集合框架（Collection单列集合（常用功能，三种遍历方式及通过并发修改异常认识他们的区别）、Map双列集合）

集合框架

集合虽然看着多，但实际上用的只有几个，知道每一类集合的整体特点，学习每一类集合的功能即可

集合框架分为单列集合和双列集合

Collection

List,Set是接口，下面的是实现类

java 复制代码

package com.itheima.demo6collection;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class CollectionDemo1 {
    public static void main(String[] args) {
        //目标：搞清楚Collection集合的整体特点
        //1、List家族的集合：有序、可重复、有索引
        List<String> list = new ArrayList<>();//多态：List<String>是接口，ArrayList<E>是实现类
        list.add("hello");
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);//打印结果：[hello, hello, world, java]  可重复、按照前后顺序打印
        String rs =list.get(0);
        System.out.println(rs);

        //2、Set家族的集合：无序、不可重复、无索引
        Set<String> set = new HashSet<>();//多态：List<String>是接口，ArrayList<E>是实现类
        set.add("hello");
        set.add("hello");
        set.add("world");
        set.add("java");
        System.out.println(set);//打印结果：[world, java, hello]，无序、不可重复
    }
}

Collection的常用功能

Collection是单列集合的祖宗，它规定的方法（功能）是全部单列集合都会继承的

java 复制代码

package com.itheima.demo6collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionDemo2 {
    public static void main(String[] args) {
        //目标：搞清楚Collection提供的通用集合功能
        Collection<String> list = new ArrayList<>();//多态

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("java");
        System.out.println(list);//[hello, world, java, java]

        //获取元素个数
        int size = list.size();
        System.out.println(size);//4

        //删除集合元素
        list.remove("java");
        System.out.println(list);

        //判断集合是否为空
        System.out.println(list.isEmpty());//false

        //清空集合
        list.clear();
        System.out.println(list);//[]

        //判断集合是否包含某个元素
        System.out.println(list.contains("world"));//false  已清空

        //集合转数组
        Object[] arr = list.toArray();
        //System.out.println(arr);//输出地址
        System.out.println(Arrays.toString(arr));//使用 Arrays.toString() 方法将数组转换为可读的字符串格式
    }
}

Collection集合的三种遍历方式

java 复制代码

package com.itheima.demo6collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTravalDemo3 {
    public static void main(String[] args) {
        //目标：掌握Collection集合的遍历方式一：迭代器遍历
        Collection<String> names = new ArrayList<>();
        names.add("唐三");
        names.add("霍雨浩");
        names.add("牧尘");

        //1、得到这个集合的迭代器对象
        Iterator<String> it = names.iterator();//迭代器类型是Iterator，泛型是<String>
//        System.out.println(it.next());//唐三
//        System.out.println(it.next());//霍雨浩
//        System.out.println(it.next());//牧尘

        //2、使用一个while循环来遍历
        while (it.hasNext()) {
            String name = it.next();//刚开始指向第一个数据，取完当前数据会马上移动到下一个位置
            System.out.println(name);
        }
    }
}

java 复制代码

package com.itheima.demo6collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTravalDemo4 {
    public static void main(String[] args) {
        //目标：掌握Collection集合的遍历方式二：增强for
        Collection<String> names = new ArrayList<>();
        names.add("唐三");
        names.add("霍雨浩");
        names.add("牧尘");
        names.add("小舞");


        for(String name : names)//该变量名name在循环开始时声明，循环结束后自动销毁
        {
            System.out.println(name);
        }

        String[] namesArray = {"唐三","霍雨浩","牧尘","小舞"};
        for(String name1 : namesArray){
            System.out.println(name1);
        }
        }
}

java 复制代码

package com.itheima.demo6collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

public class CollectionTravalDemo5 {
    public static void main(String[] args) {
        //目标：掌握Collection集合的遍历方式三：Lambda
        Collection<String> names = new ArrayList<>();
        names.add("唐三");
        names.add("霍雨浩");
        names.add("牧尘");
        names.add("小舞");

//        names.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
        
        //简化后
        //names.forEach(s -> System.out.println(s));

        //实例方法引用简化
        names.forEach(System.out::println);
        }
}

三种遍历方式的区别

通过并发修改异常来区别三种遍历方式

当集合ArrayList 中删除某个元素时，该元素后面的所有元素会自动向前移动一位。（前提是该集合可以索引）

java 复制代码

package com.itheima.demo6collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTravalTest6 {
    public static void main(String[] args) {
        //目标：认识并发修改异常问题，搞清楚每种遍历的区别
        ArrayList<String> list = new ArrayList<>();
        list.add("java入门");
        list.add("java进阶");
        list.add("java实战");
        list.add("java就业");
        list.add("java面试");
        list.add("C++");
        list.add("python");

        //需求1：删除全部java
        //当集合ArrayList 中删除某个元素时，该元素后面的所有元素会自动向前移动一位。（前提是该集合可以索引）
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.contains("java")) {
                list.remove(s);
            }
        }
        System.out.println(list);//[java进阶, java就业, C++, python]  出现并发修改异常问题

        //[java入门, java进阶, java实战, java就业, java面试, C++, python]

        System.out.println("===============================================================");

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("java入门");
        list2.add("java进阶");
        list2.add("java实战");
        list2.add("java就业");
        list2.add("java面试");
        list2.add("C++");
        list2.add("python");

        //需求1：删除全部java
        //解决方案1
        for (int i = 0; i < list2.size(); i++) {
            String s = list2.get(i);
            if (s.contains("java")) {
                list2.remove(s);
                i--;
            }
        }

        System.out.println("===============================================================");

        ArrayList<String> list3 = new ArrayList<>();
        list3.add("java入门");
        list3.add("java进阶");
        list3.add("java实战");
        list3.add("java就业");
        list3.add("java面试");
        list3.add("C++");
        list3.add("python");

        //解决方案2：倒着遍历并删除（前提是支持索引）
        for (int i = list3.size() - 1; i >= 0; i--) {
            String s = list3.get(i);
            if (s.contains("java")) {
                list3.remove(s);
            }
        }
        System.out.println(list3);

        System.out.println("===============================================================");

        ArrayList<String> list4 = new ArrayList<>();
        list4.add("java入门");
        list4.add("java进阶");
        list4.add("java实战");
        list4.add("java就业");
        list4.add("java面试");
        list4.add("C++");
        list4.add("python");

        //需求1：删除全部java
        //方案一：迭代器遍历并删除默认也存在并发修改异常问题
        //可以解决：使用迭代器自己的方法来删除
        Iterator<String> it = list4.iterator();
        while (it.hasNext()) {
            String s = it.next();
            if (s.contains("java")) {
                it.remove();//使用迭代器自己的方法来删除
            }
        }
        System.out.println(list4);

        System.out.println("===============================================================");

        //需求1：删除全部java
        //方案二和三：用增强for还有Lambda(都没有办法解决)
        ArrayList<String> list5 = new ArrayList<>();
        list5.add("java入门");
        list5.add("java进阶");
        list5.add("java实战");
        list5.add("java就业");
        list5.add("java面试");
        list5.add("C++");
        list5.add("python");

        for(String s : list5){
            if (s.contains("java")) {
                list5.remove(s);
            }
        }
        System.out.println(list5);//并发异常
    }
}

区别结论：如果要遍历集合并删除，这个集合又没有索引的情况下，只能用迭代器（增强for与Lambda无法实现），若集合有索引可以使用"i--"或倒着遍历；

增强for与Lambda只适合做遍历，不适合做遍历并删除