Java 集合进阶（Collection、List集合）

偏执的太偏执、 2024-03-02 08:02 17阅读 0赞

### 一、集合概述和分类 ###

#### 1、集合概述 ####

前面我们已经学习过了ArrayList集合，但是除了ArrayList集合，Java还提供了很多种其他的集合，如下图所示：

![4273592a530e40a38ec6a5459c7e0b7d.png][]

#### 2、集合的分类 ####

> **上图的集合可以分为两类：**
> 
> 1.  一类是单列集合，元素是一个一个的；
> 2.  一类是双列集合，元素是一对一对的。

![1e9c71ef2e4f4d6e98b80b6d2168c438.png][]

### 二、Collection集合 ###

#### 1、Collection集合概述 ####

Collection是单列集合的根接口，Collection接口下面又有两个子接口List接口、Set接口，List和Set下面分别有不同的实现类，如下图所示：

**Collection集合体系**

![3aaaa47829a342089ad19a889729210c.png][]

**Collection集合的特点**

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

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

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

**HashSet**：无序、不重复、无索引；**LinkedHashSet**：**有序**、不重复、无索引。

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

代码演示：

public class CollectionTest1 {
        public static void main(String[] args) {
            //简单确认一下Collection集合的特点
            ArrayList<String> list = new ArrayList<>(); //存取顺序一致，可以重复，有索引
            list.add("java1");
            list.add("java2");
            list.add("java1");
            list.add("java2");
            System.out.println(list); //[java1, java2, java1, java2] 
    
            HashSet<String> list = new HashSet<>(); //存取顺序不一致，不重复，无索引
            list.add("java1");
            list.add("java2");
            list.add("java1");
            list.add("java2");
            list.add("java3");
            System.out.println(list); //[java3, java2, java1] 
    
        }
    }

#### 2、Collection集合的常用方法 ####

**Collection API如下：**

![a238f58ec5db4cc4a75f061c5ff791bd.png][]

/**
     * 为啥要先学Collection的常用方法？
     *      Collection是单列集合的祖宗，它规定的方法(功能)是全部单列集合都会继承的。
     */
    public class CollectionTest2API {
        public static void main(String[] args) {
            Collection<String> c = new ArrayList<>(); // 多态写法(Collection是接口，不能直接创建对象，需通过其子类来实现)
            // 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);
    
            // 2、public void clear()：清空集合中所有的元素。
            // c.clear();
            // System.out.println(c);
    
            // 3、public boolean isEmpty()：判断集合是否为空，是空返回true，反之。
            System.out.println(c.isEmpty()); // false
    
            // 4、public int size()：获取集合的大小。
            System.out.println(c.size());
    
            // 5、public boolean contains(Object obj)：判断集合中是否包含某个元素。
            System.out.println(c.contains("java1")); // true
            System.out.println(c.contains("Java1")); // false
    
            // 6、public boolean remove(E e)：删除某个元素(如果有多个重复元素，默认删除前面的第一个！)。
            System.out.println(c.remove("java1"));
    
            // 7、public Object[] toArray()：把集合转换成数组。
            Object[] arr = c.toArray();
            System.out.println(Arrays.toString(arr));
    
            // 指定转为字符串
            String[] arr2 = c.toArray(new String[c.size()]);
            System.out.println(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);
            System.out.println(c2);
        }
    }

#### 3、Collection集合的遍历方式 ####

之前学习过的集合遍历方式（**for循环**），只能遍历List集合，不能遍历Set集合，因为以前的普通for循环遍历需要索引，只有List集合有索引，而Set集合没有索引。

##### **3.1 迭代器遍历方式** #####

> 迭代器就是一种集合的通用遍历方式。
> 
> 遍历就是一个一个的把容器中的元素访问一遍。
> 
> 迭代器在Java中的代表是**Iterator**，迭代器是集合的专用的遍历方式。

**Collection集合迭代器**

![04153fc81ae14eb7bbfb5eb857472b7c.png][]

**Iterator中的常用方法**

![94367824f8434dc6b51fd799afeccf77.png][]

/**
     * Collection集合的遍历方式
     * 方式一：迭代器概述：
     *      迭代器是用来遍历集合的专用方式(数组没有迭代器)，在Java中迭代器的代表是Iterator。
     */
    public class CollectionDemo01 {
        public static void main(String[] args) {
            Collection<String> c = new ArrayList<>();
            c.add("赵敏");
            c.add("小昭");
            c.add("素素");
            c.add("灭绝");
            System.out.println(c); //[赵敏, 小昭, 素素, 灭绝]
    
            //第一步：先获取迭代器对象
            //解释：Iterator就是迭代器对象，用于遍历集合的工具)
            Iterator<String> it = c.iterator();
            
            //第二步：用于判断当前位置是否有元素可以获取
            //解释：hasNext()方法返回true，说明有元素可以获取；反之没有
            while(it.hasNext()){
                //第三步：获取当前位置的元素，然后自动指向下一个元素.
                String e = it.next();
                System.out.println(s);
            }
        }
    }

> 迭代器代码的原理如下：
> 
>  *  当调用iterator()方法获取迭代器时，当前指向第一个元素；
>  *  hasNext()方法则判断这个位置是否有元素，如果有则返回true，进入循环；
>  *  调用next()方法获取元素，并将当月元素指向下一个位置；
>  *  等下次循环时，则获取下一个元素，以此类推。

**迭代器执行流程**

![bd209cf965dd43cf8192a041afdef754.png][]

**总结：**

1.迭代器的默认位置在哪里？

**Iterator<E> iterator()：得到迭代器对象，默认指向当前集合的索引0。**

2.迭代器如果取元素越界会出现什么问题？

**会出现NoSuchElementException异常。**

##### 3.2 增强for循环遍历集合 #####

刚才我们学习了迭代器遍历集合，但是这个代码其实还有一种更加简化的写法，叫做增强for循环。

格式如下：

![699008c3b13c43d49984d941098b251a.png][]

**增强for循环：既可以遍历集合也可以遍历数组。**

举例说明：

Collection<String> list = new ArrayList<>();
    ...
    for(String ele : list) {
        System.out.println(ele);
    }

/**
     * Collection集合的遍历方式
     * 方式二：增强for循环
     *      * 增强for可以用来遍历集合或者数组。
     *      * 增强for遍历集合，本质就是迭代器遍历集合的简化写法。
     */
    public class CollectionDemo02 {
        public static void main(String[] args) {
            Collection<String> c = new ArrayList<>();
            c.add("赵敏");
            c.add("小昭");
            c.add("苏苏");
            c.add("灭绝");
            System.out.println(c);
            // c = [赵敏, 小昭, 苏苏, 灭绝]
            //      ele
    
            // 使用增强for遍历集合或者数组。(简化写法：集合名.for)
            for (String ele : c) {
                System.out.println(ele);
            }
    
            System.out.println("---------------------");
    
            // 增强for循环遍历数组
            String[] names = {"东方月初", "涂山红红", "涂山雅雅", "涂山容容", "王权富贵"};
            for (String name : names) {
                System.out.println(name);
            }
        }
    }

##### 3.3 forEach遍历集合 #####

在JDK8版本以后还提供了一个forEach方法也可以遍历集合，如果下图所示：

![5c8341a93af243b985eacecf9640b81b.png][]

我们发现forEach方法的参数是一个Consumer接口，而Consumer是一个函数式接口，所以可以传递Lambda表达式。

/**
     * Collection集合的遍历方式
     * 方式三：lambda表达式
     * Lambda表达式遍历集合
     *      得益于JDK8开始的新技术Lambda表达式，提供了一种更简单，更直接的方式来遍历集合。
     */
    public class CollectionDemo03 {
        public static void main(String[] args) {
            Collection<String> c = new ArrayList<>();
            c.add("赵敏");
            c.add("小昭");
            c.add("苏苏");
            c.add("灭绝");
            System.out.println(c);
            // c = [赵敏, 小昭, 苏苏, 灭绝]
            //       s
    
            // default void forEach(Consumer<? super T> action)：集合Lambda遍历集合。
            // 原始方法(Consumer是接口，通过匿名内部类创建对象)
    //        c.forEach(new Consumer<String>() {
    //            @Override
    //            public void accept(String s) {
    //                System.out.println(s);
    //            }
    //        });
    //
    //        // Lambda简化1
    //        c.forEach((String s) -> {
    //                System.out.println(s);
    //        });
    //
    //        // Lambda简化2
    //        c.forEach(s -> {
    //            System.out.println(s);
    //        });
    //
    //        // Lambda简化3
    //        c.forEach(s -> System.out.println(s));
    
            // Lambda简化4(最终简化：println是一个方法)
            c.forEach(System.out::println);
        }
    }

##### 3.4遍历集合案例 #####

**案例：影片信息在程序中的展示**

> **需求：**
> 
> 某影院系统需要在后台存储上述三部电影，然后依次展示出来。
> 
> **分析：**
> 
> 1.定义一个电影类，定义一个集合存储电影对象。
> 
> 2.创建3个电影对象，封装相关数据，把3个对象存入到集合中去。
> 
> 3.遍历集合中的3个对象，输出相关信息。

首先，我们写一个电影类，用来描述每一部电影应该有哪些信息。

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;
        }
    
        public String toString() {
            return "Movie{name = " + name + ", score = " + score + ", actor = " + actor + "}";
        }
    }

接着，再创建一个测试类，完成上面的需求 。

/**
     * 案例：影片信息在程序中展示
     *      需求：
     *          new Movie("《肖生克的救赎》", 9.7, "罗宾斯")
     *          new Movie("《霸王别姬》", 9.6, "张国荣、张丰毅")
     *          new Movie("《阿甘正传》", 9.5, "汤姆·汉克斯")
     *          某影院系统需要子啊后台存储上述三部电影，然后依次展示出来。
     */
    public class CollectionTest4 {
        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循环遍历集合
            for (Movie movie : movies) {
                System.out.println("电影名称：" + movie.getName());
                System.out.println("评分：" + movie.getScore());
                System.out.println("主演：" + movie.getActor());
            }
        }
    }

以上代码的内存原理如下图所示：当往集合中存对象时，实际上存储的是对象的地址值。

![1d007008bf61410b940f4835f3e53614.png][]

**结论：集合中存储的是元素对象的地址。**

### 三、List系列集合 ###

#### 1、List集合概述 ####

前面我们已经把Collection通用的功能学习完了，接下来我们学习Collection下面的一个子体系List集合。如下图所示：

![a49c394f6b204fc59884ddb100dc8e11.png][]

#### 2、List集合的常用方法 ####

List集合因为支持索引，所以多了很多索引操作的独特API，其他Collection的功能List也都继承了。

![6817bd50a0d344e3b5ffcaf3ebeb7214.png][]

代码演示：

/**
     * List系列集合：
     *      添加的元素是有序、可重复、有索引。(有序：指的是存和取的时候，顺序是一样的，比如存的是：123，取出的也是123)
     *      * ArrayList、LinkedList：有序、可重复、有索引。
     */
    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 e): 修改索引位置处的元素，修改后，会返回原数据
            System.out.println(list.set(3,"牛魔王")); //牛夫人
            System.out.println(list); //[蜘蛛精, 至尊宝, 至尊宝, 牛魔王]
        }
    }

#### 3、List集合的遍历方式 ####

List集合相比于前面的Collection多了一种可以通过索引遍历的方式，所以List集合遍历方式一共有四种：

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

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++) {
                // i = 0, 1, 2
                String s = list.get(i);
                System.out.println(s);
            }
    
            // 2.迭代器
            Iterator<String> it = list.iterator();
            while (it.hasNext()) {
                System.out.println(it.next());
            }
    
            // 3.增强for循环(foreach遍历)
            for (String s : list) {
                System.out.println(s);
            }
    
            // 4.JDK 1.8开始之后的Lambda表达式
            list.forEach(s ->{
                System.out.println(s);
            });
        }
    }

#### 4、List集合的底层原理 ####

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

ArrayList集合底层是基于数组结构实现的，也就是说当你往集合容器中存储元素时，底层本质上是往数组中存储元素。 特点如下：

![840493ddeed3416fb018d138565f299d.png][]

我们知道数组的长度是固定的，但是集合的长度是可变的，这是怎么做到的呢？原理如下：

![834f9a55c17f411b820fa6c0506a8411.png][]**数组扩容**，并不是在原数组上扩容（原数组是不可以扩容的），底层是创建一个新数组，然后把原数组中的元素全部复制到新数组中去。

![0b10d60e5eff43768b2aadce25263040.png][]

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

**LinkedList集合的特点**

LinkedList底层是链表结构，链表结构是由一个一个的节点组成，一个节点由数据值、下一个元素的地址组成。如下图所示：

![41d5356817c44627b2c3e9447b04ce40.png][]

假如，现在要在B节点和D节点中间插入一个元素，只需要把B节点指向D节点的地址断掉，重新指向新的节点地址就可以了。如下图所示：

![6e7eefe7cbf04e32bdfba302d3eab12a.png][]

假如，现在想要把D节点删除，只需要让C节点指向E节点的地址，然后把D节点指向E节点的地址断掉。此时D节点就会变成垃圾，会把垃圾回收器清理掉。

![12ca2c85a5a34dbaa5ff8d7ccb7b7c7c.png][]上面的链表是单向链表，它的方向是从头节点指向尾节点的，只能从左往右查找元素，这样查询效率比较慢；还有一种链表叫做双向链表，不光可以从做往右找，还可以从右往左找。如下图所示：

![7201ff48acf0424ca4475df7764f93f4.png][]

LinkedList集合是基于双向链表实现了，所以相对于ArrayList新增了一些可以针对头尾进行操作的方法，如下图示所示：

![31a6c94f0f1947689870c549a469f043.png][]

代码如下：

/**
         目标：LinkedList集合。
    
         小结：
             LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的。
             所以提供了很多操作首尾元素的特殊API可的实以做栈和队列现。
    
             如果查询多而增删少用ArrayList集合。(用的最多的)
             如果查询少而增删首尾较多用LinkedList集合。
     */
    public class ListTest3 {
        public static void main(String[] args) {
            // LinkedList可以完成队列结构，和栈结构 （双链表）
            // 1、做一个队列：
            LinkedList<String> queue = new LinkedList<>();
            // 入队
            queue.addLast("1号");
            queue.addLast("2号");
            queue.addLast("3号");
            System.out.println(queue);
            // 出队
            // System.out.println(queue.getFirst());
            System.out.println(queue.removeFirst());
            System.out.println(queue.removeFirst());
            System.out.println(queue);
    
            System.out.println("--------------------------------------------");
    
            // 2、做一个栈：
            LinkedList<String> stack = new LinkedList<>();
            // 入栈 压栈 (push里面调的就是addFirst)
            stack.push("第1颗子弹");
            stack.push("第2颗子弹");
            stack.push("第3颗子弹");
            stack.push("第4颗子弹");
            System.out.println(stack);
    
            // 出栈  弹栈 (pop里面调的就是removeFirst)
            System.out.println(stack.pop());
            System.out.println(stack.pop());
            System.out.println(stack.pop());
            System.out.println(stack);
    
        }
    }

### 四、补充知识：集合的并发修改异常问题 ###

**问题引出**

当我们从集合中找出某个元素并删除的时候可能出现一种并发修改异常。

**哪些遍历存在问题？**

1、迭代器遍历集合且直接用集合删除元素的时候可能出现。

2、增强for循环遍历集合且直接用集合删除元素的时候可能出现。

**哪种遍历且删除元素不出现问题**

1、迭代器遍历集合，但是用迭代器自己的删除方法操作可以解决。

2、使用for循环遍历并删除元素不会存在这个问题。

/**
     * 目标：理解集合的而并发修改异常问题，并解决。
     *      并发(有多个同时进行)，修改(删除也是修改的一种)
     *
     * 集合的并发修改异常
     *      * 使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常。
     *      * 由于增强for循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强for循环遍历集合，又在同时删除
     *      集合中的数据，程序也会出现并发修改异常的错误。
     * 怎么保证遍历集合同时删除数据时不出现bug？
     *      * 使用迭代器遍历集合，但用迭代器自己的删除方式删除数据即可。
     *      * 如果能用for循环遍历时：可以倒着遍历并删除；或者从前往后遍历，但删除元素后做 i-- 操作。
     */
    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);
            // [王麻子, 小李子, 李爱华, 张全蛋, 晓丽, 李玉刚]
    
            // 需求：找出集合中全部带“李”字的名字，并从集合中删除。
    //        Iterator<String> it = list.iterator();
    //        while (it.hasNext()) {
    //            String name = it.next();
    //            if (name.contains("李")) {
    //                list.remove(name);
    //            }
    //        }
    //        System.out.println(list); // ConcurrentModificationException：并发修改异常
    
            // 使用for循环遍历集合并删除集合中带“李”字的名字。
            // [王麻子, 小李子, 李爱华, 张全蛋, 晓丽, 李玉刚]
            //    i
    //        for (int i = 0; i < list.size(); i++) {
    //            String name = list.get(i);
    //            if (name.contains("李")) {
    //                list.remove(name);
    //            }
    //        }
    //        System.out.println(list); // [王麻子, 李爱花, 张全蛋, 李玉刚]：漏删元素
    
            System.out.println("---------------------------------------------------------");
    
            // 怎么解决呢？ ConcurrentModificationException：并发修改异常
            // 使用for循环遍历集合并删除集合中带“李”字的名字。
            // [王麻子, 小李子, 李爱华, 张全蛋, 晓丽, 李玉刚]
            //    i
    //        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);
    
            System.out.println("---------------------------------------------------------");
    
            // 使用增强for循环遍历集合并删除数据，没有办法解决bug。
    //        for (String name : list) {
    //            if (name.contains("李")) {
    //                list.remove(name);
    //            }
    //        }
    //        System.out.println(list);
    
            // Lambda表达式也不行
    //        list.forEach(name -> {
    //            if (name.contains("李")) {
    //                list.remove(name);
    //            }
    //        });
    //        System.out.println(list);
        }
    }

[4273592a530e40a38ec6a5459c7e0b7d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/88c82df97aea43728ecc857f7c8a3c37.png
[1e9c71ef2e4f4d6e98b80b6d2168c438.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/9ca92447bd7b407784c8fd8144fb441b.png
[3aaaa47829a342089ad19a889729210c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/cdc11dd1d2e741e6b709b71b85304d41.png
[a238f58ec5db4cc4a75f061c5ff791bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/68751a94e5f847bdba23f5deaac416a5.png
[04153fc81ae14eb7bbfb5eb857472b7c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/15aeffa09c174636835f897560f6b064.png
[94367824f8434dc6b51fd799afeccf77.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/898bd344f30d4299bc9c4e6571521e77.png
[bd209cf965dd43cf8192a041afdef754.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/ac15350c76c449558f5a25dd2dbfd86e.png
[699008c3b13c43d49984d941098b251a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/90041bee9de94ca5a3dc4afa9002c8ea.png
[5c8341a93af243b985eacecf9640b81b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/f0d9405bdf2e4ff6bd28f5f4183b7f04.png
[1d007008bf61410b940f4835f3e53614.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/3580c57e4f8d47a6bef622d79d7bbf92.png
[a49c394f6b204fc59884ddb100dc8e11.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/bd4ca4fa947f457fb2222150bcbb29bf.png
[6817bd50a0d344e3b5ffcaf3ebeb7214.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/24646f79a33449be81a859fce36bd144.png
[840493ddeed3416fb018d138565f299d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/c18c7d2762f1459c8b904c84dd1f7d30.png
[834f9a55c17f411b820fa6c0506a8411.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/22d4aa31e14649f5948fe28ceccba8ae.png
[0b10d60e5eff43768b2aadce25263040.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/bcded4ff8a324aa098b5705943f1b646.png
[41d5356817c44627b2c3e9447b04ce40.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/686da25908f0422daa3877604272c428.png
[6e7eefe7cbf04e32bdfba302d3eab12a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/fce03ab39a7e4219b73681541f46249a.png
[12ca2c85a5a34dbaa5ff8d7ccb7b7c7c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/61e43ce4ec6c4d6888d35b2e6f3fab9b.png
[7201ff48acf0424ca4475df7764f93f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/de9483c5c4a045ab9713304621c9d165.png
[31a6c94f0f1947689870c549a469f043.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/645ee67da3fd41bdad2f3b98c5a1f38e.png