集合

集合是一种容器，用来装数据，但大小可变

• Collection：单列集合，每个元素（数据）只包含1个值
• Map：双列集合，每个元素包含两个值（键值对）
  

Collection集合特点

• List集合特点：其中的元素有序（添加时的顺序）、可重复、有索引
• Set系列集合：元素无序、不重复、无索引
  LinkedHashSet：有序，不重复，无索引
  TreeSet：按大小默认升序排序，不重复，无索引
  

遍历方式

1、迭代器遍历

迭代器是遍历集合的专用方式（数组没有），Java中代表是Iterator

public class Traversaldemo3 {
    public static void main(String[] args) {
        //Collection的遍历方式1：迭代器遍历
        Collection<String> c = new ArrayList<>();
        c.add("方源");
        c.add("武庸");
        c.add("龙公");
        c.add("白凝冰");
        c.add("黑楼兰");
        System.out.println(c);//[方源, 武庸, 龙公, 白凝冰, 黑楼兰]
        //                        it
        //获取迭代器
        Iterator<String> it = c.iterator();
        //使用while循环遍历
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

2、增强for循环

public class Traversaldemo4 {
    public static void main(String[] args) {
        //Collection的遍历方式2：增强for循环遍历
        Collection<String> c = new ArrayList<>();
        c.add("方源");
        c.add("武庸");
        c.add("龙公");
        c.add("白凝冰");
        c.add("黑楼兰");

        for(String s : c){
            System.out.println(s);
        }
        
        String[] names = {"方源","武庸","龙公","白凝冰","黑楼兰"};
        for(String s : names){
            System.out.println(s);
        }
    }
}

3、Lambda表达式

public class Traversaldemo5 {
    public static void main(String[] args) {
        //Collection的遍历方式3：Lambda遍历
        Collection<String> c = new ArrayList<>();
        c.add("方源");
        c.add("武庸");
        c.add("龙公");
        c.add("白凝冰");
        c.add("黑楼兰");

        /*c.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        //c.forEach(s -> System.out.println(s));
        c.forEach(System.out::println);
    }
}

三种遍历区别

认识并发修改异常问题

遍历集合时若有增删集合元素的行为时可能出现的业务异常

public class Traversaltest6 {
    public static void main(String[] args) {
        //认识并发修改异常问题
        ArrayList<String> list = new ArrayList<>();
        list.add("Java入门");
        list.add("Java进阶");
        list.add("红莲魔尊");
        list.add("星宿仙尊");
        list.add("元始仙尊");
        list.add("巨阳仙尊");
        list.add("乐土仙尊");
        list.add("炼天魔尊");
        list.add("盗天魔尊");
        list.add("幽魂魔尊");
        System.out.println( list);
        //需求：删除全部仙尊
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.contains("仙尊")) {
                list.remove(s);
            }
        }
        System.out.println(list);//出现异常

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("Java入门");
        list2.add("Java进阶");
        list2.add("红莲魔尊");
        list2.add("星宿仙尊");
        list2.add("元始仙尊");
        list2.add("巨阳仙尊");
        list2.add("乐土仙尊");
        list2.add("炼天魔尊");
        list2.add("盗天魔尊");
        list2.add("幽魂魔尊");
        System.out.println( list2);
        //需求：删除全部仙尊
        for (int i = 0; i < list2.size(); i++) {
            String s = list2.get(i);
            if (s.contains("仙尊")) {
                list2.remove(s);
                i--;//方法1：删除元素，i--，重新开始遍历
            }
        }
        System.out.println(list2);

        ArrayList<String> list3 = new ArrayList<>();
        list3.add("Java入门");
        list3.add("Java进阶");
        list3.add("红莲魔尊");
        list3.add("星宿仙尊");
        list3.add("元始仙尊");
        list3.add("巨阳仙尊");
        list3.add("乐土仙尊");
        list3.add("炼天魔尊");
        list3.add("盗天魔尊");
        list3.add("幽魂魔尊");
        System.out.println( list3);
        //需求：删除全部仙尊
        //方法2：倒着遍历并删除（要支持索引）
        for (int i = list3.size()-1; i >=0; i--) {
            String s = list3.get(i);
            if (s.contains("仙尊")) {
                list3.remove(s);
            }
        }
        System.out.println(list3);

        ArrayList<String> list4 = new ArrayList<>();
        list4.add("Java入门");
        list4.add("Java进阶");
        list4.add("红莲魔尊");
        list4.add("星宿仙尊");
        list4.add("元始仙尊");
        list4.add("巨阳仙尊");
        list4.add("乐土仙尊");
        list4.add("炼天魔尊");
        list4.add("盗天魔尊");
        list4.add("幽魂魔尊");
        System.out.println( list4);
        //需求：删除全部仙尊
        //方案1：迭代器遍历并删除：默认存在并发修改异常
        //解决：使用迭代器自己的方法删除
        Iterator<String> it = list4.iterator();
        while(it.hasNext()){
            String s = it.next();
            if (s.contains("仙尊")) {
                //list4.remove(s);
                it.remove();
            }
        }
        System.out.println(list4);

        ArrayList<String> list5 = new ArrayList<>();
        list5.add("Java入门");
        list5.add("Java进阶");
        list5.add("红莲魔尊");
        list5.add("星宿仙尊");
        list5.add("元始仙尊");
        list5.add("巨阳仙尊");
        list5.add("乐土仙尊");
        list5.add("炼天魔尊");
        list5.add("盗天魔尊");
        list5.add("幽魂魔尊");
        System.out.println( list5);
        //需求：删除全部仙尊
        //方案2和3：增强for和Lambda（都没有办法解决）
        //增强for和Lambda只适合遍历，不能遍历并删除
        /*for (String s : list5) {
            if (s.contains("仙尊")) {
                list5.remove(s);
            }
        }*/
        //Lambda
        list5.forEach(s -> {
            if (s.contains("仙尊")) {
                list5.remove(s);
            }
        });

        System.out.println(list5);
    }
}

List集合

支持的遍历方式

• for循环
• 迭代器
• 增强for循环
• Lambda表达式

ArrayList底层原理

• ArrayList底层基于数组存储数据

数组特点：
1、查询速度快（根据索引查询速度快）
2、增删效率低

ArrayList在第一次添加数据时才开始扩容，初始扩容最小容量为10，每次扩容大小为扩容前的1.5倍

LinkedList底层原理

• LinkedList底层基于==链表（双链表）==存储数据

特点：
1、查询慢
2、增删效率相对高，对首尾元素的增删改查速度极快

LinkedList新增了很多首尾操作的特有方法

应用场景：

• 可用于设计队列
  只在首尾增删元素
• 设计栈
  只在首部增删元素