存东西找集合(Collection)的大儿子李斯特List

数组爸爸：我是个容器 只能装一种类型的数据，我天生容积不可变；可以存储基本类型的数据，也可存储引用的类型的数据
集合儿子：我也是个容器 我啥都能装 不同类型的数据也可以，我吃多少装多少。只能存储引用数据类型

集合：他整个是一个集合体系，由很多，不同类型的集合组成。

单列集合：Collection
        Collection collection=new ArrayList();
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 23);
        Student s3 = new Student("王五", 23);
  往集合种添加元素add()
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);

 //返回值的意思，是否添加成功
        boolean aaa = collection.add("aaa");
        //把两个集合的元素，归并到一个集合里面去
        boolean b = collection.addAll(collection2);
        //删除集合中的元素
        collection.remove("aaa");
        //A集合去removeAll(B集合) A集合中会移除掉两个集合中的交集元素，如果有交集元素被删除了，返回true
        //没有交集元素可删除返回false
        boolean b = collection.removeAll(collection2);
 //清空集合中的所有元素
        collection2.clear();

集合:
只能存储引用数据类型/*

  collection.add(100); //自动装箱
    collection.add(Integer.valueOf(200));
    collection.add(new Integer(300));
    collection.add(400);
    collection.add(500);

    //判断集合中有没有该元素
    boolean b = collection.contains(400);
     //判断集合是否为空
    boolean empty = collection2.isEmpty();
     //size()获取集合的长度
    int size = collection.size();
   // System.out.println(size);
   //A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
        Collection collection2 = new ArrayList();
         //把集合转换成数组
        Object[] objects = collection.toArray();

        Integer object = (Integer) objects[0];
        System.out.println(object);

        //把数组转换成集合
        Integer[] arr={10,20,30,40};
        Collection collection1=  new ArrayList();
        for (int i = 0; i < arr.length; i++) {
            collection1.add(arr[i]);
        }

        //把数组转换成集合
        List integers = Arrays.asList(arr);

Collection 集合的遍历方式

 //先要获取一个迭代器，通过迭代器去遍历集合中元素
    Iterator iterator = collection.iterator();
    System.out.println(iterator);
   // Iterator 接口 迭代器
  /*  boolean hasNext ()
    如果仍有元素可以迭代，则返回 true。
    E next ()
    返回迭代的下一个元素。*/
   // iterator.next();
    while (iterator.hasNext()){
        Object next = iterator.next();
        System.out.println(next);
    }

List 接口中特有的方法

List ：允许元素重复

  /*  void add ( int index, E element)
    在列表的指定位置插入指定元素（可选操作）。*/

  /*  E get ( int index)
    返回列表中指定位置的元素。*/

  /*  int indexOf (Object o)
    返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 - 1。*/

   /* ListIterator<E> listIterator ()
    返回此列表元素的列表迭代器（按适当顺序）。*/

   /* List<E> subList ( int fromIndex, int toIndex)
    返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。*/

根据指定的索引，来添加元素

list.add(0, 100);
System.out.println(list);

//根据索引获取集合中的元素
Object o = list.get(list.size() - 1);
System.out.println(o);

根据起始索引和终止索引，截取一段元素，放到新集合中

 List list1 = list.subList(2, 6);

遍历List集合的三种方式

     //方式1
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
        System.out.println("-------------------------");
        //方式2.List 有一个自己的迭代器 ListIterator
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println("---------------------------");
        //方式3：for循环遍历
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }

//方式2.List 有一个自己的迭代器 ListIterator
        /*ListIterator 中的两个特有方法
        *boolean hasPrevious ()
        如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
        E previous ()
        返回列表中的前一个元素。
        //要进行反向迭代之前，要先进行正向迭代

        */
        ListIterator listIterator = list.listIterator();
        //正向迭代
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println("-----------------");

        //反向迭代
       // ListIterator listIterator2 = list.listIterator();
        while (listIterator.hasPrevious()){
            Object previous = listIterator.previous();
            System.out.println(previous);

        }

ConcurrentModificationException 并发修改异常

我们在使用迭代器遍历，那么当集合中元素添加完毕，通过集合对象，获取迭代，那么这个迭代器，预先就已经知道你集合中的元素个数了。然后你使用迭代器，遍历，那么迭代器就会按照原先的顺序进行遍历，可是你在遍历途中，要添加一个元素就会打乱迭代器，预先设定好的顺序，就会抛出这个并发修改异常

   ListIterator listIterator = list.listIterator();
    while (listIterator.hasNext()) {
        Object obj = listIterator.next();
        String str = (String) obj;
        if (str.equals("world")) {
            //list.add("javaEE");
            listIterator.add("javaEE"); //使用迭代器添加或删除的方法
        }
    }

    //
    System.out.println(list);
    //那么怎么来处理这个并发修改异常呢？两种处理方式，
    //处理方式1.你用迭代器 遍历，那么你就使用迭代器自带的添加或删除元素的方法,来操作集合

    //2.你使用for循环来做
    for (int i = 0; i < list.size(); i++) {
        Object obj = list.get(i);
        String str = (String) obj;
        if (str.equals("world")) {
            list.add("javaEEEEE");
        }
    }
    
    System.out.println(list);