集合collection、list

集合
集合的作用：就是用来存储数据。
变量 数组
数组的优缺点：
优点：1 可以存储多个同类型的元素
2 存储地址连续
缺点：
1 初始化之后长度不可变
2 只能存储同种类型的元素
3 数组存储的元素是有限的
从操作的角度来说：数组的 添加 和删除效率低 查找的效率比较高。
12 23 34 45 30 25
面向对象思想编程的核心是什么？
1 类的设计
2 对象的创建以及对象的相互调用
集合的特点：
1 长度不限
2 只可以存储对象
3 元素可以是有序或无序
4 元素可以是单列也可是有映射关系的双列
5 可以对存储在其中的元素进行比较

1 Collection
Collection 是集合的根接口 集合表示一组被称为其元素的对象。 一些集合允许重复元素，而其他集合不允许
Collection的常用方法：

Collection的基本操作

public class CollectionDemo {
     
    public static void main(String[] args) {
     
        //创建集合
        Collection c = new ArrayList();
        //1 ：添加元素  元素只能是对象
        c.add(1);//此处存储的 是基本类型的包装类
        c.add("java");
        c.add(true);
        c.add(2.3);
        //c.clear();//清空集合中的所有元素
        //判断集合中是否包含某一个元素
        boolean b = c.contains("jav");
        System.out.println(b+"----");
        //判断集合是否为空  为空返回true
        boolean isEmpty= c.isEmpty();
        System.out.println(isEmpty+"=====");
        //从集合中移除某一个元素
        c.remove(true);
        // 获取集合中元素的 个数
        System.out.println(c.size());
        //2 集合的 遍历
        Object[] obj = c.toArray();
        //2.1. 普通for
        for(int i = 0 ; i < obj.length;i++){
     
            System.out.println(obj[i]);
        }
        // 2.2. foreach
//        for(Object o:c){
     
//            System.out.println(o);
//        }
    }
}

Collection的高级方法

public static void main(String[] args) {
     
    Collection c1 = new ArrayList();
    Collection c2 = new ArrayList();
    c1.add("java");
    c1.add("HTML");
    c1.add("CSS");
    c1.add("JS");
    c2.add("spring");
    c2.add("springmvc");
    c2.add("cloud");

   // c1.addAll(c2);//将c2中的每一个元素作为独立的个体添加到c1中
    System.out.println(c1.containsAll(c2));// c1是否包含c2的所有的元素
    //c1.removeAll(c2);//从c2中移除c2中的所有元素
    c2.add("java");
    c2.add("js");
    c1.retainAll(c2);// 取c1和c2的交集  并保存在c1中
    Object[] arr= c1.toArray();
    for(int i  = 0 ; i < arr.length;i++){
     
        System.out.println(arr[i]);
    }
}

public class CollectionDemo2 {
     
    public static void main(String[] args) {
     
        Collection c1 = new ArrayList();
        Collection c2 = new ArrayList();
        c1.add("java");
        c1.add("HTML");
        c1.add("CSS");
        c1.add("JS");
        c2.add("spring");
        c2.add("springmvc");
        c2.add("cloud");
        c1.addAll(c2);//将c2中的每一个元素作为独立的个体添加到c1中
        c2.add("java");
        c2.add("js");
        //使用迭代器来迭代遍历集合

//       if(iter.hasNext()){
     
//          Object obj =  iter.next();
//           System.out.println(obj);
//       }
//        if(iter.hasNext()){
     
//            Object obj =  iter.next();
//            System.out.println(obj);
//        }
//        for(Iterator iter =  c1.iterator();iter.hasNext();){
     
//            Object obj =  iter.next();
//            System.out.println(obj);
//        }
//一般常用while来进行迭代

        Iterator iter =  c1.iterator();
        while(iter.hasNext()){
     
            Object obj =  iter.next();
            System.out.println(obj);
        }
    }
}

default void remove()
从底层集合中删除此迭代器返回的最后一个元素（可选操作）。

Iterator iter =  c1.iterator();
while(iter.hasNext()){
     
    Object obj =  iter.next();
    c1.remove("java");//在迭代的过程中，通过集合对象修改集合的元素
    System.out.println(obj);
}

并发修改异常
使用Collection保存自定义对象

public static void main(String[] args) {
     
    Collection collection = new ArrayList();
    Student stu1 =new Student("张三",22);
    Student stu2 = new Student("李四",20);
    collection.add(stu1);
    collection.add(stu2);
    //使用迭代器来迭代
   Iterator iter =  collection.iterator();
   while(iter.hasNext()){
     
       Object obj = iter.next();
       System.out.println(obj);
   }
}

迭代器的图示

List
有序集合（也称为序列 ）。 该界面的用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。
List的特点：
1 元素是有序的
2 列表通常允许重复的元素


List集合的有序：元素的迭代顺序和添加顺序是一致的

public static void main(String[] args) {
     
    List list = new ArrayList();
    list.add(1);
    list.add(3);
    list.add(2);
    list.add(0);
   Iterator iter =  list.iterator();
   while(iter.hasNext()){
     
       Object obj = iter.next();
       System.out.println(obj);
   }
}

List中的元素是可重复的

public static void main(String[] args) {
     
    List list = new ArrayList();
    list.add(1);
    list.add(3);
    list.add(2);
    list.add(0);
    list.add(1);
    list.add(2);
    list.add(null);
    list.add(null);
   Iterator iter =  list.iterator();
   while(iter.hasNext()){
     
       Object obj = iter.next();
       System.out.println(obj);
   }
}

并且可以保存null值 且可以保存多个null

public class ListDemo {
     
    public static void main(String[] args) {
     
        List list = new ArrayList();
        list.add(1);
        list.add(3);
        list.add(2);
        list.add(0);
        list.add(1);
        list.add(2);
        list.add(null);
        list.add(null);//add方法是将元素添加到集合的末尾
        list.add(2,"java");//在2号位置添加元素
        List list1 = new ArrayList();
        list1.add("html");
        list1.add("css");
        //list.addAll(list1);//将list1中的元素添加到list的末尾
        list.addAll(5,list1);
        for(int i = 0 ; i <list.size();i++){
     
            System.out.println(list.get(i));// 获取集合指定位置的元素
        }

        System.out.println("------------------------");
       //indexOf(Object  o)
        //返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
        System.out.println(list.indexOf(1));//从前往后 查找元素第一次出现的 索引
        System.out.println(list.indexOf(10));
        System.out.println(list.lastIndexOf(1));//从后往前 查找元素第一次出现的索引 索引的计数是从前往后的
        //set(int   index, Eelement)
        //用指定的元素（可选操作）替换此列表中指定位置的元素
        list.set(2,"spring");// 修改指定位置的元素为传入的新元素
        System.out.println("------------------------");
        Iterator iter =  list.iterator();
        while(iter.hasNext()){
     
            Object obj = iter.next();
            System.out.println(obj);
        }
        System.out.println("------------------------");
        //subList(int  fromIndex, int  toIndex)
        List list2 = list.subList(2,5);//前闭后开
        Iterator iter2 =  list2.iterator();
        while(iter2.hasNext()){
     
            Object obj = iter2.next();
            System.out.println(obj);
        }

ListIterator listIterator()
返回列表中的列表迭代器（按适当的顺序）。

    //ListIterator listIterator()  返回列表中的列表迭代器（按适当的顺序）。
        ListIterator listIterator = list.listIterator();
       // 用于允许程序员沿任一方向遍历列表的列表的迭代器，
        while(listIterator.hasNext()){
     //从前往后遍历
           Object obj = listIterator.next();
           if(obj.equals(0)){
     
            //   list.remove(3);//在迭代器进行迭代的时候  不要使用集合对象取修改集合的元素
               list.add("aaa");
         //      listIterator.set("java");//慎用
//               listIterator.add("java");
           //    listIterator.previous();//指针回退
              // System.out.println(o);
           }
           // System.out.println(list.size()+"----------");
            System.out.println(obj);
        }

解决并发修改异常 使用普通for进行遍历及修改

for(int i = 0 ; i < list.size();i++){
     
    if(i == 3){
     
        list.add("aaaa");
        list.set(3,"bbbb");
    }
    System.out.println(list.get(i));
}

增强for循环 的底层是迭代器

Collection ：
 添加：add addAll
 判断：isEmpty contains
 元素个数： size
 修改：set
 移除： remove
 迭代：Iterator hasNext next
List ：
 特点：有序 可重复
 获取：可以根据元素的索引来获取元素
 移除 修改
 迭代： ListIterator
 查询： 查询元素在序列中第一次出现的索引 indexOf lastIndexOf
 迭代器迭代集合时,不允许对集合进行同步的修改操作（添加 删除）
List迭代器的原码分析：

使用迭代器来修改集合中的元素

// 用于允许程序员沿任一方向遍历列表的列表的迭代器，
 while(listIterator.hasNext()){
     //从前往后遍历
    Object obj = listIterator.next();
    if(obj.equals(0)){
     
       listIterator.set("java");//慎用 此处执行的是修改操作 此时已经将3号位置的元素修改为了java
        listIterator.previous();//但是course 已经跳过了3号位置 指向了4 所以我们需要回退重新获取3号位置的新值
    }else{
     
        System.out.println(obj);
    }
 }

添加

while(listIterator.hasNext()) {
     //从前往后遍历
    Object obj = listIterator.next();
    if (obj.equals(0)) {
     
        listIterator.add("java");//慎用
        listIterator.previous();
    }
    System.out.println(obj);
}

删除

while(listIterator.hasNext()) {
     //从前往后遍历
    Object obj = listIterator.next();
    if (obj.equals(0)) {
     
        listIterator.remove();//慎用
       // listIterator.previous();
    }else{
     
        System.out.println(obj);
    }
}

并发修改异常
 使用普通for解决
 使用迭代器进行迭代，同时使用迭代器进行修改