【Java从入门到大牛】集合进阶上篇

待我称王封你为后i 2024-04-26 02:49 88阅读 0赞

> ? 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> ? 系列专栏：[Java从入门到大牛][Java]  
> ? 首发时间：2023年7月29日  
> ? 欢迎关注?点赞?收藏?留言?  
> ? 一以贯之的努力 不得懈怠的人生

#### 目录 ####

*  集合体系概述
 *  Collection的常用方法
 *  Collection的遍历方式
 *   *  迭代器
     *  增强for
     *  lambda表达式
 *  List集合
 *   *  特点、特有方法
     *  遍历方式
     *  ArrayList集合的底层原理
     *  LinkedList集合的底层原理
 *  Set集合
 *   *  特点
     *  HashSet集合的底层原理
     *  LinkedHashSet集合的底层原理
     *  TreeSet集合
 *  集合的并发修改异常问题

## 集合体系概述 ##

**集合体系结构**  
![在这里插入图片描述][f05d40ba6918498d89e75ef2668a2d35.png]

**单列集合和双列集合**

![在这里插入图片描述][5689cef43cff465694a18f1d31d858fc.png]

*  Collection 代表单列集合，每个元素（数据）只包含一个值
 *  Map 代表双列集合，每个元素包含两个值，即一个键值对

**Collection集合体系**

![在这里插入图片描述][2ba9c3d861d54cc3bc6bb80587b2b79a.png]

**Collection集合特点**

**List 系列集合**：添加的元素是有序的、可重复的、有索引的

*  ArrayList、LinkedList：有序、可重复、有索引

**Set 系列集合**：添加的元素是无序的、不重复的、无索引的

*  HashSet：无序、不重复、无索引
 *  LinkedHashSet：**有序**、不重复、无索引
 *  TreeSet：**按照大小默认升序排序**、不重复、无索引

## Collection的常用方法 ##

**为什么要先学 Collection 的常用方法 ？**

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

**Collection 的常见方法如下：**  
![在这里插入图片描述][99985f0a50ed4c6f8182b63c9de6c056.png]

**具体应用**

import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    
    /**
        目标：掌握Collection集合的常用API
     */
    public class CollectionTest2API {
        
        public static void main(String[] args) {
        
            Collection<String> c = new ArrayList<>(); // 多态写法
            // 1.public boolean add(E e)：添加元素, 添加成功返回true。
            c.add("java1");
            c.add("java1");
            c.add("java2");
            c.add("java2");
            c.add("java3");
            System.out.println("c: " + c);
    
            // 2.public void clear()：清空集合的元素。
            //c.clear();
            //System.out.println("c: " + c);
    
            // 3.public boolean isEmpty()：判断集合是否为空 是空返回true,反之。
            System.out.println("isEmpty: " + c.isEmpty()); // false
    
            // 4.public int size()：获取集合的大小。
            System.out.println("size: " + c.size());
    
            // 5.public boolean contains(Object obj)：判断集合中是否包含某个元素。
            System.out.println("contains(\"java1\"): " + c.contains("java1")); // true
            System.out.println("contains(\"Java1\"): " + c.contains("Java1")); // false
    
            // 6.public boolean remove(E e)：删除某个元素:如果有多个重复元素默认删除前面的第一个！
            System.out.println("remove(\"java1\"): " + c.remove("java1"));
            System.out.println("c: " + c);
    
            // 7.public Object[] toArray()：把集合转换成数组
            Object[] arr1 = c.toArray();
            System.out.println("arr1: " + Arrays.toString(arr1));
    
            String[] arr2 = c.toArray(new String[c.size()]);
            System.out.println("arr2: " + Arrays.toString(arr2));
    
            System.out.println("--------------------------------------------");
            // 把一个集合的全部数据倒入到另一个集合中去。
            Collection<String> c1 = new ArrayList<>();
            c1.add("java1");
            c1.add("java2");
            Collection<String> c2 = new ArrayList<>();
            c2.add("java3");
            c2.add("java4");
            c1.addAll(c2); // 就是把c2集合的全部数据倒入到c1集合中去。
            System.out.println("c1: " + c1);
            System.out.println("c2: " + c2);
        }
    }

![在这里插入图片描述][eb0778ac224341f192c4922432b68cf6.png]

## Collection的遍历方式 ##

### 迭代器 ###

**迭代器概述**

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

**Collection集合获取迭代器的方法**  
![在这里插入图片描述][249e3c33ad52441888187a76d03a5cf9.png]

**Iterator迭代器中的常用方法**

![在这里插入图片描述][ac84fe622bbe41f686c78a5913929c77.png]

**具体应用**

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /**
        目标：Collection集合的遍历方式一：使迭代器Iterator遍历
     */
    public class CollectionDemo01 {
        
        public static void main(String[] args) {
        
            Collection<String> c = new ArrayList<>();
            c.add("小明");
            c.add("小红");
            c.add("小刚");
            System.out.println(c);
    
            // 使用迭代器遍历集合
            // 1、从集合对象中获取迭代器对象
            Iterator<String> it = c.iterator();
    
            // 2、我们应该使用循环结合迭代器遍历集合
            while (it.hasNext()){
        
                String ele = it.next();
                System.out.println(ele);
            }
        }
    }

![在这里插入图片描述][41007632191a4caaa52edeb9ee6534d3.png]

### 增强for ###

**增强版for循环的格式**

for (元素的数据类型 变量名 : 数组或者集合) {
        
    }
    
    Collection<String> c = new ArrayList<>();
    ...
    for (String s : c) {
        
    	System.out.println(s);
    }

*  增强 for 可以用来遍历集合或者数组
 *  增强 for 遍历集合，本质就是迭代器遍历集合的简化写法

**增强for修改变量值会出现什么问题 ？**

修改增强 for 中的变量值不会影响到集合中的元素

### lambda表达式 ###

**Lambda表达式遍历集合**

得益于 JDK8 开始的新技术 Lambda 表达式，提供了一种更简单、更直接的方式来遍历集合

**需要使用 Collection 的如下方法来完成**  
![在这里插入图片描述][08db98109f604c7d865286ce617c9fe6.png]

![在这里插入图片描述][d811bef541824298acbea8a30349d97b.png]

**具体应用**

import java.util.ArrayList;
    import java.util.Collection;
    
    /**
         目标：Collection集合的遍历方式三：JDK8开始新增的Lambda表达式
     */
    public class CollectionDemo03 {
        
        public static void main(String[] args) {
        
            Collection<String> c = new ArrayList<>();
            c.add("小明");
            c.add("小红");
            c.add("小刚");
    
            c.forEach(s -> System.out.println(s));
            System.out.println("-----------------------");
            c.forEach(System.out::println);
        }
    }

![在这里插入图片描述][8e5d423673b94f78804be45130d27be0.png]

**案例：遍历集合中的自定义对象**

需求：展示多部电影信息

分析

1.  每部电影都是一个对象，多部对象要使用集合装起来
2.  遍历集合中的电影对象，输出每部电影的详情信息

**案例代码实现**

**Movie 类**

public class Movie {
        
        private String name;
        private double score;
        private String actor;
    
        public Movie() {
        
        }
    
        public Movie(String name, double score, String actor) {
        
            this.name = name;
            this.score = score;
            this.actor = actor;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public double getScore() {
        
            return score;
        }
    
        public void setScore(double score) {
        
            this.score = score;
        }
    
        public String getActor() {
        
            return actor;
        }
    
        public void setActor(String actor) {
        
            this.actor = actor;
        }
    
        @Override
        public String toString() {
        
            return "Movie{" +
                    "name='" + name + '\'' +
                    ", score=" + score +
                    ", actor='" + actor + '\'' +
                    '}';
        }
    }

**测试类**

import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     *       目标：完成电影信息的展示
     */
    public class CollectionTest04 {
        
        public static void main(String[] args) {
        
            // 1、创建一个集合容器负责存储多部电影对象
            Collection<Movie> movies = new ArrayList<>();
            movies.add( new Movie("《肖生克的救赎》" , 9.7 ,  "罗宾斯"));
            movies.add( new Movie("《霸王别姬》" , 9.6 ,  "张国荣、张丰毅"));
            movies.add( new Movie("《阿甘正传》" , 9.5 ,  "汤姆.汉克斯"));
            System.out.println(movies);
    
            for (Movie movie : movies) {
        
                System.out.println("电影名：" + movie.getName());
                System.out.println("评分：" + movie.getScore());
                System.out.println("主演：" + movie.getActor());
                System.out.println("---------------------------------------------");
            }
        }
    }

**执行结果**

![在这里插入图片描述][06cb27ca51604e1a9a5abadcd75399ce.png]

**集合存储对象的原理**

![在这里插入图片描述][dc3206ef65df454bb1eab07a6aca9315.png]  
可以发现，集合中存储的是元素对象的地址

## List集合 ##

### 特点、特有方法 ###

**List系列集合特点：有序、可重复、有索引**

*  ArrayList：有序、可重复、有索引
 *  LinkedList：有序、可重复、有索引

**List集合的特有方法**

List 集合因为支持索引，所以多了很多与索引相关的方法，当然，Collection 的功能 List 也都继承了  
![在这里插入图片描述][4ccca9e7ddca4f6080b62d50f1df8547.png]  
**具体应用**

import java.util.ArrayList;
    import java.util.List;
    
    /**
          目标：掌握List系列集合的特点，以及其提供的特有方法
     */
    public class ListTest1 {
        
        public static void main(String[] args) {
        
            // 1.创建一个ArrayList集合对象（有序、可重复、有索引）
            List<String> list = new ArrayList<>();  // 一行经典代码
            list.add("蜘蛛精");
            list.add("至尊宝");
            list.add("至尊宝");
            list.add("牛夫人");
            System.out.println(list); // [蜘蛛精, 至尊宝, 至尊宝, 牛夫人]
    
            // 2.public void add(int index, E element): 在某个索引位置插入元素。
            list.add(2, "紫霞仙子");
            System.out.println(list);
    
            // 3.public E remove(int index): 根据索引删除元素,返回被删除元素
            System.out.println(list.remove(2));
            System.out.println(list);
    
            // 4.public E get(int index): 返回集合中指定位置的元素。
            System.out.println(list.get(3));
    
            // 5.public E set(int index, E element): 修改索引位置处的元素,修改成功后，会返回原来的数据
            System.out.println(list.set(3, "牛魔王"));
            System.out.println(list);
        }
    }

![在这里插入图片描述][4068b817ac5c45a49e5de7b111847502.png]

### 遍历方式 ###

**List集合支持的遍历方式**

1.  for 循环（因为 List 集合有索引）
2.  迭代器
3.  增强 for 循环
4.  Lambda 表达式

**具体应用**

import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    /**
        拓展：List系列集合的遍历方式
     */
    public class ListTest2 {
        
        public static void main(String[] args) {
        
            List<String> list = new ArrayList<>();
            list.add("糖宝宝");
            list.add("蜘蛛精");
            list.add("至尊宝");
    
            //（1）for循环
            for (int i = 0; i < list.size(); i++) {
        
                String s = list.get(i);
                System.out.println(s);
            }
            System.out.println("--------------------");
    
            //（2）迭代器
            Iterator<String> it = list.iterator();
            while (it.hasNext()) {
        
                System.out.println(it.next());
            }
            System.out.println("--------------------");
    
            //（3）增强for循环（foreach遍历）
            for (String s : list) {
        
                System.out.println(s);
            }
            System.out.println("--------------------");
            
            //（4）JDK 1.8开始之后的Lambda表达式
            list.forEach(s -> {
        
                System.out.println(s);
            });
        }
    }

![在这里插入图片描述][0bbd27e014994f1d8dc8e95930963cb0.png]

### ArrayList集合的底层原理 ###

**ArrayList的特点**

*  基于数组实现的，数组的特点就是查询快、增删慢
 *  查询速度快（注意：是根据索引查询数据快）：查询数据通过地址值和索引定位，查询任意数据耗时相同
 *  删除效率低：可能需要把后面很多的数据进行前移
 *  添加效率极低：可能需要把后面很多的数据后移，再添加数据；或者也可能需要进行数组的扩容

**ArrayList集合的底层原理**

1.  利用无参构造器创建的集合，会在底层创建一个默认长度为 0 的数组
2.  添加第一个元素时，底层会创建一个新的长度为 10 的数组
3.  存满时，会扩容 1.5 倍
4.  如果一次添加多个元素，1.5 倍还放不下，则新创建数组的长度以实际为准

**ArrayList集合适合的应用场景**

*  ArrayList 适合：根据索引查询数据，比如根据随机索引取数据（高效），或者数据量不是很大时
 *  ArrayList 不适合：数据量大的同时，又要频繁地进行增删操作

### LinkedList集合的底层原理 ###

**LinkedList集合的底层原理**

*  基于双链表实现的  
    ![在这里插入图片描述][1d1e91613d3e4104bbdb1fb3a09b71ef.png]
 *  特点：查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的

**LinkedList新增了很多首尾操作的特有方法**  
![在这里插入图片描述][b72fe21faa0c4fc39d9c6e75223e985c.png]

**LinkedList集合的应用场景**

1.  可以用来设计队列，队列的特点是先进先出、后进后出，队列只是在首尾增删元素，所以用 LinkedList 来实现很合适
2.  可以用来设计栈，栈的特点是后进先出、先进后出，栈只是在首部增删元素，用 LinkedList 来实现很合适

**具体应用**

import java.util.LinkedList;
    
    /**
     * 目标：掌握LinkedList集合的使用
     */
    public class ListTest3 {
        
        public static void main(String[] args) {
        
            // 1、创建一个队列
            LinkedList<String> queue = new LinkedList<>();
            // 入队
            queue.addLast("第1号");
            queue.addLast("第2号");
            queue.addLast("第3号");
            queue.addLast("第4号");
            System.out.println(queue);
            // 出队
            System.out.println(queue.removeFirst());
            System.out.println(queue.removeFirst());
            System.out.println(queue.removeFirst());
            System.out.println(queue);
            System.out.println("--------------------------------------------------");
    
            // 2、创建一个栈对象
            LinkedList<String> stack = new LinkedList<>();
            // 压栈(push)
            stack.push("第1颗子弹");		// addFirst
            stack.push("第2颗子弹");
            stack.push("第3颗子弹");
            stack.push("第4颗子弹");
            System.out.println(stack);
            // 出栈(pop)
            System.out.println(stack.pop());	// removeFirst
            System.out.println(stack.pop());
            System.out.println(stack);
        }
    }

![在这里插入图片描述][09bf4fa3e0d14f4b9b0a90edcbf472d0.png]

## Set集合 ##

### 特点 ###

Set 系列集合特点：无序——添加数据的顺序和获取出的数据顺序不一致；不重复；无索引

*  HashSet：无序、不重复、无索引
 *  LinkedHashSet：有序、不重复、无索引
 *  TreeSet：排序、不重复、无索引

注意：Set 要用到的常用方法，基本上就是 Collection 提供的，自己几乎没有额外新增一些常用功能

### HashSet集合的底层原理 ###

**什么是哈希值 ？**

*  就是一个 int 类型的数值，Java 中每个对象都有一个哈希值
 *  Java 中的所有对象，都可以调用 Object 类提供的 hashCode 方法，返回该对象自己的哈希值
    
        public int hashCode(): 返回对象的哈希码值

**对象哈希值的特点**

*  同一个对象多次调用 hashCode() 方法返回的哈希值是相同的
 *  不同的对象，它们的哈希值一般不相同，但也有可能会相同（哈希碰撞）

**HashSet集合的底层原理**

*  基于哈希表实现
 *  哈希表是一种增删改查数据性能都较好的数据结构

**哈希表**

*  JDK8 之前，哈希表 = 数组+链表
 *  JDK8 开始，哈希表 = 数组+链表\+红黑树

**JDK8之前HashSet集合的底层原理，基于哈希表：数组+链表**

1.  创建一个默认长度为 16 的数组，默认加载因子为 0.75，数组名为 table
2.  使用元素的哈希值对数组的长度求余计算出应存入的位置
3.  判断当前位置是否为 null，如果是 null 直接存入
4.  如果不为 null，表示当前位置有元素，则调用 equals 方法比较。相等，则不存；不相等，则存入数组  
    JDK8 之前，新元素存入数组，占据老元素位置，老元素挂下面  
    JDK8 开始之后，新元素直接挂在老元素下面
5.  当数组存满到 16\*0.75=12 时，就自动扩容，每次扩容为原先的两倍

**如果数组快占满了，会出什么问题？该咋办？**

链表会过长，导致查询性能降低，这时候就需要扩容了

**JDK8开始HashSet集合的底层原理，基于哈希表：数组+链表+红黑树**

JDK8 开始，当链表长度超过 8，且数组长度 >= 64时，自动将链表转成红黑树

**深入理解HashSet集合去重复的机制**

HashSet 集合默认不能对内容一样的两个不同对象去重复

比如有内容一样的两个学生对象存入到 HashSet 集合中去，HashSet 集合是不能去重复的

怎么让 HashSet 集合能够实现对内容一样的两个不同对象也能去重复？

如果希望 Set 集合认为两个内容一样的对象是重复的，必须重写对象的 hashSet() 和 equals() 方法

**案例：Set集合去重复**

**需求**：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合，要求学生对象的成员变量值一样，我们就认为是同一个对象

**分析**

1.  定义学生类，创建 HashSet 集合对象，创建学生对象
2.  把学生添加到集合
3.  在学生类中重写两个方法，hashCode() 和 equals()，自动生成即可
4.  遍历集合（增强for）

自动生成步骤：在编辑器界面右击鼠标，选择 Generate，再选择 equals() and hashCode() 即可

**代码示例**

**Student 类**

import java.util.Objects;
    
    public class Student {
        
        private String name;
        private int age;
        private double height;
    
        public Student() {
        
        }
    
        public Student(String name, int age, double height) {
        
            this.name = name;
            this.age = age;
            this.height = height;
        }
    
        // 只要两个对象内容一样就返回true
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age && Double.compare(student.height, height) == 0 && Objects.equals(name, student.name);
        }
    
        // 只要两个对象内容一样，返回的哈希值就是一样的
        @Override
        public int hashCode() {
        
            // 姓名 年龄 身高计算哈希值的
            return Objects.hash(name, age, height);
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public double getHeight() {
        
            return height;
        }
    
        public void setHeight(double height) {
        
            this.height = height;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", height=" + height +
                    '}';
        }
    }

**测试类**

import org.w3c.dom.ls.LSOutput;
    
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * 目标：自定义的类型的对象，比如两个内容一样的学生对象，如果让HashSet集合能够去重复！
     */
    public class SetTest3 {
        
        public static void main(String[] args) {
        
            Set<Student> students = new HashSet<>();
            Student s1 = new Student("至尊宝", 28, 169.6);
            Student s2 = new Student("蜘蛛精", 23, 169.6);
            Student s3 = new Student("蜘蛛精", 23, 169.6);
            System.out.println(s2.hashCode());
            System.out.println(s3.hashCode());
    
            Student s4 = new Student("牛魔王", 48, 169.6);
            students.add(s1);
            students.add(s2);
            students.add(s3);
            students.add(s4);
    
            for(Student s : students) {
        
                System.out.println(s);
            }
        }
    }

![在这里插入图片描述][93d895d2649848d4962785798a387d6a.png]

### LinkedHashSet集合的底层原理 ###

*  依然是基于哈希表（数组、链表、红黑树）实现的
 *  但是，它的每个元素都额外地多了一个双链表的机制记录它前后元素的值

### TreeSet集合 ###

*  特点：不重复、无索引、可排序（默认升序排序，按照元素的大小，由小到大排序）
 *  底层是基于红黑树实现的排序

**注意：**

*  对于数值类型：Integer、Double 默认按照数值本身的大小进行升序排序
 *  对于字符串类型：默认按照首字符的编号升序排序
 *  对于自定义类型如 Student 对象，TreeSet 默认是无法直接排序的

**自定义排序规则**

TreeSet 集合存储自定义类型的对象时，必须指定排序规则，支持如下两种方式来指定比较规则

*  方式一：让自定义的类（如学生类）实现 Comparable 接口，重写里面的 compareTo 方法来指定比较规则
    
        public class Student implements Comparable<Student>
 *  方式二：通过调用 TreeSet 集合有参数构造器，可以设置 Comparator 对象（比较器对象，用于指定比较规则）
    
        public TreeSet(Comparator<? super E> comparator)

两种方式中，关于返回值的规则：

*  如果认为第一个元素大于第二个元素，返回正整数即可
 *  如果认为第一个元素小于第二个元素，返回负整数即可
 *  如果认为第一个元素等于第二个元素，返回 0 即可，此时 TreeSet 集合只会保留一个元素，认为两者重复

注意：如果类本身有实现 Comparable 接口，TreeSet 集合同时也自带比较器，默认使用集合自带的比较器排序

**具体应用**

import java.util.Set;
    import java.util.TreeSet;
    
    /**
     * 目标：掌握TreeSet集合的使用。
     */
    public class SetTest4 {
        
        public static void main(String[] args) {
        
            Set<Integer> set1 = new TreeSet<>();
            set1.add(6);
            set1.add(5);
            set1.add(5);
            set1.add(7);
            System.out.println(set1);
    
            // TreeSet就近选择自己自带的比较器对象进行排序
    //        Set<Student> students = new TreeSet<>(new Comparator<Student>() {
        
    //            @Override
    //            public int compare(Student o1, Student o2) {
        
    //                // 需求：按照身高升序排序
    //                return Double.compare(o1.getHeight() , o2.getHeight());
    //            }
    //        });
            
            Set<Student> students = new TreeSet<>(( o1,  o2) ->  Double.compare(o1.getHeight() , o2.getHeight()));
            students.add(new Student("蜘蛛精",23, 169.7));
            students.add(new Student("紫霞",22, 169.8));
            students.add(new Student("至尊宝",26, 165.5));
            students.add(new Student("牛魔王",22, 183.5));
            System.out.println(students);
        }
    }

![在这里插入图片描述][5de6d4ffeac94012aceaea5454091e2d.png]

## 集合的并发修改异常问题 ##

**集合的并发修改异常**

*  使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误
 *  由于增强 for 循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强 for 循环遍历集合，又在同时删除集合中的数据时，程序也会出现并发修改异常的错误

**怎么保证遍历集合的同时删除数据而不出bug？**

*  使用迭代器遍历集合，但用迭代器自己的删除方法删除数据即可
 *  如果能用 for 循环遍历时，可以倒着遍历并删除；或者从前往后遍历，但删除元素后做 `i--` 的操作

注意：使用增强 for 和 Lambda 表达式无法解决 bug

**具体应用**

import java.util.*;
    
    /**
     * 目标：理解集合的并发修改异常问题，并解决。
     */
    public class CollectionTest1 {
        
        public static void main(String[] args) {
        
            List<String> list = new ArrayList<>();
            list.add("王麻子");
            list.add("小李子");
            list.add("李爱花");
            list.add("张全蛋");
            list.add("晓李");
            list.add("李玉刚");
            System.out.println(list);
    
            // 需求：找出集合中全部带“李”的名字，并从集合中删除。
    
            // 使用for循环遍历集合并删除集合中带李字的名字
    //        for (int i = 0; i < list.size(); i++) {
        
    //            String name = list.get(i);
    //            if(name.contains("李")){
        
    //                list.remove(name);
    //                i--;
    //            }
    //        }
    //        System.out.println(list);
    
    
            // 需求：找出集合中全部带“李”的名字，并从集合中删除。
            Iterator<String> it = list.iterator();
            while (it.hasNext()){
        
                String name = it.next();
                if(name.contains("李")){
        
                    // list.remove(name); // 并发修改异常的错误
                    it.remove(); // 删除迭代器当前遍历到的数据，每删除一个数据后，相当于也在底层做了i--
                }
            }
            System.out.println(list);
        }
    }

![在这里插入图片描述][c4096e278da945fcb33b4fee04c96f49.png]

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[Java]: https://blog.csdn.net/weixin_62511863/category_12365679.html?spm=1001.2014.3001.5482
[f05d40ba6918498d89e75ef2668a2d35.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d5104d4e5f894cf08fbfee01a0cbc9c1.png
[5689cef43cff465694a18f1d31d858fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0229ee71e41f466181f00baccd4c249d.png
[2ba9c3d861d54cc3bc6bb80587b2b79a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/68bedc6a18fd43aabae81a647ecca9c6.png
[99985f0a50ed4c6f8182b63c9de6c056.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e11b5b98a8164782a669ac3fa544dfff.png
[eb0778ac224341f192c4922432b68cf6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/145bfa2dba1b487db949ea3b862e9eee.png
[249e3c33ad52441888187a76d03a5cf9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/567c7b29ffbb4113ae812ab0dbcc38f5.png
[ac84fe622bbe41f686c78a5913929c77.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/557ab3999817485d887a722f46097000.png
[41007632191a4caaa52edeb9ee6534d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/80e88382eae848beb052f65d07f66e40.png
[08db98109f604c7d865286ce617c9fe6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/2cf0e1b88b894212a106ff944247a4d6.png
[d811bef541824298acbea8a30349d97b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1cbf8e74ced646e0bdd1804e25ccfbc0.png
[8e5d423673b94f78804be45130d27be0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/a0c1a749d0d14c7d9004519db470e9a4.png
[06cb27ca51604e1a9a5abadcd75399ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/9e7624a3fd6342f189e0185295a968f7.png
[dc3206ef65df454bb1eab07a6aca9315.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/f13b0f47ca5441f89a9b5984c4fa0e70.png
[4ccca9e7ddca4f6080b62d50f1df8547.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/dd1afb8b131d43bbb01add921e04858f.png
[4068b817ac5c45a49e5de7b111847502.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8dac120966b246819e97855bb88957ac.png
[0bbd27e014994f1d8dc8e95930963cb0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/856b9490aaaf443f86e026debf0545bf.png
[1d1e91613d3e4104bbdb1fb3a09b71ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e1c766814d714cbd8104157ace19b252.png
[b72fe21faa0c4fc39d9c6e75223e985c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3ad3eae14cbc48a49007d81c1744b757.png
[09bf4fa3e0d14f4b9b0a90edcbf472d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/4bb7cf69a3694f72a14fbe305e7d8c22.png
[93d895d2649848d4962785798a387d6a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/96ae57570ab0491c9a80afb40349eae1.png
[5de6d4ffeac94012aceaea5454091e2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/ab612b3f764148c4884ded0c682a92bb.png
[c4096e278da945fcb33b4fee04c96f49.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/f7117afbb6a849b29c6686bd86d577e8.png