Java 集合进阶（Map）

本是古典何须时尚 2024-03-02 08:13 19阅读 0赞

### 一、Map集合 ###

#### 1、Map概述体系 ####

前面我们已经把单列集合学习完了，接下来我们要学习的是双列集合。首先我们还是先认识一下什么是双列集合。

所谓双列集合，就是说集合中的元素是一对一对的。Map集合中的每一个元素是以key=value的形式存在的，一个key=value就称之为一个键值对，而且在Java中有一个类叫Entry类，Entry的对象用来表示键值对对象。

所有的Map集合有如下的特点：**键不能重复，值可以重复，每一个键只能找到自己对应的值。**

![f8e3ac1906d7473684bfc7f7e6ef5d75.png][]

下面我们先写一个Map集合，保存几个键值对，体验一下Map集合的特点 。

public class MapTest1 {
        public static void main(String[] args) {
            // Map<String, Integer> map = new HashMap<>(); // 一行经典代码。 按照键 无序，不重复，无索引。
            Map<String, Integer> map = new LinkedHashMap<>(); // 有序，不重复，无索引。
            map.put("手表", 100);
            map.put("手表", 220); // 后面重复的数据会覆盖前面的数据（键）
            map.put("手机", 2);
            map.put("Java", 2);
            map.put(null, null);
            System.out.println(map);
    
            Map<Integer, String> map1 = new TreeMap<>(); // 可排序，不重复，无索引
            map1.put(23, "Java");
            map1.put(23, "MySQL");
            map1.put(19, "李四");
            map1.put(20, "王五");
            System.out.println(map1);
        }
    }

Map集合也有很多种，在Java中使用不同的类来表示的，每一种Map集合其键的特点是有些差异的，值是键的一个附属值，所以我们只关注键的特点就可以了。

![19435c49e2ba43a6ab7565ea7738eca3.png][]

**说明**

**使用最多的Map集合是HashMap。**

重点掌握HashMap，LinkedHashMap，TreeMap。其他的后续理解。

**Map集合体系特点**

Map集合的特点都是由键决定的。

Map集合的键是无序的、不重复、无索引的，值不做要求（可以重复）。

Map集合后面重复的键对应的值会覆盖前面重复键的值。

Map集合的键值对都可以为null。

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

HashMap：元素按照键是无序，不重复，无索引，值不做要求。（与Map体系一致）

LinkedHashMap：元素按照键是**有序**，不重复，无索引，值不做要求。

TreeMap：元素按照键是**排序**，不重复，无索引的，值不做要求。

/**
     * Map集合
     * Collection：单列集合
     * Map：双列集合
     *
     * 认识Map集合
     * Map集合称为双列集合，格式：{key1 = valus1, key2 = valus2, key3 = valus3, ...}，一次需要存一对数据作为一个元素。
     * Map集合的每个元素 "key = value" 称为一个键值对/键值对对象/一个Entry对象，Map集合也不内叫做”键值对集合“。
     * Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值。
     *
     * Map集合体系
     * 注意：Map系列集合的特点都是由键觉得的，值只是一个附属品，值是不做要求的
     * HashMap（由键决定特点）：无序、不重复、无索引；（用的最多）
     * LinkedHashMap（由键决定特点）：有序、不重复、无索引。
     * TreeMap（由键决定特点）：按照大小默认升序排序、不重复、无索引。
     */
    public class MapTest1 {
        public static void main(String[] args) {
            // 目标：掌握Map集合的特点。
            Map<String, Integer> map = new HashMap<>(); // 一行经典代码。按照键 无序，不重复，无索引。
            map.put("手表", 100);
            map.put("手表", 200); // 后面重合度的数据回覆盖前面的数据(键)
            map.put("手机", 2);
            map.put("Java", 2);
            map.put(null, null);
            System.out.println(map);
    
            System.out.println("-------------------------------------");
    
            Map<String, Integer> map1 = new LinkedHashMap<>(); // 有序，不重复，无索引。
            map1.put("手表", 100);
            map1.put("手表", 200); // 后面重合度的数据回覆盖前面的数据(键)
            map1.put("手机", 2);
            map1.put("Java", 2);
            map1.put(null, null);
            System.out.println(map1);
    
            System.out.println("-------------------------------------");
    
            Map<Integer, String> map2 = new TreeMap<>(); // 可排序，不重复，无索引。
            map2.put(23, "Java");
            map2.put(23, "MYSQL"); // 后面重合度的数据回覆盖前面的数据(键)
            map2.put(19, "李四");
            map2.put(20, "王五");
            System.out.println(map2);
        }
    }

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

由于Map是所有双列集合的父接口，它的功能是全部双列集合都可以继承使用的，所以我们只需要学习Map接口中每一个方法是什么含义，那么所有的Map集合方法你就都会用了。

![ce25417d34e442b690eeb8f4dbf05ab3.png][]

public class MapTest2 {
        public static void main(String[] args) {
            // 1.添加元素: 无序，不重复，无索引。
            Map<String, Integer> map = new HashMap<>();
            map.put("手表", 100);
            map.put("手表", 220);
            map.put("手机", 2);
            map.put("Java", 2);
            map.put(null, null);
            System.out.println(map);
            // map = {null=null, 手表=220, Java=2, 手机=2}
    
            // 2.public int size():获取集合的大小
            System.out.println(map.size());
    
            // 3、public void clear():清空集合
            //map.clear();
            //System.out.println(map);
    
            // 4.public boolean isEmpty(): 判断集合是否为空，为空返回true ,反之！
            System.out.println(map.isEmpty());
    
            // 5.public V get(Object key)：根据键获取对应值
            int v1 = map.get("手表");
            System.out.println(v1);
            System.out.println(map.get("手机")); // 2
            System.out.println(map.get("张三")); // null
    
            // 6. public V remove(Object key)：根据键删除整个元素(删除键会返回键的值)
            System.out.println(map.remove("手表"));
            System.out.println(map);
    
            // 7.public  boolean containsKey(Object key): 判断是否包含某个键 ，包含返回true ,反之
            System.out.println(map.containsKey("手表")); // false
            System.out.println(map.containsKey("手机")); // true
            System.out.println(map.containsKey("java")); // false
            System.out.println(map.containsKey("Java")); // true
    
            // 8.public boolean containsValue(Object value): 判断是否包含某个值。
            System.out.println(map.containsValue(2)); // true
            System.out.println(map.containsValue("2")); // false
    
            // 9.public Set<K> keySet(): 获取Map集合的全部键。
            Set<String> keys = map.keySet();
            System.out.println(keys);
    
            // 10.public Collection<V> values(); 获取Map集合的全部值。
            Collection<Integer> values = map.values();
            System.out.println(values);
    
            // 11.把其他Map集合的数据倒入到自己集合中来。(拓展)
            Map<String, Integer> map1 = new HashMap<>();
            map1.put("java1",  10);
            map1.put("java2",  20);
            Map<String, Integer> map2 = new HashMap<>();
            map2.put("java3",  10);
            map2.put("java2",  222);
            map1.putAll(map2); // putAll：把map2集合中的元素全部倒入一份到map1集合中去。
            System.out.println(map1);
            System.out.println(map2);
        }
    }

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

> Map集合一共有三种遍历方式：
> 
> 1.  **键找值**的方式遍历：先获取Map集合全部的键，再根据遍历键找值。
> 2.  **键值对**的方式遍历：把 "键值对" 看成一个整体，难度较大。
> 3.  DK1.8开始之后的新技术：**Lambda表达式**。

##### 3.1 Map集合的遍历方式一：键找值 ![fe374addc83c47269da7a1f943270336.png][] #####

**键找值流程：**

![ebea81ce580b44ab8321d27864d8bf07.png][]

/**
     * 目标：掌握Map集合的遍历方式一：键找值
     */
    public class MapTest1 {
        public static void main(String[] args) {
            // 准备Map集合
            Map<String, Double> map = new HashMap<>();
            map.put("蜘蛛精", 162.5);
            map.put("蜘蛛精", 169.8);
            map.put("紫霞", 165.8);
            map.put("至尊宝", 169.5);
            map.put("牛魔王", 183.6);
            System.out.println(map);
            // {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
    
            // 1.获取Map集合的全部键
            Set<String> keys = map.keySet();
            System.out.println(keys);
            // [蜘蛛精, 牛魔王, 至尊宝, 紫霞]
            //   key
            // 2.遍历全部的键，根据键获取其对应的值
            for (String key : keys) {
                // 根据键获取对应的值
                Double value = map.get(key);
                System.out.println(key + "--->" + value);
            }
        }
    }

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

前面给大家介绍过，Map集合是用来存储键值对的，而每一个键值对实际上是一个Entry对象。

**这里Map集合的第二种方式，是直接获取每一个Entry对象，把Entry存储到Set集合中去，再通过Entry对象获取键和值。**

![4bb0fe6388414436af5cdf8645f7e0fe.png][]

/**
     * 目标： 目标：掌握Map集合的遍历方式二：键值对。
     */
    public class MapTest2 {
        public static void main(String[] args) {
            Map<String, Double> map = new HashMap<>();
            map.put("蜘蛛精", 169.8);
            map.put("紫霞", 165.8);
            map.put("至尊宝", 169.5);
            map.put("牛魔王", 183.6);
            System.out.println(map);
            // map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
            // entries = [(蜘蛛精=169.8), (牛魔王=183.6), (至尊宝=169.5), (紫霞=165.8)]
            // entry = (蜘蛛精=169.8)
            // entry = (牛魔王=183.6)
            // ...
    		
            // 1、调用Map集合提供entrySet方法，把Map集合转换成键值对类型的Set集合
            Set<Map.Entry<String, Double>> entries = map.entrySet();
            for (Map.Entry<String, Double> entry : entries) {
                String key = entry.getKey();
                double value = entry.getValue();
                System.out.println(key + "---->" + value);
            }
        }
    }

##### 3.3 Map集合的遍历方式三：Lambda表达式 #####

Map集合的第三种遍历方式，需要用到下面的一个方法forEach，而这个方法是JDK8版本以后才有的。调用起来非常简单，最好是结合的lambda表达式一起使用。

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

![22a7c6d078bb40809531fec0e5907f72.png][]

**流程：**

![cd94b502887b4b7ab350956b3da00de1.png][]

/**
     * 目标：掌握Map集合的遍历方式三：键值对。
     */
    public class MapTest3 {
        public static void main(String[] args) {
            Map<String, Double> map = new HashMap<>();
            map.put("蜘蛛精", 169.8);
            map.put("紫霞", 165.8);
            map.put("至尊宝", 169.5);
            map.put("牛魔王", 183.6);
            System.out.println(map);
            // map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
    
    
    		//遍历map集合，传递匿名内部类
            map.forEach(new BiConsumer<String, Double>() {
                @Override
                public void accept(String k, Double v) {
                    System.out.println(k + "---->" + v);
                }
            });
    		//遍历map集合，传递Lambda表达式
            map.forEach(( k,  v) -> {
                System.out.println(k + "---->" + v);
            });
        }
    }

#### 4、Map集合案例 ####

**案例：统计投票人数**

> **需求：**
> 
> 某个班级80名学生，现在需要组成秋游活动，班长提供了四个景点依次是（A、B、C、D），每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多。
> 
> **分析：**
> 
> 1、将80个学生选择的数据拿到程序中去。
> 
> 2、定义Map集合用于存储最终统计的结果。
> 
> 3、遍历80个学生选择的数据，看Map集合中是否存在，不存在存入 "数据 = 1"，存在则其对应值+1。

/**
     * 目标：完成Map集合的案例：统计投票人数。
     */
    public class MapDemo4 {
        public static void main(String[] args) {
            // 1、把80个学生选择的景点数据拿到程序中来。
            List<String> data = new ArrayList<>();
            String[] selects = {"A", "B", "C", "D"};
            Random r = new Random();
            for (int i = 1; i <= 80; i++) {
                // 每次模拟一个学生选择一个景点，存入到集合中去。
                int index = r.nextInt(4); // 0 1 2 3
                data.add(selects[index]);
            }
            System.out.println(data);
    
            // 2、开始统计每个景点的投票人数
            // 准备一个Map集合用于统计最终的结果
            Map<String, Integer> result = new HashMap<>();
    
            // 3、开始遍历80个景点数据
            for (String s : data) {
                // 问问Map集合中是否存在该景点
                if(result.containsKey(s)){
                    // 说明这个景点之前统计过。其值+1. 存入到Map集合中去
                    result.put(s, result.get(s) + 1);
                }else {
                    // 说明这个景点是第一次统计，存入"景点=1"
                    result.put(s, 1);
                }
            }
            System.out.println(result);
        }
    }

### 二、Map集合的实现类 ###

#### 1、HashMap ####

首先，我们学习HashMap集合的底层原理。前面我们学习过HashSet的底层原理，实际上HashMap底层原理和HashSet是一样的。为什么这么说呢？因为我们往HashSet集合中添加元素时，实际上是把元素作为添加添加到了HashMap集合中。

下面是Map集合的体系结构，HashMap集合的特点是由键决定的： **它的键是无序、不能重复，而且没有索引的**。在各种Map集合中也是用得最多的一种集合。

![971754df256d44dcaad77d45f3540edf.png][]

刚才我们说，HashSet底层就是HashMap，我们可以看源码验证这一点，如下图所示，我们可以看到，创建HashSet集合时，底层帮你创建了HashMap集合；往HashSet集合中添加添加元素时，底层却是调用了Map集合的put方法把元素作为了键来存储。所以实际上根本没有什么HashSet集合，把HashMap的集合的值忽略不看就是HashSet集合。

![96b3564cd914453bafd17a8fae79a6df.png][]

HashSet的原理我们之前已经学过了，所以HashMap是一样的，底层是哈希表结构。

![228986dbe3ba43a190227189d1143321.png][]

> HashMap底层数据结构: 哈希表结构  
> JDK8之前的哈希表 = 数组+链表  
> JDK8之后的哈希表 = 数组+链表+红黑树  
> 哈希表是一种增删改查数据，性能相对都较好的数据结构。  
>   
> 往HashMap集合中键值对数据时，底层步骤如下：  
> 第1步：当你第一次往HashMap集合中存储键值对时，底层会创建一个长度为16的数组；  
> 第2步：把键然后将键和值封装成一个对象，叫做Entry对象；  
> 第3步：再根据Entry对象的键计算hashCode值（和值无关）；  
> 第4步：利用hashCode值和数组的长度做一个类似求余数的算法，会得到一个索引位置；  
> 第5步：判断这个索引的位置是否为null，如果为null,就直接将这个Entry对象存储到这个索引位置；  
> 如果不为null，则还需要进行第6步的判断。  
> 第6步：继续调用equals方法判断两个对象键是否相同；  
> 如果equals返回false，则以链表的形式往下挂；  
> 如果equals方法true,则认为键重复，此时新的键值对会替换就的键值对。  
>   
> HashMap底层需要注意这几点：  
> 1.底层数组默认长度为16，如果数组中有超过12个位置已经存储了元素，则会对数组进行扩容2倍。  
> 数组扩容的加载因子是0.75，意思是：16\*0.75=12 。  
>   
> 2.数组的同一个索引位置有多个元素、并且在8个元素以内(包括8)，则以链表的形式存储  
> JDK7版本：链表采用头插法（新元素往链表的头部添加）。  
> JDK8版本：链表采用尾插法（新元素我那个链表的尾部添加）。  
>   
> 3.数组的同一个索引位置有多个元素、并且超过了8个，则以红黑树形式存储 。

从HashMap底层存储键值对的过程中我们发现：决定键是否重复依赖与两个方法，一个是hashCode方法、一个是equals方法。有两个键计算得到的hashCode值相同，并且两个键使用equals比较为true，就认为键重复。

**所以，往Map集合中存储自定义对象作为键，为了保证键的唯一性，我们应该重写hashCode方法和equals方法。**

比如有如下案例：往HashMap集合中存储Student对象作为键，学生的家庭住址当做值。要求，当学生对象的姓名和年龄相同时就认为键重复。

public class Student implements Comparable<Student> {
        private String name;
        private int age;
        private double height;
    
        // this  o
        @Override
        public int compareTo(Student o) {
            return this.age - o.age; // 年龄升序排序
        }
    
        @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 Student() {
        }
    
        public Student(String name, int age, double height) {
            this.name = name;
            this.age = age;
            this.height = height;
        }
    
    	//...get,set方法自己补全....
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", height=" + height +
                    '}';
        }
    }

写一个测试类，在测试类中，创建HashMap集合，键是Student类型，值是Stirng类型 。

/**
     * 目标：掌握Map集合下的实现类：HashMap集合的底层原理。
     */
    public class Test1HashMap {
        public static void main(String[] args) {
            Map<Student, String> map = new HashMap<>();
            map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");
            map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");
            map.put(new Student("至尊宝", 23, 163.5), "水帘洞");
            map.put(new Student("牛魔王", 28, 183.5), "牛头山");
            System.out.println(map);
        }
    }

上面存储的键，有两个蜘蛛精，但是打印出只会有最后一个。

![ab4718e2538e4053bf39cb09c762493e.png][]

**总结：**

**HashMap的特点和底层原理。**

1、由键决定：无序、不重复、无索引。HashMap底层是哈希表结构的。

2、依赖HashCode方法和equals方法保证键的唯一。

3、如果键要存储的是自定义对象，需要重写hashCode和equals方法。

4、基于哈希表。增删改查性能都比较好。

#### 2、LinkedHashMap ####

LinkedHashMap集合的特点也是由键决定的：**由键决定：有序**、不重复、无索引。

这里的有序指的是保证存储和取出的元素顺序一致。

![bf59a690233647e89ef14b3ca99a6ac2.png][]

/**
     * 目标：掌握LinkedHashMap的底层原理。
     */
    public class Test2LinkedHashMap {
        public static void main(String[] args) {
            // Map<String, Integer> map = new HashMap<>();    //  按照键 无序，不重复，无索引。
            LinkedHashMap<String, Integer> map = new LinkedHashMap<>(); //  按照键 有序，不重复，无索引。
            map.put("手表", 100);
            map.put("手表", 220);
            map.put("手机", 2);
            map.put("Java", 2);
            map.put(null, null);
            System.out.println(map);
        }
    }

运行上面代码发现，如果是LinedHashMap集合键存储和取出的顺序是一样的。

![eef0fdbb6aee49bf8b8cf2672902e3d7.png][]

如果是HashMap，键存储和取出的顺序是不一致的。

![2ab664e4e933458c868e0425f2f6bfac.png][]

> **总结：**
> 
> LinkedHashMap的底层原理，和LinkedHashSet底层原理是一样的。底层多个一个双向链表来维护键的存储顺序。
> 
> 取元素时，先取头节点元素，然后再依次取下一个几点，一直到尾结点。所以是有序的。

![aad154c69b4e46a98a93384be246cf79.png][]

#### 3、TreeMap ####

最后，我们再学习Map集合下面的另一个子类叫TreeMap。根据我们前面学习其他Map集合的经验，我们应该可以猜出TreeMap有什么特点。

TreeMap集合的特点也是由键决定的，默认按照键的升序排列，键不重复，也是无索引的。

可排序：按照键数据的大小默认升序（有小到大）排序。**只能对键排序**。

**注意：TreeMap集合是一定要排序的，可以默认排序，也可以将键按照指定的规则进行排序。**

![a7db71a028494f609b549e4c9da0ba35.png][]

TreeMap集合的底层原理和TreeSet也是一样的，底层都是红黑树实现的。所以可以对键进行排序。

比如往TreeMap集合中存储Student对象作为键，排序方法有两种。

> **TreeMap集合自定义排序规则有2种：**
> 
> 1.  类实现Comparable接口，重写比较规则。
> 2.  集合自定义Comparator比较器对象，重写比较规则。

*  **排序方式1：**写一个Student类，让Student类实现Comparable接口。

//第一步：先让Student类，实现Comparable接口
    public class Student implements Comparable<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;
        }
        //...get、set、toString()方法自己补上..
        
        //按照年龄进行比较，只需要在方法中让this.age和o.age相减就可以。
        /*
        原理：
        在往TreeSet集合中添加元素时，add方法底层会调用compareTo方法，根据该方法的
        结果是正数、负数、还是零，决定元素放在后面、前面还是不存。
        */
        @Override
        public int compareTo(Student o) {
            //this：表示将要添加进去的Student对象
            //o: 表示集合中已有的Student对象
            return this.age-o.age;
        }
    }

*  **排序方式2：**在创建TreeMap集合时，直接传递Comparator比较器对象。

/**
     * 目标：掌握TreeMap集合的使用。
     */
    public class Test3TreeMap {
        public static void main(String[] args) {
            Map<Student, String> map = new TreeMap<>(new Comparator<Student>() {
                @Override
                public int compare(Student o1, Student o2) {
                    return Double.compare(o1.getHeight(), o2.getHeight());
                }
            });
    //        Map<Student, String> map = new TreeMap<>(( o1,  o2) ->   Double.compare(o2.getHeight(), o1.getHeight()));
            map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");
            map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");
            map.put(new Student("至尊宝", 23, 163.5), "水帘洞");
            map.put(new Student("牛魔王", 28, 183.5), "牛头山");
            System.out.println(map);
        }
    }

这种方式都可以对TreeMap集合中的键排序。**注意：只有TreeMap的键才能排序，HashMap键不能排序。**

### 三、补充知识：集合的嵌套 ###

到现在为止我们把Map集合和Collection集合的都已经学习完了。但是在实际开发中可能还会存在一种特殊的用法。就是把一个集合当做元素，存储到另一个集合中去，我们把这种用法称之为集合嵌套。

下面通过一个案例演示一下：

![b60eb3de87b149f8a8e1e2a60feca1e4.png][]

> 案例分析：
> 
> 1. 从需求中我们可以看到，有三个省份，每一个省份有多个城市  
> 我们可以用一个Map集合的键表示省份名称，而值表示省份有哪些城市  
> 2. 而又因为一个身份有多个城市，同一个省份的多个城市可以再用一个List集合来存储。  
> 所以Map集合的键是String类型，而指是List集合类型  
> HashMap<String, List<String>> map = new HashMap<>();

/**
     * 目标：理解集合的嵌套。
     * 江苏省 = "南京市","扬州市","苏州市“,"无锡市","常州市"
     * 湖北省 = "武汉市","孝感市","十堰市","宜昌市","鄂州市"
     * 河北省 = "石家庄市","唐山市", "邢台市", "保定市", "张家口市"
     */
    public class Test {
        public static void main(String[] args) {
            // 1、定义一个Map集合存储全部的省份信息，和其对应的城市信息。
            Map<String, List<String>> map = new HashMap<>();
    
            List<String> cities1 = new ArrayList<>();
            Collections.addAll(cities1, "南京市","扬州市","苏州市" ,"无锡市","常州市");
            map.put("江苏省", cities1);
    
            List<String> cities2 = new ArrayList<>();
            Collections.addAll(cities2, "武汉市","孝感市","十堰市","宜昌市","鄂州市");
            map.put("湖北省", cities2);
    
            List<String> cities3 = new ArrayList<>();
            Collections.addAll(cities3, "石家庄市","唐山市", "邢台市", "保定市", "张家口市");
            map.put("河北省", cities3);
            System.out.println(map);
    
            List<String> cities = map.get("湖北省");
            for (String city : cities) {
                System.out.println(city);
            }
    
            map.forEach((p, c) -> {
                System.out.println(p + "----->" + c);
            });
        }
    }

[f8e3ac1906d7473684bfc7f7e6ef5d75.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/39696de4640d4ace8206c9ad081721ec.png
[19435c49e2ba43a6ab7565ea7738eca3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/160cff7cab07423aa52230deb9ed19a4.png
[ce25417d34e442b690eeb8f4dbf05ab3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/77ed62ae238d43819120c00e0bbd1793.png
[fe374addc83c47269da7a1f943270336.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/982d172aee7e4e0098019647788c4555.png
[ebea81ce580b44ab8321d27864d8bf07.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/8ff8e839883546ff8c6ee4b2afd97b51.png
[4bb0fe6388414436af5cdf8645f7e0fe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/df5ebf0967394aa6a28ea2b174c13186.png
[22a7c6d078bb40809531fec0e5907f72.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/aeb24c1f792b4184904c567d810ff293.png
[cd94b502887b4b7ab350956b3da00de1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/818719344230476bae380dc71c61ae6e.png
[971754df256d44dcaad77d45f3540edf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/6fa08268a4a542f28214dec8c02a8b94.png
[96b3564cd914453bafd17a8fae79a6df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/89f9c523461e4a4dbfca3104a4995aec.png
[228986dbe3ba43a190227189d1143321.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/ea77e878a71f46d9a2fbf9af30e77651.png
[ab4718e2538e4053bf39cb09c762493e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/6a60f53c88c9440eb03b47b29b91063b.png
[bf59a690233647e89ef14b3ca99a6ac2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/f72dc83274cf4204ab008be6d2630258.png
[eef0fdbb6aee49bf8b8cf2672902e3d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/dc607b75c3fb41be9c30108344d405e8.png
[2ab664e4e933458c868e0425f2f6bfac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/444752943c0a458aaff8a90da0f9b813.png
[aad154c69b4e46a98a93384be246cf79.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/e8ece4de235c4d3f9d8dfa5d47f37235.png
[a7db71a028494f609b549e4c9da0ba35.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/d13443bfc2d84eea8f9c27bc07332099.png
[b60eb3de87b149f8a8e1e2a60feca1e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/d4c325fb5eeb4a418c31c3ebf3285ce7.png