day07-集合【迭代器、增强for、泛型】

1.数组与集合的区别

1.数组的长度是固定的，集合的长度是可变的。

2.数组中可以存储任何类型的元素（基本类型和引用类型），而集合中只能存储引用类型的元素；

应用场景：
1.在知道存储的元素的个数的情况下，可以使用数组；

2.否则，就使用集合。

ArrayList<Integer> list=new ArrayList<Integer>();

list.add(1);

2.集合

在Java中提供了很多个集合，因为用户要求存储数据的方式的不同，就需要使用不同的集合来存储数据。

3.Collertion接口

方法：

1.boolean add（E e）：向集合中添加一个元素，添加成功就返回true，否则返回false；

2.boolean addAll（Collection<? extends E> c): 把集合C中的所有元素都添加到当前集合中；

3.void clear（）：清空集合中的元素，集合中就没有元素了，但是几个对象还是存在；

4.boolean contains（Object o）：判断数据o在集合中是否存在，如果存在返回true,否则返回false；

5.boolean isEmpty():判断集合是否为空，如果为空就返回true,否则就返回false；

6.boolean remove（Object o):从集合中移除数据o，如果移除成功，就返回true，否则返回false；

7.int size（）：得到集合的大小，就是集合中元素的个数，也叫集合的长度；

8.Object[] toArray():把集合中的元素都放到一个数组中，并返回这个数组；

4.迭代器 Iterator

JDK给所有的集合提供了一种统一的遍历元素的方式，这个方式迭代的方式。

使用步骤：

1.通过几个对象得到 迭代器对象（就相当于八级和中的元素都拷贝到迭代器对象中了）；

2.循环遍历迭代器中的每个元素；
    1.先判断下个位置是否有元素；
    2.如果有，就得到下一个位置的元素；

public static void main（String[] args){
    Collection<String> c=new ArrayList<String>();

    c.add("冬冬");
    c.add（“冰冰”）；
//使用步骤：
// 1.通过集合对象得到 迭代器对象；
Iterator<String> it=c.iterator();
// 2.循环遍历 迭代器中的每个元素；
// 1.循环判断下一个位置是否有元素；
while(it.hasNext()){
        //如果有，就得到下一个位置的元素。
        String name=it.next();
        System.out.println(name);
    }
}

5.并发修改的异常

java.util.ConcurrentModificationException:并发修改的异常

原因：

当通过集合对象得到迭代器时，长度是集合原来的长度，迭代器按照原来的长度开始遍历元素，但是当使用迭代器遍历元素时，又向集合中改变原长度，迭代器就不知道怎么遍历剩下的元素了，所以在用迭代器时不能改变集合长度；

解决方法：

1.当使用迭代器遍历元素时，如果想改变集合的长度，使用迭代器去改变；

2.当使用集合遍历元素，如果想改变集合的长度，使用集合对象去改变；

遍历ArrayList时，使用for循环遍历；

示例代码：
  /*
    * 1.当使用迭代器遍历元素时,如果想改变集合的长度,使用迭代器去改变;
     */
    private static void method02() {
        ArrayList<String> c = new ArrayList<String>();

            c.add("冬冬");
            c.add("冰冰");
            c.add("圆圆");
            c.add("娇妹");

    // 使用步骤:
    // 1.通过集合对象得到 迭代器对象(就相当于把集合中的元素都拷贝到迭代器对象中了);
    ListIterator<String> it = c.listIterator();

    // 2.循环遍历 迭代器中的每个元素:
    // 1.循环判断下一个位置是否有元素;
        int i = 0;

        while (it.hasNext()) {
            i++;
    // 在使用迭代器遍历元素时,向集合对象中添加元素(修改集合的长度)
    if (i == 2) {
        // c.add("冠希哥");
        it.add("冠希哥");
    }

    // 2.如果有,就得到下一个位置的元素.
    String name = it.next();
        System.out.println(name);
            }
        System.out.println(c);
        }

    /*
     * 2.当使用集合遍历元素,如果想改变集合的长度,使用集合对象去改变;
     */
    private static void method03() {
        ArrayList<String> c = new ArrayList<String>();

            c.add("冬冬");
            c.add("冰冰");
            c.add("圆圆");
            c.add("娇妹");

    for (int i = 0; i < c.size(); i++) {
            if (i == 1) {
            c.add("冠希哥");
            }
    System.out.println(c.get(i));
        }
    }

6.增强for循环

是for循环语句的一种格式；可以简化传统的for循环语句的代码；

格式：

for（数据类型 变量名 ： 数组/集合）{
    循环体；
}

示例代码：

public class ForPlusDemo{
    public static void main（String[] args){
        int[] iArray={1,2,3,4,5}
    //每次从数组中取出一个元素赋值给变量i
        for(int i: iArray){
            //打印元素
        System.out.println(i);
    }
  }
}

示例代码2：

public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(3);
    list.add(5);
    list.add(7);

    for (Integer integer : list) {
        System.out.println(integer);
    }

}

1.当使用增强for循环遍历数组时，底层使用的普通的for循环语句；

2.当使用增强for循环遍历集合组时，底层使用迭代器；

7.泛型

表示一种不确定的数据类型；

泛型可以用在：

类，方法，接口上面；

好处：

提高代码的重复使用率；
1.泛型用在类的上面
    class D<T>{
        T t;
    }
2.泛型用在方法的上面
    修饰符 泛型 返回值类型 方法名（泛型 参数名）{
        ....
    }
3.泛型用在接口上面
    修饰符 interface 接口名（泛型）{
        .....
        修饰符 返回值类型 方法名（泛型 t）；
    }
4.泛型的通配符
    ？ 是泛型的的通配符；
    通配符的第一种写法：
        ArrayList<? extends T>:?表示T类型或者T的子类类型
        boolean  addAll(Collection< ? extends E> c):?表示E类型或者E的子类类型

        boolean  addAll(Collection< ? extends Person> c):
    通配符的第二种写法：
        ArrayList<? super T> :?表示T类型或者T的父类类型

        ArrayList<? super Student> :?表示Student类型或者Student的父类类型;

        // 这个?表示的类型与后面<>中的类型一样
        ArrayList<?> c2 = new ArrayList<String>();