【JAVA进阶】Set集合、Map集合

朴灿烈づ我的快乐病毒、 2024-04-20 07:54 7阅读 0赞

> 📃个人主页：[个人主页][Link 1]
> 
> 🔥系列专栏：[JAVASE基础][JAVASE]

**目录**

一、Set系列集合

1.HashSet

2.LinkedHashSet

3.TreeSet

二、补充知识

1.可变参数

2.集合工具类Collections

三、Map集合体系

1.Map集合的概述

2.Map集合体系特点

3.Map集合常用API

4.Map集合的遍历方式

1.Map集合的遍历方式一：键找值

2.Map集合的遍历方式二：键值对

3.Map集合的遍历方式三：Lambda

5.Map集合的实现类HashMap

6.Map集合的实现类LinkedHashMap

7.Map集合的实现类TreeMap

--------------------

## 一、Set系列集合 ##

**Set系列集合特点**

*  无序：存取顺序不一致
 *  不重复：可以去除重复
 *  无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。

**Set集合实现类特点**

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

### **1.HashSet** ###

*  HashSet集合底层采取哈希表存储的数据。
 *  哈希表是一种对于增删改查数据性能都较好的结构。

**HashSet底层原理**

*  HashSet集合底层采取哈希表存储的数据。
 *  哈希表是一种对于增删改查数据性能都较好的结构。

哈希表的组成

*  JDK8之前的，底层使用数组+链表组成
 *  JDK8开始后，底层采用数组+链表+红黑树组成。

在了解哈希表之前需要先理解哈希值的概念

**哈希值**

是JDK根据对象的地址，按照某种规则算出来的int类型的数值。

**Object类的API**

public int hashCode()：返回对象的哈希值

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

*  同一个对象多次调用hashCode()方法返回的哈希值是相同的
 *  默认情况下，不同对象的哈希值是不同的。

public class Main {
        public static void main(String[] args) {
            String str="123";
    
            System.out.println(str.hashCode());
            System.out.println(str.hashCode());
    
            String str2="1234";
    
            System.out.println(str2.hashCode());
            System.out.println(str2.hashCode());
        }
    }

![f62d82b22c994f6dae42385be8bb3571.png][]

### 2.LinkedHashSet ###

*  有序、不重复、无索引。
 *  这里的有序指的是保证存储和取出的元素顺序一致
 *  原理：底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序。

### 3.TreeSet ###

*  不重复、无索引、可排序
 *  可排序：按照元素的大小默认升序（有小到大）排序。
 *  TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好。
 *  注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序。

**TreeSet集合默认的规则**

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

**自定义排序规则**

TreeSet集合存储对象的的时候有2种方式可以设计自定义比较规则

*  方式一 让自定义的类（如学生类）实现Comparable接口重写里面的compareTo方法来定制比较规则。
 *  方式二 TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则。

> 1. 如果希望元素可以重复，又有索引，索引查询要快？
> 
> 用ArrayList集合，基于数组的。（用的最多）
> 
> 2. 如果希望元素可以重复，又有索引，增删首尾操作快？
> 
> 用LinkedList集合，基于链表的。
> 
> 3. 如果希望增删改查都快，但是元素不重复、无序、无索引。
> 
> 用HashSet集合，基于哈希表的。
> 
> 4. 如果希望增删改查都快，但是元素不重复、有序、无索引。
> 
> 用LinkedHashSet集合，基于哈希表和双链表。
> 
> 5. 如果要对对象进行排序。
> 
> 用TreeSet集合，基于红黑树。后续也可以用List集合实现排序。

## 二、补充知识 ##

### 1.可变参数 ###

**可变参数**

*  可变参数用在形参中可以接收多个数据。
 *  可变参数的格式：数据类型...参数名称

**可变参数的作用**

*  接收参数非常灵活，方便。可以不接收参数，可以接收1个或者多个参数，也可以接收一个数组
 *  可变参数在方法内部本质上就是一个数组。

**可变参数的注意事项：**

1.一个形参列表中可变参数只能有一个

2.可变参数必须放在形参列表的最后面

public class Test {
        public static void main(String[] args) {
           test(0);
           System.out.println("---------------------");
           test(1,2);
            System.out.println("---------------------");
           test(1,3,5,7);
        }
    
    
        public static void test(int... num) {
            for (int i = 0; i < num.length; i++) {
                System.out.println(num[i]);
            }
    
    
        }
    
    }

![9249f3a6e58d42edbc58574b6d5c37d1.png][]

###  ###

### 2.集合工具类Collections ###

**Collections集合工具类**

*  java.utils.Collections:是集合工具类
 *  作用：Collections并不属于集合，是用来操作集合的工具类。

**Collections常用的API**

<table> 
 <tbody> 
  <tr> 
   <td style="width:472px;"> <p>方法名称</p> </td> 
   <td style="width:376px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:472px;"> <p>public&nbsp;static&nbsp;&lt;T&gt;&nbsp;boolean&nbsp;addAll(Collection&lt;?&nbsp;super&nbsp;T&gt;&nbsp;c,&nbsp;T...&nbsp;elements)</p> </td> 
   <td style="width:376px;"> <p>给集合对象批量添加元素</p> </td> 
  </tr> 
  <tr> 
   <td style="width:472px;"> <p>public&nbsp;static&nbsp;void&nbsp;shuffle(List&lt;?&gt;&nbsp;list)&nbsp;</p> </td> 
   <td style="width:376px;"> <p>打乱List集合元素的顺序</p> </td> 
  </tr> 
 </tbody> 
</table>

**Collections排序相关API**

使用范围：只能对于List集合的排序。

**排序方式1：**

<table> 
 <tbody> 
  <tr> 
   <td style="width:301px;"> <p>方法名称</p> </td> 
   <td style="width:547px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:301px;"> <p>public&nbsp;static&nbsp;&lt;T&gt;&nbsp;void&nbsp;sort(List&lt;T&gt;&nbsp;list)</p> </td> 
   <td style="width:547px;"> <p>将集合中元素按照默认规则排序</p> </td> 
  </tr> 
 </tbody> 
</table>

注意：本方式不可以直接对自定义类型的List集合排序，除非自定义类型实现了比较规则Comparable接口。

public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            Collections.addAll(list,"98","5","2","7","3","1");
            System.out.println(list);
            Collections.sort(list);
            System.out.println(list);
    
        }

![8a30a1521b1245c1a935b460eca5cc8b.png][]

**排序方式2：**

<table> 
 <tbody> 
  <tr> 
   <td style="width:439px;"> <p>方法名称</p> </td> 
   <td style="width:409px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:439px;"> <p>public&nbsp;static&nbsp;&lt;T&gt;&nbsp;void&nbsp;sort(List&lt;T&gt;&nbsp;list，Comparator&lt;?&nbsp;super&nbsp;T&gt;&nbsp;c)</p> </td> 
   <td style="width:409px;"> <p>将集合中元素按照指定规则排序</p> </td> 
  </tr> 
 </tbody> 
</table>

##  三、Map集合体系 ##

### 1.Map集合的概述 ###

**Map集合概述和使用**

*  Map集合是一种双列集合，每个元素包含两个数据。
 *  Map集合的每个元素的格式：key=value(键值对元素)。
 *  Map集合也被称为“键值对集合”。

**Map集合整体格式：**

*  Collection集合的格式: \[元素1,元素2,元素3..\]
 *  Map集合的完整格式：\{key1=value1 , key2=value2 , key3=value3 , ...\}

### 2.Map集合体系特点 ###

**Map集合体系**

![d79488b73ec340fc9bbc09033c9b2a99.png][]

说明

*  使用最多的Map集合是HashMap。
 *  重点掌握HashMap , LinkedHashMap , TreeMap。其他的后续理解。

![b407eba0393545fbb3f3e8242b771597.png][]

**Map集合体系特点**

*  Map集合的特点都是由键决定的。
 *  Map集合的键是无序,不重复的，无索引的，值不做要求（可以重复）。
 *  Map集合后面重复的键对应的值会覆盖前面重复键的值。
 *  Map集合的键值对都可以为null。

**Map集合实现类特点**

*  HashMap:元素按照键是无序，不重复，无索引，值不做要求。（与Map体系一致）
 *  LinkedHashMap:元素按照键是有序，不重复，无索引，值不做要求。
 *  TreeMap：元素按照建是排序，不重复，无索引的，值不做要求。

### 3.Map集合常用API ###

**Map集合**

*  Map是双列集合的祖宗接口，它的功能是全部双列集合都可以继承使用的。

**Map API如下:**

<table> 
 <tbody> 
  <tr> 
   <td style="width:304px;"> <p>方法名称</p> </td> 
   <td style="width:544px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:304px;"> <p>V&nbsp;put(K&nbsp;key,V&nbsp;value)</p> </td> 
   <td style="width:544px;"> <p>添加元素</p> </td> 
  </tr> 
  <tr> 
   <td style="width:304px;"> <p>V&nbsp;remove(Object&nbsp;key)</p> </td> 
   <td style="width:544px;"> <p>根据键删除键值对元素</p> </td> 
  </tr> 
  <tr> 
   <td style="width:304px;"> <p>void&nbsp;clear()</p> </td> 
   <td style="width:544px;"> <p>移除所有的键值对元素</p> </td> 
  </tr> 
  <tr> 
   <td style="width:304px;"> <p>boolean&nbsp;containsKey(Object&nbsp;key)</p> </td> 
   <td style="width:544px;"> <p>判断集合是否包含指定的键</p> </td> 
  </tr> 
  <tr> 
   <td style="width:304px;"> <p>boolean&nbsp;containsValue(Object&nbsp;value)</p> </td> 
   <td style="width:544px;"> <p>判断集合是否包含指定的值</p> </td> 
  </tr> 
  <tr> 
   <td style="width:304px;"> <p>boolean&nbsp;isEmpty()</p> </td> 
   <td style="width:544px;"> <p>判断集合是否为空</p> </td> 
  </tr> 
  <tr> 
   <td style="width:304px;"> <p>int&nbsp;size()</p> </td> 
   <td style="width:544px;"> <p>集合的长度，也就是集合中键值对的个数</p> </td> 
  </tr> 
 </tbody> 
</table>

public class Test {
        public static void main(String[] args) {
            Map<String, Integer> map = new HashMap<>();
            //1.V put(K key,V value) 添加元素
            map.put("java",1);
            map.put("html",12);
            map.put("css",21);
            map.put("rust",3);
            map.put("js",9);
            System.out.println(map);
            System.out.println("-------------------------");
            //2.V remove(Object key)	根据键删除键值对元素
            map.remove("java");
            System.out.println(map);
            System.out.println("-------------------------");
            //3.void clear()	移除所有的键值对元素
    //        map.clear();
    //        System.out.println(map);
    //        System.out.println("-------------------------");
            //4. boolean containsKey(Object key)	判断集合是否包含指定的键
            System.out.println(map.containsKey("java"));
            System.out.println(map.containsKey("js"));
            System.out.println("-------------------------");
            //5.boolean containsValue(Object value)	判断集合是否包含指定的值
            System.out.println(map.containsValue(12));
            System.out.println("-------------------------");
            //6. boolean isEmpty()	判断集合是否为空
            System.out.println(map.isEmpty());
            System.out.println("-------------------------");
            //7. int size()	集合的长度，也就是集合中键值对的个数
            System.out.println(map.size());
    
    
        }
    
    
    
    
    }

### 4.Map集合的遍历方式 ###

**Map集合的遍历方式有：3种。**

*  方式一：键找值的方式遍历：先获取Map集合全部的键，再根据遍历键找值。
 *  方式二：键值对的方式遍历，把“键值对“看成一个整体，难度较大。
 *  方式三：JDK 1.8开始之后的新技术：Lambda表达式。

#### 1.Map集合的遍历方式一：键找值 ####

*  先获取Map集合的全部键的Set集合。
 *  遍历键的Set集合，然后通过键提取对应值。

**键找值涉及到的API:**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法名称</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>Set&lt;K&gt; keySet()</td> 
   <td>获取所有键的集合</td> 
  </tr> 
  <tr> 
   <td>V get(Object key)</td> 
   <td>根据键获取值</td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
            Map<String, Integer> map = new HashMap<>();
            //1.V put(K key,V value) 添加元素
            map.put("java",1);
            map.put("html",12);
            map.put("css",21);
            map.put("rust",3);
            map.put("js",9);
            System.out.println(map);
    
            Set<String> keys = map.keySet();
            for (String key : keys) {
                Integer value = map.get(key);
                System.out.println(key+"----->"+value);
            }
    
        }

![5754daf879494737a29d3266315f87cb.png][]

#### 2.Map集合的遍历方式二：键值对 ####

*  先把Map集合转换成Set集合，Set集合中每个元素都是键值对实体类型了。
 *  遍历Set集合，然后提取键以及提取值。

**键值对涉及到的API:**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法名称</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>Set&lt;Map.Entry&lt;K,V&gt;&gt; entrySet()</td> 
   <td>获取所有键值对对象的集合</td> 
  </tr> 
  <tr> 
   <td>K &nbsp;getKey()</td> 
   <td>获得键</td> 
  </tr> 
  <tr> 
   <td>V &nbsp;getValue()</td> 
   <td>获取值</td> 
  </tr> 
 </tbody> 
</table>

import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class Main {
        public static void main(String[] args) {
            Map<String, Integer> map = new HashMap<>();
            //1.V put(K key,V value) 添加元素
            map.put("java", 1);
            map.put("html", 12);
            map.put("css", 21);
            map.put("rust", 3);
            map.put("js", 9);
            System.out.println(map);
    
            Set<Map.Entry<String, Integer>> entries = map.entrySet();
            for (Map.Entry<String, Integer> entry : entries) {
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key+"----->"+value);
            }
            }
    
        }

![e7c845fd3994481898980e0233f4bb83.png][]

#### 3.Map集合的遍历方式三：Lambda ####

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

**Map结合Lambda遍历的API**

<table> 
 <tbody> 
  <tr> 
   <td style="width:420px;"> <p>方法名称</p> </td> 
   <td style="width:429px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:420px;"> <p>default&nbsp;void&nbsp;forEach(BiConsumer&lt;?&nbsp;super&nbsp;K,&nbsp;?&nbsp;super&nbsp;V&gt;&nbsp;action)</p> </td> 
   <td style="width:429px;"> <p>结合lambda遍历Map集合</p> </td> 
  </tr> 
 </tbody> 
</table>

public class Main {
        public static void main(String[] args) {
            Map<String, Integer> map = new HashMap<>();
            //1.V put(K key,V value) 添加元素
            map.put("java", 1);
            map.put("html", 12);
            map.put("css", 21);
            map.put("rust", 3);
            map.put("js", 9);
            System.out.println(map);
    
            map.forEach(new BiConsumer<String, Integer>() {
                @Override
                public void accept(String key, Integer value) {
                    System.out.println(key+"----->"+value);
                }
            });
    
    
    }
    
     }

代码简化一下：

public class Main {
        public static void main(String[] args) {
            Map<String, Integer> map = new HashMap<>();
            //1.V put(K key,V value) 添加元素
            map.put("java", 1);
            map.put("html", 12);
            map.put("css", 21);
            map.put("rust", 3);
            map.put("js", 9);
            System.out.println(map);
    
            map.forEach( (key,  value) ->{
                    System.out.println(key+"----->"+value);
            });
    
    
    }
    
     }

![d6b33ee881c641a29a44de16235d6cd4.png][]

### 5.Map集合的实现类HashMap ###

![a3c1b5e3e6744ba79e441f5c24504f91.png][]

**说明**

*  **使用最多的Map集合是HashMap。**
 *  重点掌握HashMap , LinkedHashMap , TreeMap。其他的后续理解。

**HashMap的特点**

*  HashMap是Map里面的一个实现类。特点都是由键决定的：无序、不重复、无索引
 *  没有额外需要学习的特有方法，直接使用Map里面的方法就可以了。
 *  HashMap跟HashSet底层原理是一模一样的，都是哈希表结构，只是HashMap的每个元素包含两个值而已。

**实际上：Set系列集合的底层就是Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。**

HashMap 是 Java 中的一个集合类，它用来存储键值对。它实现了 Map 接口，可以存储不同类型的键和值，并且允许 null 值。在 HashMap 中，键是唯一的，值可以重复。

HashMap 中最常用的方法包括：

*  put(key, value)：将键值对添加到 HashMap 中。
 *  get(key)：获取指定键对应的值。
 *  remove(key)：删除指定键对应的键值对。
 *  containsKey(key)：判断 HashMap 是否包含指定的键。
 *  keySet()：返回 HashMap 中所有键组成的 Set 集合。

public static void main(String[] args) {
            // 创建一个名为capitalCities的HashMap对象
            HashMap<String, String> capitalCities = new HashMap<String, String>();
    
            // 添加键和值（国家，城市）
            capitalCities.put("England", "London");
            capitalCities.put("Germany", "Berlin");
            capitalCities.put("Norway", "Oslo");
            capitalCities.put("USA", "Washington DC");
    
            // 通过使用键访问值
            System.out.println("英格兰的首都是 " + capitalCities.get("England"));
    
            // 删除一个键和值
            capitalCities.remove("Norway");
    
            // 打印键
            System.out.println("键: " + capitalCities.keySet());
    
            // 检查一个键是否在HashMap中
            System.out.println("capitalCities是否包含Norway作为键？ " + capitalCities.containsKey("Norway"));
        }

英格兰的首都是 London
    键: [USA, England, Germany]
    capitalCities是否包含Norway作为键？ false

### 6.Map集合的实现类LinkedHashMap ###

LinkedHashMap是Java集合框架中的一种Map实现，它继承自 HashMap 类，底层使用双向链表维护元素的顺序。特点是能够保持插入顺序，即遍历顺序与插入顺序相同，同时也支持按照访问顺序排序，即根据元素最近被访问的时间排序。其键值对是唯一的，键和值都可以为null。 对于访问顺序，可以通过构造函数或调用 afterNodeAccess、beforeNodeInsertion 等访问方法来配置。此外，LinkedHashMap 还实现了 removeEldestEntry 方法，它的作用是当元素个数超过指定阈值时，删除最不常访问的元素。

LinkedHashMap类实现了Map接口，使用双向链表维护插入顺序。具有如下主要方法：

1.  void clear()：从此映射中删除所有映射关系。
2.  boolean containsKey(Object key)：如果此映射包含指定键的映射关系，则返回true。
3.  boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回true。
4.  Set<Entry<K,V>> entrySet()：返回此映射中所包含的映射关系的Set视图。
5.  V get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。
6.  boolean isEmpty()：如果此映射未包含键-值映射关系，则返回true。
7.  Set<K> keySet()：返回此映射中包含的键的Set视图。
8.  V put(K key, V value)：将指定的值与此映射中的指定键关联。
9.  void putAll(Map<? extends K,? extends V> m)：将指定映射中的所有映射关系复制到此映射中。
10. V remove(Object key)：从此映射中移除指定键的映射关系（如果存在）。
11. int size()：返回此映射中的键-值映射关系数。
12. Collection<V> values()：返回此映射中包含的值的Collection视图。

**注意：LinkedHashMap是非线程安全的。**

LinkedHashMap集合可以保持插入顺序，如果已经存在的键再次被放入，那么会把原来对应的值覆盖掉。以下是一个简单的例子：

import java.util.LinkedHashMap;
    import java.util.Map;
    
    public class LinkedHashMapDemo {
    
        public static void main(String[] args) {
            Map<String, Integer> map = new LinkedHashMap<>(); // 创建 LinkedHashMap 对象
            map.put("apple", 1); // 插入数据
            map.put("banana", 2);
            map.put("orange", 3);
            map.put("apple", 4); // 覆盖相同键的值
            for (Map.Entry<String, Integer> entry : map.entrySet()) { // 遍历输出
                System.out.println(entry.getKey() + ": " + entry.getValue());
            }
        }
    }

apple: 4
    banana: 2
    orange: 3

### 7.Map集合的实现类TreeMap ###

TreeMap 是 Java 中的一种有序的数据结构，基于红黑树实现，可以根据键值进行排序。TreeMap 中存储的元素都是键值对(key-value)，其中键是唯一的。

**TreeMap集合概述和特点:**

*  由键决定特性：不重复、无索引、可排序
 *  可排序：按照键数据的大小默认升序（有小到大）排序。只能对键排序。
 *  注意：TreeMap集合是一定要排序的，可以默认排序，也可以将键按照指定的规则进行排序
 *  TreeMap跟TreeSet一样底层原理是一样的。

**TreeMap集合自定义排序规则有2种**

*  类实现Comparable接口，重写比较规则。
 *  集合自定义Comparator比较器对象，重写比较规则。

import java.util.TreeMap;
    
    public class TreeMapExample {
        public static void main(String[] args) {
            // 创建一个TreeMap对象，指定键的类型为String，值的类型为Integer
            TreeMap<String, Integer> map = new TreeMap<>();
    
            // put()方法向TreeMap中添加元素
            map.put("apple", 1);
            map.put("banana", 2);
            map.put("orange", 3);
    
            // 通过遍历TreeMap来获取元素
            for (String key : map.keySet()) {
                System.out.println(key + ": " + map.get(key));
            }
        }
    }

[Link 1]: https://blog.csdn.net/Javascript_tsj?type=blog
[JAVASE]: https://blog.csdn.net/javascript_tsj/category_11897642.html?spm=1001.2014.3001.5482
[f62d82b22c994f6dae42385be8bb3571.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/55ecfc36fda14cf9a54cb09bd88dc856.png
[9249f3a6e58d42edbc58574b6d5c37d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/d44d3423206d4873899fc84fbb799cb8.png
[8a30a1521b1245c1a935b460eca5cc8b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/d6921149df594d10ae383d550b4f66c7.png
[d79488b73ec340fc9bbc09033c9b2a99.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/a6a84bb98b9d45269c6198c07107b5a3.png
[b407eba0393545fbb3f3e8242b771597.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/3607b21ed1b146bc9aa836454677ed16.png
[5754daf879494737a29d3266315f87cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/810ca7395e7d4846b3fb98048e76d804.png
[e7c845fd3994481898980e0233f4bb83.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e7c749d6d0d449fdacd8de6d2400a819.png
[d6b33ee881c641a29a44de16235d6cd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/dacaddb8b662405f81d1edc9df156df1.png
[a3c1b5e3e6744ba79e441f5c24504f91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/f11ed2b349124f2fb1b945bff49681bf.png