Java集合框架 -- Set和Map接口

向右看齐 2021-11-09 05:58 291阅读 0赞

### 一、Set接口 ###

Set集合代表一个无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问。

**即Set集合无索引、不可以重复（元素唯一）、无序（存取顺序不一致）。**

实现Set接口的集合主要有：HashSet、LinkedHashSet、TreeSet。

### HashSet类 ###

**HashSet是一种没有重复元素的无序集合**，HashSet继承于AbstractSet，实现接口Set，内部使用HashMap来存储数据，数据存储在HashMap的key中，value只是同一个默认值，所以HashSet存储的值是不能重复的。

**1、HashSet类的原理**

（1）底层是哈希表（散列/hash）算法的封装。

（2）HashSet是线程不安全的。如果需要多线程访问，文档推荐如下：

![20190805103120161.png][]

截取的一段源码：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

**2、HashSet类的常用方法（父类重写了toString()方法）具体查看API**

*   *  <table> 
         <tbody> 
          <tr> 
           <td><code>boolean</code></td> 
           <td><code><a rel="nofollow">add</a>(<a rel="nofollow">E</a>&nbsp;e)</code> <p>将指定的元素添加到此集合（如果尚未存在）。</p> </td> 
          </tr> 
          <tr> 
           <td><code>boolean</code></td> 
           <td><code><a rel="nofollow">contains</a>(<a rel="nofollow">Object</a>&nbsp;o)</code> <p>如果此集合包含指定的元素，则返回 true 。</p> </td> 
          </tr> 
          <tr> 
           <td><code>boolean</code></td> 
           <td><code><a rel="nofollow">isEmpty</a>()</code> <p>如果此集合不包含元素，则返回 true 。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">Iterator</a>&lt;<a rel="nofollow">E</a>&gt;</code></td> 
           <td><code><a rel="nofollow">iterator</a>()</code> <p>返回此集合中元素的迭代器。</p> </td> 
          </tr> 
          <tr> 
           <td><code>boolean</code></td> 
           <td><code><a rel="nofollow">remove</a>(<a rel="nofollow">Object</a>&nbsp;o)</code> <p>如果存在，则从该集合中删除指定的元素。</p> </td> 
          </tr> 
          <tr> 
           <td><code>int</code></td> 
           <td><code><a rel="nofollow">size</a>()</code> <p>返回此集合中的元素数（其基数）。</p> </td> 
          </tr> 
         </tbody> 
        </table>

测试demo

public static void main(String[] args) {
            Set<String> set1 = new HashSet<>();
            set1.add("d");
            set1.add("b");
            set1.add("c");
            set1.add("c");
            set1.add("a");
            System.out.println(set1.size());// 4
            System.out.println(set1);// [a, b, c, d]
            set1.remove("b");
            System.out.println(set1);// [a, c, d]
            // 遍历删除
            Iterator<String> it = set1.iterator();
            while (it.hasNext()) {
                Object ele = it.next();
                if ("c".equals(ele)) {
                    it.remove();
                }
            }
            System.out.println(set1); // [a, d]
        }

**3、HashSet类中元素不重复原理**

由源码分析中add()方法可知，HashSet集合中添加元素，实际是作为HashMap的Key存储，

由于 HashMap 的 put() 方法添加 key-value 时，当新放入 HashMap 的 Entry 中 key 与集合中原有 Entry 的 key 相同（hashCode()返回值相等，通过 equals 比较也返回 true），新添加的 Entry 的 value 会将覆盖原来 Entry 的 value，但 key 不会有任何改变，因此如果向 HashSet 中添加一个已经存在的元素时，新添加的集合元素将不会被放入 HashMap中，原来的元素也不会有任何改变，这也就满足了 Set 中元素不重复的特性。

如果添加元素在 HashSet 中不存在的，则返回 true；如果添加的元素已经存在，返回 false。其原因在于 HashMap 的 put 方法。该方法在添加 key 不重复的键值对的时候，会返回 null。

**4、HashSet中判断两个元素对象是否相同:**

当添加新的对象到HashSet集合中时，二者缺一不可：

1）先判断该对象与集合对象中的hashCode值是否相同，如果不相同，则添加，否则，进行步骤2

2）再继续判断该对象与集合对象中的equals进行比较，如果返回false，则添加，否则，表示重复，不添加。

**5、对象的hashCode和equals方法的重要性:**

每一个存储到hash表中的对象，都得提供hashCode和equals方法，用来判断是否是同一个对象。存储在哈希表中的对象，都应该覆盖equals方法和hashCode方法，并且保证equals相等的时候，hashCode也应该相等。

public class SetDemo {
        public static void main(String[] args) {
            Set<Student> set = new HashSet<>();
            set.add(new Student("赵云",1,17));
            set.add(new Student("赵云2",3,18));
            set.add(new Student("赵云3",1,19));
            System.out.println(set.size());// 2 序号重复就判断为同一个人
            System.out.println(set);
            // [Student{name='赵云', studentNumber=1, age=17}, Student{name='赵云2', studentNumber=3, age=18}]
        }
    }
    
    public class Student{
        private String name;
        private int studentNumber;
        private int age;
    
        public Student(String name, int studentNumber, int age) {
            this.name = name;
            this.studentNumber = studentNumber;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", studentNumber=" + studentNumber +
                    ", age=" + 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 studentNumber == student.studentNumber;
        }
        @Override
        public int hashCode() {
            return Objects.hash(studentNumber);
        }
    }

### LinkedHashSet类 ###

LinkedHashSet类继承于 HashSet类

**1、LinkedHashSet类的原理**

（1）底层是哈希表和链表算法。

哈希表：来保证唯一性,.此时就是HashSet,在哈希表中元素没有先后顺序.

链表：来记录元素的先后添加顺序.

（2）LinkedHashSet是线程不安全的。如果需要多线程访问，参考文档

截取的一段源码：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1][]

即 LinkedHashSet  底层是依靠 LinkedHashMap 来实现数据存取的，而 LinkedHashMap 继承于 HashMap，在内部自己维护了一条双向链表用于保存元素的插入顺序，因此使得 LinkedHashSet 也具有了存取有序，元素唯一的特点。LinkedHashSet类的常用方法使用同HashSet类一样。测试demo

public static void main(String[] args) {
            Set<String> set1 = new LinkedHashSet<>();
            set1.add("d");
            set1.add("b");
            set1.add("c");
            set1.add("c");
            set1.add("a");
            System.out.println(set1.size());// 4
            System.out.println(set1);// [d, b, c, a] 记录插入顺序
            set1.remove("b");
            System.out.println(set1);// [d, c, a]
            // 遍历删除
            Iterator<String> it = set1.iterator();
            while (it.hasNext()) {
                Object ele = it.next();
                if ("c".equals(ele)) {
                    it.remove();
                }
            }
            System.out.println(set1); // [d, a]
        }

### TreeSet类 ###

TreeSet是基于TreeMap实现的一个保证元素有序的集合，所以弄清楚TreeMap是关键。

注意：**必须保证TreeSet集合中的元素对象是相同的数据类型，否则报错，**

**1、TreeSet类的原理**

（1）底层是采用红黑树算法，会对存储的元素默认使用**自然排序(从小到大).**

（2）TreeSet是线程不安全的。如果需要多线程访问，参考文档

截取的一段源码：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2][]

**2、TreeSet类的常用方法，具体查看api**

*   *  <table> 
         <tbody> 
          <tr> 
           <td><code>boolean</code></td> 
           <td><code><a rel="nofollow">add</a>(<a rel="nofollow">E</a>&nbsp;e)</code> <p>将指定的元素添加到此集合（如果尚未存在）。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">E</a></code></td> 
           <td><code><a rel="nofollow">first</a>()</code> <p>返回此集合中当前的第一个（最低）元素。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">Iterator</a>&lt;<a rel="nofollow">E</a>&gt;</code></td> 
           <td><code><a rel="nofollow">iterator</a>()</code> <p>以升序返回该集合中的元素的迭代器。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">E</a></code></td> 
           <td><code><a rel="nofollow">last</a>()</code> <p>返回此集合中当前的最后（最高）元素。</p> </td> 
          </tr> 
         </tbody> 
        </table>

测试demo

public static void main(String[] args) {
            TreeSet<String> s = new TreeSet<>();
            s.add("c");
            s.add("f");
            s.add("6");
            s.add("9");
            System.out.println(s); // [6, 9, c, f]
            System.out.println(s.first()); // 6
            // 遍历删除
            Iterator<String> it = s.iterator();
            while (it.hasNext()) {
                Object ele = it.next();
                if ("c".equals(ele)) {
                    it.remove();
                }
            }
            System.out.println(s); // [6, 9, f]
        }

**3、TreeSet的排序规则**

**     1）自然排序(从小到大):**

TreeSet调用集合元素的compareTo方法来比较元素的大小关系，然后将集合元素按照升序排列(从小到大).

注意：要求TreeSet集合中对象元素得实现 java.util.Comparable接口（可比较的）

![20190805114334852.png][]

覆盖 public int compareTo(Object o)方法，在该方法中编写比较规则（当前对象(this)和参数对象o做比较）。

在TreeSet的自然排序中，认为如果两个对象做比较的compareTo方法返回的是0，则认为是同一个对象.

public class ListDemo {
        public static void main(String[] args) {
            Set<Student> set = new TreeSet<>();
            set.add(new Student("赵云",1,17));
            set.add(new Student("赵云2",3,19));
            set.add(new Student("赵云3",5,18));
            set.add(new Student("赵云4",6,18));
            System.out.println(set);
            //[Student{name='赵云', studentNumber=1, age=17}, Student{name='赵云3', studentNumber=5, age=18}, Student{name='赵云2', studentNumber=3, age=19}]
        }
    }
    public class Student implements Comparable<Student>{
        private String name;
        private int studentNumber;
        private int age;
    
        public Student(String name, int studentNumber, int age) {
            this.name = name;
            this.studentNumber = studentNumber;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", studentNumber=" + studentNumber +
                    ", age=" + age +
                    '}';
        }
    
        // 自定义的编写比较规则 (按照年龄来排序) 自然排序
        @Override
        public int compareTo(Student o) {
            if (this.age > o.age) {
                return 1;
            } else if (this.age < o.age) {
                return -1;
            } else {
                return 0;
            }
        }
    }

**2）定制排序(从大到小，按照名字的长短来排序):**

在TreeSet构造器中传递 java.lang.Comparator对象，并覆盖 public int compare(Object o1, Object o2)再编写比较规则。

public class ListDemo {
        public static void main(String[] args) {
            Set<Student> set = new TreeSet<>(new Comparator<Student>() {
                // 自定义编写 定制排序的规则.名字长度升序比较器
                @Override
                public int compare(Student o1, Student o2) {
                    if (o1.getName().length() > o2.getName().length()) {
                        return 1;
                    } else if (o1.getName().length() < o2.getName().length()) {
                        return -1;
                    } else {
                        if (o1.getAge() < o2.getAge() ) { // 当名字长度相等的时候 按年龄降序来排序
                            return 1;
                        } else if (o1.getAge()  > o2.getAge() ) {
                            return -1;
                        } else {
                            return 0;
                        }
                    }
                }
            });
            set.add(new Student("赵云",1,17));
            set.add(new Student("赵云2",3,19));
            set.add(new Student("赵云3",5,18));
            set.add(new Student("赵云4",6,18));
            System.out.println(set);
            //[Student{name='赵云', studentNumber=1, age=17}, Student{name='赵云2', studentNumber=3, age=19}, Student{name='赵云3', studentNumber=5, age=18}]
        }
    }
    class Student{
        private String name;
        private int studentNumber;
        private int age;
    
        public Student(String name, int studentNumber, int age) {
            this.name = name;
            this.studentNumber = studentNumber;
            this.age = age;
        }
    
        // get/set/toString方法
    }

**3）对于TreeSet集合来说，要么使用自然排序，要么使用定制排序.**

判断两个对象是否相等的规则:

自然排序:   compareTo方法返回0;

定制排序:  compare方法返回0;

### 二、Map接口 ###

Map接口采用键值对**Map<K,V>**的存储方式，保存具有映射关系的数据，因此，Map集合里保存两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value可以是任意引用类型的数据。**key值不允许重复**。如果添加key-value对时Map中已经有重复的key，则新添加的value会覆盖该key原来对应的value。

**Map的常用实现类：**

1）HashMap类

采用哈希表算法，此时Map中的key不会保证添加的先后顺序，key也不允许重复.   null 可作为键和值

key判断重复的标准是： key1和key2是否equals为true，并且hashCode相等.

2）TreeMap类

采用红黑树算法，此时Map中的key会按照自然顺序或定制排序进行排序，,key也不允许重复.  null 不可作为键，可作为值

key判断重复的标准是：compareTo/compare的返回值是否为0.

3）LinkedHashMap类

采用链表和哈希表算法，此时Map中的key会保证先后添加的顺序，key不允许重复.

key判断重复的标准和HashMap中的key的标准相同.

4）Hashtable类

采用哈希表算法，是HashMap的前身(古老的集合)。所有的方法都使用synchronized修饰符，线程安全的，但是性能相对HashMap较低. null 不可作为键和值

5）Properties类

Hashtable的子类,此时要求key和value都是String类型,用来加载资源文件

一般的，我们定义Map时，key都使用不可变的类(String)，把key作为value的唯一名称.HashMap和TreeMap以及LinkedHashMap都是线程不安全的,但是性能较高。**如果需要多线程访问，文档推荐如下**：

解决方案: Map m = Collections.synchronizedMap(Map对象);

Map常见方法，具体查看API

*   *  <table> 
         <tbody> 
          <tr> 
           <td><code>boolean</code></td> 
           <td><code><a rel="nofollow">containsKey</a>(<a rel="nofollow">Object</a>&nbsp;key)</code> <p>如果此映射包含指定键的映射，则返回 true 。</p> </td> 
          </tr> 
          <tr> 
           <td><code>boolean</code></td> 
           <td><code><a rel="nofollow">containsValue</a>(<a rel="nofollow">Object</a>&nbsp;value)</code> <p>如果此地图将一个或多个键映射到指定的值，则返回 true 。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">Set</a>&lt;<a rel="nofollow">Map.Entry</a>&lt;<a rel="nofollow">K</a>,<a rel="nofollow">V</a>&gt;&gt;</code></td> 
           <td><code><a rel="nofollow">entrySet</a>()</code> <p>返回此地图中包含的映射的<a rel="nofollow"><code>Set</code></a>视图。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">V</a></code></td> 
           <td><code><a rel="nofollow">get</a>(<a rel="nofollow">Object</a>&nbsp;key)</code> <p>返回到指定键所映射的值，或 <code>null</code>如果此映射包含该键的映射。</p> </td> 
          </tr> 
          <tr> 
           <td><code>boolean</code></td> 
           <td><code><a rel="nofollow">isEmpty</a>()</code> <p>如果此地图不包含键值映射，则返回 true 。</p> </td> 
          </tr> 
          <tr> 
           <td><code>default void</code></td> 
           <td><code><a rel="nofollow">forEach</a>(<a rel="nofollow">BiConsumer</a>&lt;? super <a rel="nofollow">K</a>,? super <a rel="nofollow">V</a>&gt;&nbsp;action)</code> <p>对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">Set</a>&lt;<a rel="nofollow">K</a>&gt;</code></td> 
           <td><code><a rel="nofollow">keySet</a>()</code> <p>返回此地图中包含的键的<a rel="nofollow"><code>Set</code></a>视图。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">V</a></code></td> 
           <td><code><a rel="nofollow">put</a>(<a rel="nofollow">K</a>&nbsp;key, <a rel="nofollow">V</a>&nbsp;value)</code> <p>将指定的值与该映射中的指定键相关联（可选操作）。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">V</a></code></td> 
           <td><code><a rel="nofollow">remove</a>(<a rel="nofollow">Object</a>&nbsp;key)</code> <p>如果存在（从可选的操作），从该地图中删除一个键的映射。</p> </td> 
          </tr> 
          <tr> 
           <td><code>int</code></td> 
           <td><code><a rel="nofollow">size</a>()</code> <p>返回此地图中键值映射的数量。</p> </td> 
          </tr> 
          <tr> 
           <td><code><a rel="nofollow">Collection</a>&lt;<a rel="nofollow">V</a>&gt;</code></td> 
           <td><code><a rel="nofollow">values</a>()</code> <p>返回此地图中包含的值的<a rel="nofollow"><code>Collection</code></a>视图。</p> </td> 
          </tr> 
         </tbody> 
        </table>

测试demo

public static void main(String[] args) {
    
            Map<String, Object> map = new HashMap<>();
            map.put("key1", "v1");
            map.put("key2", "v2");
            map.put("key3", "v3");
            map.put("key3", "v33"); //覆盖上面,即修改key值对应的value
            map.put("key4", "v4");
            System.out.println(map);
            //map.remove("key3");
            //System.out.println(map);
    
            // map 不是集合,所以不能使用foreach
            // 获取map中的所有key
            Set<String> keys = map.keySet(); //类似于一个set
            for (String key : keys) {
                System.out.println(key + "-" + map.get(key)); // 可以根据key的值,获取相对应的value值
            }
            // // 获取map中的所有value
            Collection<Object> values = map.values(); // 类似于一个list
            for (Object value : values) {
                System.out.println(value);
            }
    
            // 获取map中的键值对key-value 推荐使用
    // keySet 其实是遍历了 2 次，一次是转为 Iterator 对象，另一次是从 hashMap 中取出key 所对应的 value。
    //而entrySet 只是遍历了一次就把 key 和 value 都放到了 entry 中，效率更高。
            Set<Map.Entry<String , Object>> entrys = map.entrySet();
            for (Map.Entry<String, Object> entry : entrys) { //entry 里面有获取key和value的方法
                String key = entry.getKey();
                Object value = entry.getValue();
                System.out.println(key + "-" +value);
            }
    
        }

JDK1.8 的话，可使用Map.forEach(...)遍历

// JDK8 可使用 Map.forEach 方法。
            // 方式一
            map.forEach(new BiConsumer() {
                @Override
                public void accept(Object key, Object value) {
                    System.out.println(key + "：" + value);
                }
            });
            // 方式二
            map.forEach((key, value) -> {
                System.out.println(key + "：" + value);
            });

**1、Map边遍历边删除**

public static void main(String[] args) {
    
            Map<String, Object> map = new HashMap<>();
            map.put("key1", "v1");
            map.put("key2", "v2");
            map.put("key3", "v3");
            map.put("key3", "v33"); //覆盖上面,即修改key值对应的value
            map.put("key4", "v4");
            System.out.println(map);
            //map.remove("key3");
            //System.out.println(map);
    
            // 边遍历边删除，两种方式
            //Set<Map.Entry<String , Object>> entrys2 = map.entrySet();
           /* Set<String> keys2 = map.keySet();
            for(Iterator it2 = keys2.iterator();it2.hasNext();){
                String ele = String.valueOf(it2.next());
                if("key3".equals(ele)){
                    it2.remove();  // 使用Iterator接口中的remove() 方法。
                }
            } */
            Set<Map.Entry<String , Object>> entrys2 = map.entrySet();
            Iterator<Map.Entry<String, Object>> iterator = entrys2.iterator();
            while (iterator.hasNext()){
                Map.Entry<String, Object> entry = iterator.next();
                if("key4".equals(entry.getKey())){
                    iterator.remove();  // 使用Iterator接口中的remove() 方法。
                }
            }
            System.out.println(map);
    
        }

**2、List、Set和Map之间的选用：**

选用使用哪个取决于每一种容器的存储特点以及当前业务的需求:

**List:**  单一元素集合。允许元素重复/记录元素的添加顺序.

**Set**：单一元素集合。不允许元素重复/不记录元素的添加顺序。既要不重复,又要保证先后顺序.

**LinkedHashSet.Map**: 双元素集合。用键值对Map<K,V>的存储方式。

**3、List、Set和Map之间相互转换问题: **

List<String> list = new ArrayList<>();

把List转换为Set：Set<String> set = new HashSet<>(list); //此时会消除重复的元素.

把Set转换为List：List<String> list2 = new ArrayList<>(set );

Map不能直接转换为List或Set(但是Map中的方法可以间接的将键或值转换).

**4、一个小需求demo**

public static void main(String[] args) {        
            /**
             * 需求 计算一个字符串中每一个字母出现的次数
             *  用键值对做: Character-->key   ,Integer --> value
             */
            String str = "fadjlkfajdaqweiiueoiruoilknvanjvahjknjddslkpd";
            char[] arr = str.toCharArray(); //将字符串转为数组
            //Map<Character, Integer> map2 = new HashMap<>(); // 无序
            Map<Character, Integer> map2 = new LinkedHashMap<>(); // 插入排序
            //Map<Character, Integer> map2 = new TreeMap<>(); // 自然排序
            for (char ch : arr) {
                //判断map中是否包含了该字符的key
                if(map2.containsKey(ch)){  //如果存在,取出该字符对应的value值加1 ,再放回去
                    Integer num = map2.get(ch);
                    map2.put(ch, num+1);
                }else{ //如果不存在,表示当前map不包含该字符的key,  将ch字符保存为 key ,value值设置为1
                    map2.put(ch, 1);
                }
            }
            System.out.println(map2);
    
        }

HashMap源码分析参考文章：

[https://www.cnblogs.com/winterfells/p/8876888.html][https_www.cnblogs.com_winterfells_p_8876888.html]

[https://blog.csdn.net/qq\_34433210/article/details/90696751][https_blog.csdn.net_qq_34433210_article_details_90696751]

LinkedHashMap源码分析参考文章：

[https://blog.csdn.net/ONROAD0612/article/details/82851060][https_blog.csdn.net_ONROAD0612_article_details_82851060]

简单记录下使用，注意点，具体源码分析，上面作者文章写得不错，可参考。

ends~

[20190805103120161.png]: /images/20211109/23c157f262bd491d80025a625acc9f1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: /images/20211109/aac257be138a448a81cd358b2f3db230.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1]: /images/20211109/4dd6544d79334836bc18ed3cacaf6c54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2]: /images/20211109/e6c17da769f14fef91da813d56c2d97c.png
[20190805114334852.png]: /images/20211109/0df5b9e25f354c23871bdf4ba808e368.png
[https_www.cnblogs.com_winterfells_p_8876888.html]: https://www.cnblogs.com/winterfells/p/8876888.html
[https_blog.csdn.net_qq_34433210_article_details_90696751]: https://blog.csdn.net/qq_34433210/article/details/90696751
[https_blog.csdn.net_ONROAD0612_article_details_82851060]: https://blog.csdn.net/ONROAD0612/article/details/82851060