Java学习记录 Day14（List集合、泛型、for-each、可变参数）

左手的ㄟ右手 2022-02-04 13:21 266阅读 0赞

### 文章目录 ###

*  Day 14
 *   *  集合
     *  集合框架的并发异常
     *  函数式接口
     *  泛型
     *  for-each循环
     *  可变参数
     *  ArrayList嵌套

# Day 14 #

2019年5月3日。  
这是我学习Java的第十四天。  
这一天，我学到了以下的知识。

## 集合 ##

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类

集合和数组的区别有

1.  长度区别:  
    数组的长度是固定的而集合的长度是可变的
2.  存储数据类型的区别:  
    数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
3.  内容区别:  
    **数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素**

在集合框架中，Collection是顶层父接口，List和Set为子接口，List的实现类又有ArrayList、LinkedList、Vector，而Set的实现类有HashSet、LinkedHashSet、TreeSet，集合框架图如下所示  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]  
首先，讲解Collection顶层父接口下的方法

*  **Collection**  
    常用的成员方法
    
     *  添加功能
        
         *  `boolean add(Object obj)`：添加一个元素
         *  `boolean addAll(Collection c)`：添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
     *  删除功能
        
         *  `void clear()`：移除所有元素
         *  `boolean remove(Object o)`：移除一个元素
         *  `boolean removeAll(Collection c)`：移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素，如果没有交集元素 则删除失败 返回false
     *  判断功能
        
         *  `boolean contains(Object o)`：判断集合中是否包含指定的元素
         *  `boolean containsAll(Collection c)`：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
         *  `boolean isEmpty()`：判断集合是否为空
     *  获取功能
        
         *  `Iterator<E> iterator()`：获取一个迭代器（主要用于遍历集合）  
            \- `iterator().next()`：让迭代器的指针下移  
            \- `iterator().hasNext()`：判断迭代器的指针下面是否为空
     *  长度功能
        
         *  `int size()`：元素的个数
     *  交集功能
        
         *  `boolean retainAll(Collection c)`：获取两个集合的交集元素(交集：两个集合都有的元素)
     *  转换功能
        
         *  `Object[] toArray()`：将集合转换为数组（依次获取集合中的每一个元素）

其次，讲解List子接口下的方法

*  **List**  
    List，特点为元素有序，并且每一个元素都存在一个索引，元素可以重复  
    常用的特有方法
    
     *  `void add(int index,E element)`：在指定索引处添加元素
     *  `E remove(int index)`：移除指定索引处的元素 ，返回的是移除的元素
     *  `E get(int index)`：获取指定索引处的元素
     *  `E set(int index,E element)`：更改指定索引处的元素 返回的而是被替换的元素
     *  `ListIterator<E> listIterator()`：获取一个list迭代器  
        \- `boolean hasPrevious()`：是否存在前一个元素  
        \- `E previous():`：返回列表中的前一个元素  
        \- 注意： 通过以上两个方法，可以实现反向遍历 但是注意，要在成反向遍历之前，要先进行正向遍历 ，这样迭代器的指针才能移到最后。如果直接反向遍历是没有效果的 ，因为指针默认位置就在最前面，它前面没有元素

最后，讲解List接口下的实现类（Set接口和Set接口下的实现类暂时不讲解）

*  **ArrayList**  
    底层数据结构是数组，查询快，增删慢。  
    线程不安全，效率高。
 *  **LinkedList**  
    底层数据结构是链表，查询慢，增删快。  
    线程不安全，效率高。
 *  **Vector**  
    底层数据结构是数组，查询快，增删慢。  
    线程安全，效率低。

## 集合框架的并发异常 ##

当我们用Iterator这个迭代器遍历采用hasNext方法和next方法，用集合去修改集合，就会出现并发修改异常（ConcurrentModificationException）  
原因是我们的迭代依赖与集合，当我们往集合中添加好了元素之后，获取迭代器 ，那么迭代器已经知道了集合的元素个数，这个时候你在遍历的时候又突然想给集合里面加一个元素（用的是集合的add方法），那迭代器不同意，就报错了  
解决方案如下

*  **用ListIterator迭代器遍历，并且用迭代器自带的add方法添加元素，那就不会报错了，步骤如下**  
    \- 迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)  
    \- 集合遍历元素，集合修改元素
 *  **使用for循环遍历集合，添加元素，不会报错**

## 函数式接口 ##

JDK1.8之后引入的一种机制，若接口中只有一个抽象方法，那么就可以使用Lanbda表达式来简写匿名内部类

代码如下

public class MyTest3 {
        public static void main(String[] args) {
            ArrayList list = new ArrayList();
            list.add(100);
            list.add(100);
            list.add(100);
            list.add(100);
            list.add(100);
            list.add(100);
            list.add(100);
            list.add(100);
            list.add(200);
            list.add(100);
    
            //Consumer con= new Consumer() {
            //     @Override
            //     public void accept(Object o) {
            //         System.out.println(o);
            //     }
            // };
            //函数式接口：接口中只有一个抽象方法，那么你就可以使用 Lambda 表达式来简写匿名内部类
            Consumer con = (obj) -> System.out.println(obj);
    
            Consumer con2 = System.out::println;
            //JDK1.8 对应函数式接口，可以使用Lambda 表达式来简写
            //list.forEach(con2);
            list.forEach(new Consumer() {
                @Override
                public void accept(Object o) {
                    System.out.println(o);
                }
            });
    
        }
    }

## 泛型 ##

JDK1.5之后引入的一种机制，是把类型明确工作推迟到创建对象或调用方法时，再去明确的一种机制，泛型可以提高代码的灵活性，扩展性，把问题提前到编译器  
**格式**：`<数据类型> 这里的数据类型只能是引用数据类型`  
**优点**

1.  把运行时期的问题提前到了编译期间（泛型只在编译期有效 ，但在运行期就擦除了）
2.  避免了强制类型转换
3.  优化了程序设计，解决了黄色警告线

**使用**

*  类  
    \- 概述：把泛型定义在方法上  
    \- 格式：`public <泛型类型> 返回类型 方法名(泛型类型 变量名`  
    \- 定义
    
        public class Phone {
        
        /**
         * 泛型方法
         */
        public <E> void show(E e){
        	System.out.println(e);
        }
 *  接口  
    \- 概述：把泛型定义在接口上  
    \- 格式：`public interface 接口名<泛型类型>`  
    \- 定义
    
        //一般定义
        public interface Inter<T> {
        
        public abstract void show(T t) ;
        }
        ——————————————————————————————————————
        //特殊定义一: 在定义子类的时候，已经可以明确数据类型了
        //public class InterImpl implements Inter<String> {
        //
        //	@Override
        //	public void show(String t) {
        //		System.out.println(t);
        //	}
        //
        //}
        ——————————————————————————————————————
        //特殊定义二: 在定义子类的时候，还不知道到底使用什么数据类型，这个时候就需要将这个子类也定义成泛型
        public class InterImpl<T> implements Inter<T>  {
        @Override
          public void show(T t) {
        	System.out.println(t);
         }
        }

**通配符**：

*  `泛型通配符<?>`：任意类型，如果没有明确，那么就是Object以及任意的Java类了
 *  `? extends E`：向下限定，？表示的是E及其子类
 *  `? super E`：向上限定，？表示的是E及其父类

## for-each循环 ##

JDK1.5之后引入的一种机制，是简化数组和Collection集合的遍历  
**格式**

for(元素数据类型 变量 : 数组或者Collection集合) {
    		使用变量即可，该变量就是元素
    	}

**使用步骤**

1.  先确定容器中的元素的数据类型
2.  确定容器的名字
3.  注意：使用新式for循环在遍历时，若想在集合中添加或删除元素，同样会报出并发修改异常的错误（解决方案如上）

## 可变参数 ##

若在定义方法的时候不知道该定义多少个参数，就可以使用可变参数  
**格式**：`修饰符 返回值类型 方法名(数据类型… 变量名){}`

**注意事项**

1.  这里的变量其实是一个数组
2.  如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

**范例**

public static int add(int... a){
    	
    	// 定义一个累加变量
    	int sum = 0 ;
    	
    	for(int s : a ){
    		sum += s ;
    	}
    	
    	return sum;
    }

**特殊**  
在集合中，存在一个与可变参数产生联动的方法：`public static <T> List<T> asList(T... a)`  
该方法可以把多个数组转换成集合，但需要注意的是：

*  若传入一个或多个int\[\]数组，则集合里面存放的是数组的引用
 *  若传入一个或多个Integer\[\]数组，则会把数组的元素取出来并放到集合中
 *  若通过这个方法获取到了一个转换过来的集合，则这个集合的长度是固定的，即只能从集合中取出元素，而不能增删元素

## ArrayList嵌套 ##

类似于数组的遍历，集合也有相似的遍历方式（即用两层for循环进行遍历）

代码如下

public class MyTest {
        public static void main(String[] args) {
            //A:
            //需求：
            //我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
            //但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。
            //而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢 ?
            //集合嵌套之ArrayList嵌套ArrayList
    
            ArrayList<Student> javaList = new ArrayList<>();
            javaList.add(new Student("张三1", 23));
            javaList.add(new Student("张三2", 23));
            javaList.add(new Student("张三3", 23));
    
            ArrayList<Student> webList = new ArrayList<>();
            webList.add(new Student("张三4", 23));
            webList.add(new Student("张三5", 23));
            webList.add(new Student("张三6", 23));
    
            ArrayList<Student> linuxList = new ArrayList<>();
            linuxList.add(new Student("张三7", 23));
            linuxList.add(new Student("张三8", 23));
            linuxList.add(new Student("张三9", 23));
    
            //创建一个大的集合，大的集合放小的集合
            ArrayList<ArrayList<Student>> maxList = new ArrayList<>();
            maxList.add(javaList);
            maxList.add(webList);
            maxList.add(linuxList);
    
            //
            //遍历：普通for循环
            for (int i = 0; i < maxList.size(); i++) {
                ArrayList<Student> minList = maxList.get(i);
                for (int j = 0; j < minList.size(); j++) {
                    Student student = minList.get(j);
                    System.out.println(student.getName() + "===" + student.getAge());
                }
    
            }
            System.out.println("----------------------------------------------------------");
            //新式for循环遍历
            for (ArrayList<Student> students : maxList) {
                for (Student student : students) {
                    System.out.println(student.getName() + "===" + student.getAge());
                }
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]: /images/20220204/c53a35fde74e494280ee83c9ea243cbe.png