Java学习 day08

谁借莪１个温暖的怀抱￠ 2021-11-17 23:18 235阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70][]

## 1 Map接口 ##

1.1 概述  
![20190731105134757.png][]  
1.2 【比较】Collection、Map  
![20190731105247964.png][]  
1.3 增加值  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 1][]  
1.4 删除值  
![20190731143525477.png][]  
1.5 获取值  
![20190731143550282.png][]  
1.6 遍历  
1.6.1 遍历方法一（Set keySet()）  
1.6.1.1 【图示】  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 2][]  
1.6.1.2 【代码】

//方法一
 	public static void test1(Map<String, String> map) {
 		//第一步:先得到装着key的set
 		Set<String> set = map.keySet();
 		//第二步:遍历set,得到key,再根据key获取value
 		Iterator<String> iterator = set.iterator();
 		while (iterator.hasNext()) {
 			String key = iterator.next();
 			System.out.println("key:"+key+" value:"+map.get(key));
 		}
 	}

1.6.2 遍历方法二（Set<Map.Entry<K, V> > entrySet()） 
1.6.2.1 【图示】 
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 3][] 
备注：映射

1.6.2.2 【代码】

//方法二
 	public static void test2(Map<String, String> map) {
 		//第一步:先得到装着Entry实体的set
 		Set<Map.Entry<String,String>> set = map.entrySet();
 		//第二步:遍历set,得到entry实体,再调用entry实体对象的方法获取key和value
 		Iterator<Map.Entry<String,String>> iterator = set.iterator();
 		while (iterator.hasNext()) {
 			Map.Entry<String, String> entry = iterator.next();
 			//通过setValue可以将map的原始值改变,但是一般在使用entrySet的时候,是进行遍历.不进行值的改变.
 			//entry.setValue("bingbing");
 			System.out.println("key1:"+entry.getKey()+" value1:"+entry.getValue());
 		}
 	}

1.7 常用的判断  
![20190731143619166.png][]

## 2 HashMap ##

2.1 概述  
![20190731145016964.png][]  
重点：去重

2.2 【样例】  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 4][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 5][]

## 3 TreeMap ##

3.1 概述  
![20190731175336746.png][]  
3.2 注意点  
（1）什么类型的数据类型可以作为key?  
a:实现了Comparable接口的compareTo()方法  
b:实现了Comparator接口的compare()方法  
可以的代表：String、包装类、自定义的实现了要求的类  
不可以的代表：数组、ArrayList、LinkedList(如果给他们建立的比较器也可以比较,但是不建议使用)  
（2）元素可不可以作为key,跟元素内部的成员有没有关系

3.3 【样例】  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 6][]

## 4 可变参数 ##

4.1 概述  
![20190731112613800.png][]  
4.2 特点  
（1）给可变参数传值的实参可以直接写，个数不限制，内部会自动将它们放入可变数组中  
（2）当包括可变参数在内有多个参数时，可变参数必须放在最后面，并且一个方法中最多只能有一个可变参数  
（3）当可变参数的方法与固定参数的方法是重载关系时，调用的顺序，固定参数的优先于可变参数的  
4.3 【样例】  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 7][]

## 5 增强for循环 ##

5.1 概述  
![2019073119131970.png][]  
5.2 【样例】  
5.2.1 遍历数组  
![2019073119154737.png][]  
5.2.2 遍历Collection  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 8][]  
5.2.3 遍历Map  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 9][]

## 6 Collections ##

6.1 概述：封装了大量操作Collection的工具

6.2 【样例】  
6.2.1 使用Collections排序  
![20190731192329973.png][]  
6.2.2 Collections结合比较器进行排序  
（1）直接使用Comparator  
![20190731192730164.png][]  
（2）重写compare方法  
![20190731192448219.png][]  
![20190731192513376.png][]  
6.2.3 求最大值  
![=][20190731192627213.png]  
6.3 常用方法  
（1）shuffle():使用默认随机源对指定列表进行置换  
![20190731114925503.png][]  
（2）binarySearch():使用二分搜索法搜索指定列表，以获得指定对象  
![20190731114955224.png][]

## 7 ArrayList、LinkedList ##

7.1 ArrayList和LinkedList的区别  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 10][]

## 8 Hash表 ##

8.1 概述  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 11][]  
8.2 扩容机制  
![20190731150224910.png][]  
8.3 排重机制  
![20190731150345133.png][]  
8.4 优点  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 12][]  
8.5 模拟实现代码  
Node类

public class Node {
    // key、value模拟键值对的数据
        public Integer key;
        public String value;
        // 下一节点的引用
        public Node next;
        public Node() {
        }
        public Node(int key, String value) {
            this.key = key;
            this.value = value;
        }
     
    }

MyLinkedList类

public class MyLinkedList {
        // 根节点
        private Node root;
     
        public MyLinkedList() {
            root = new Node();
        }
        /**
         * 添加数据，key值必须唯一，如果重复值将被覆盖
         * @param key
         */
        public void add(int key, String value) {
     
            Node newNode = new Node(key, value);
            Node current = root;
            while (current.next != null) {
                if(current.next.key == key) {
                    current.next.value = value;
                    return;
                }
                current = current.next;
            }
            current.next = newNode;
        }
     
        /**
         * 删除数据
         * @param key
         * @return
         */
        public boolean delete(int key) {
     
            Node current = root;
            while (current.next != null) {
                if(current.next.key == key) {
                    current.next = current.next.next;
                    return true;
                }
                current = current.next;
            }
            return false;
        }
     
        /**
         * 根据key获取value
         * @param key
         * @return
         */
        public String get(int key) {
     
            Node current = root;
            while (current.next != null) {
                if(current.next.key == key) {
                    return current.next.value;
                }
                current = current.next;
            }
            return null;
        }
     
        /**
         * 遍历链表，列出所有数据
         * @return
         */
        public String list() {
     
            String str = "";
            Node current = root.next;
            while (current != null) {
                str += "(" + current.key + "," + current.value + "),";
                current = current.next;
            }
            return str;
        }
     
        @Override
        public String toString() {
            return list();
        }
    }

MyHashMap类

// 哈希表
 public class MyHashMap {
 
 // 链表数组，数组的每一项都是一个链表
 private MyLinkedList[] arr;
 // 数组的大小
 private int maxSize;
 
 /**
 * 空参构造，默认数组大小为10
 */
 public MyHashMap() {
 maxSize = 10;
 arr = new MyLinkedList[maxSize];
 }
 
 /**
 * 带参构造，数组大小自定义
 * @param maxSize
 */
 public MyHashMap(int maxSize) {
 this.maxSize = maxSize;
 arr = new MyLinkedList[maxSize];
 }
 
 /**
 * 添加数据，key值必须唯一
 * @param key
 * @param value
 */
 public void put(int key, String value) {
 
 int index = getHashIndex(key);
 if(arr[index] == null) {
 arr[index] = new MyLinkedList();
 }
 arr[index].add(key, value);
 }
 
 /**
 * 删除数据
 * @param key
 * @return
 */
 public boolean delete(int key) {
 
 int index = getHashIndex(key);
 if(arr[index] != null) {
 return arr[index].delete(key);
 }
 return false;
 }
 
 /**
 * 根据key获取value
 * @param key
 * @return
 */
 public String get(int key) {
 
 int index = getHashIndex(key);
 if(arr[index] != null) {
 return arr[index].get(key);
 }
 return null;
 }
 
 /**
 * 获取数组下标
 * @param key
 * @return
 */
 private int getHashIndex(Integer key) {
 return key.hashCode() % maxSize;
 }
 
 /**
 * 遍历数组中所有链表的数据
 * @return
 */
 public String list() {
 
 String str = "[ ";
 for (int i = 0; i < maxSize; i++) {
 if(arr[i] != null) {
 str += arr[i].toString();
 }
 }
 str = str.substring(0, str.length()-1);
 str += " ]";
 return str;
 }
 
 @Override
 public String toString() {
 return list();
 }
 }

测试类

public class Test {
     
        public static void main(String[] args) {
     
            MyHashMap map = new MyHashMap(20);
     
            map.put(5, "aaa");
            map.put(8, "bbb");
            map.put(3, "ccc");
            map.put(8, "bbb");
            map.put(2, "ddd");
            map.put(9, "eee");
     
            System.out.println(map);
            System.out.println(map.get(3));
            System.out.println(map.delete(2));
            System.out.println(map);
        }
    }

## 9 HashMap和ConcurrentMap ##

9.1 HashMap概述  
![20190731193959558.png][]  
9.2 HashMap的工作原理  
![20190731194736664.png][]  
![20190731194807342.png][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 13][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 14][]  
9.3 HashMap的扩容机制  
![20190731194908255.png][]  
9.4 【比较】HashMap和ConcurentHashMap的区别  
![20190731194932236.png][]  
9.5 segment分段锁  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 15][]  
9.6 红黑树  
![图片来源于https://www.cnblogs.com/skywang12345/p/3245399.html?tdsourcetag=s\_pctim\_aiomsg][https_www.cnblogs.com_skywang12345_p_3245399.html_tdsourcetag_s_pctim_aiomsg]  
![20190731195024354.png][]  
![20190731195040568.png][]  
9.7 大O表示法（时间复杂度、空间复杂度）  
（1）什么是大 O 表示法？  
我们常常会听到有人说，“这个算法在最糟情况下的运行时间是 O(n^2) 而且占用了 O(n) 大小的空间”，他的意思是这个算法有点慢，不过没占多大空间。  
这里的 `O(n^2)` 和 `O(n)` 就是我们通常用来描述算法复杂度的大 O 表示法。  
大 O 表示法能让你对一个算法的**运行时间**和**占用空间**有个大概概念。

（2）大 O 表示法怎么看？怎么用？  
假设一个算法的时间复杂度是 O(n)，n 在这里代表的意思就是数据的个数。举个例子，如果你的代码用一个循环遍历 100 个元素，那么这个算法就是 O(n)，n 为 100，所以这里的算法在执行时就要做 100 次工作。

（3）大O符号是关于一个算法的最坏情况的。比如说，你要从一个大小为 100 的数组（数组中存的都是数字）中找出一个数值等于 10 的元素，我们可以从头到尾扫描一遍，这个复杂度就是 O(n)，这里 n 等于 100，实际上呢，有可能第 1 次就找到了，也有可能是第 100 次才找到，但是大 O 表示法考虑的是最坏的情况，也就是一个算法理论上要执行多久才能覆盖所有的情况。

（4）常见的时间复杂度有：  
常数阶O(1)，对数阶O(log2n)，线性阶O(n)，线性对数阶O(nlog2n)，平方阶O(n2)，立方阶O(n3)，…， k次方阶O(nk)，指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

（5）说明：

大部分情况下你用直觉就可以知道一个算法的大 O 表示法

大 O 表示法只是一种估算，当数据量大的时候才有用

这种东西仅仅在比较两种算法哪种更好的时候才有点用。但归根结底，你还是要实际测试之后才能得出结论。而且如果数据量相对较小，哪怕算法比较慢，在实际使用也不会造成太大的问题。

要知道一个算法的大 O 表示法通常要通过数学分析。在这里我们不会涉及具体的数学，不过知道不同的值意味着什么会很有用。所以这里有一张方便的表。**n** 在这里代表的意思是数据的个数。举个例子，当对一个有 100 个元素的数组进行排序时，**n = 100**。

<table> 
 <thead> 
 <tr> 
 <th>Big-O</th> 
 <th>名字</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>O(1)</td> 
 <td>常数级</td> 
 <td>最好的。不论输入数据量有多大，这个算法的运行时间总是一样的。例子: 基于索引取出数组中对应的元素。</td> 
 </tr> 
 <tr> 
 <td>O(log n)</td> 
 <td>对数级</td> 
 <td>相当好。这种算法每次循环时会把需要处理的数据量减半。如果你有 100 个元素，则只需要七步就可以找到答案。1000 个元素只要十步。100,0000 元素只要二十步。即便数据量很大这种算法也非常快。例子：二分查找。</td> 
 </tr> 
 <tr> 
 <td>O(n)</td> 
 <td>线性级</td> 
 <td>还不错。如果你有 100 个元素，这种算法就要做 100 次工作。数据量翻倍那么运行时间也翻倍。例子：线性查找。</td> 
 </tr> 
 <tr> 
 <td>O(n log n)</td> 
 <td>线性对数级</td> 
 <td>还可以。比线性级差了一些，不过也没那么差劲。例子：最快的通用排序算法。</td> 
 </tr> 
 <tr> 
 <td>O(n^2)</td> 
 <td>二次方级</td> 
 <td>有点慢。如果你有 100 个元素，这种算法需要做 100^2 = 10000 次工作。数据量 x 2 会导致运行时间 x 4 (因为 2 的 2 次方等于 4)。例子：循环套循环的算法，比如插入排序。</td> 
 </tr> 
 <tr> 
 <td>O(n^3)</td> 
 <td>三次方级</td> 
 <td>特别慢。如果你有 100 个元素，那么这种算法就要做 100^3 = 100,0000 次工作。数据量 x 2 会导致运行时间 x 8。例子：矩阵乘法。</td> 
 </tr> 
 <tr> 
 <td>O(2^n)</td> 
 <td>指数级</td> 
 <td>超级慢。这种算法你要想方设法避免，但有时候你就是没得选。加一点点数据就会把运行时间成倍的加长。例子：旅行商问题。</td> 
 </tr> 
 <tr> 
 <td>O(n!)</td> 
 <td>阶乘级</td> 
 <td>比蜗牛还慢！不管干什么都要跑个 N 年才能得到结果。</td> 
 </tr> 
 </tbody> 
</table>

大部分情况下你用直觉就可以知道一个算法的大 O 表示法。比如说，如果你的代码用一个循环遍历你输入的每个元素，那么这个算法就是 **O(n)**。如果是循环套循环，那就是 **O(n^2)**。如果 3 个循环套在一起就是 **O(n^3)**，以此类推。

注意，大 O 表示法只是一种估算，当数据量大的时候才有用。

例如冒泡排序:

假设需要比较的数组中有N个元素，也就意味着外层循环会执行N次即O(n),而内层循环也是要执行N,所以此时冒泡排序的O(n^2)

最好情况下的时间复杂度：如果元素本来就是有序的，那么一趟冒泡排序既可以完成排序工作，比较和移动元素的次数分别是n-1和0，因此最好情况的时间复杂度为O（n）。

最差情况的时间复杂度：如果数据元素本来就是逆序的，进行n-1趟排序，所需比较和移动次数分别为n（n-1）/2和3n(n-1)/2。因此最坏情况子下的时间复杂度为O(n^2)。

## 10 多线程 ##

10.1 概述  
10.1.1 简介  
![20190731164145136.png][]  
10.1.2 多线程的作用：为了实现同一时间干多件事情

10.1.3 任务区  
![\-][-]  
10.1.4 【图示】单CPU多线程工作原理  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 16][]  
10.1.5 其它  
（1）JVM至少是两个线程  
\-主线程：任务区：main函数  
\-垃圾回收线程：任务区：finalize函数

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70]: /images/20211116/7ce196b4ce16404390d320cd80e25603.png
[20190731105134757.png]: /images/20211116/8cbe4615d59e421980a4bbf3f5728a26.png
[20190731105247964.png]: /images/20211116/4985a9a7768b48b9a000958020d7e815.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 1]: /images/20211116/7b031ac98d5042e693e174207e1217cb.png
[20190731143525477.png]: /images/20211116/8b6c2a88876f4c148f32a45f64a98331.png
[20190731143550282.png]: /images/20211116/e9de7c7ce1a44725860e5384d511666a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 2]: /images/20211116/dd89f4a97f56483ba75f9ed233a26b55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 3]: /images/20211116/705ae99244d94dccbd07f23f449b8671.png
[20190731143619166.png]: /images/20211116/bec910b308084a9babbbeabea3a4bc2d.png
[20190731145016964.png]: /images/20211116/63e750594c924ed383650ea3fc56f93a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 4]: /images/20211116/f6b1f540f178437b90f18980616366bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 5]: /images/20211116/d202a461880e414b8da08d79ed8e78e9.png
[20190731175336746.png]: /images/20211116/9b16de238657422d821e626ac895e37f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 6]: /images/20211116/b465f11c10054928839eee248759f4d7.png
[20190731112613800.png]: /images/20211116/f5a3d1f452984426be5ec8b8be7f8968.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 7]: /images/20211116/1541bef935df418aacccc0d926c43eb1.png
[2019073119131970.png]: /images/20211116/f2467be4922240f991a7b1242a6290dd.png
[2019073119154737.png]: /images/20211116/da43268e19694eccbc88862285a8d88c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 8]: /images/20211116/f159123d33b143bfbda5576336641187.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 9]: /images/20211116/365c53b977a44732a06e43c4a79425c8.png
[20190731192329973.png]: /images/20211116/4d75facc7a8b453ba119955773bedcae.png
[20190731192730164.png]: /images/20211116/e6132dc448f64d21bb936c9d61cf8c8f.png
[20190731192448219.png]: /images/20211116/150bda34b1dd484886058fed2a91ed46.png
[20190731192513376.png]: /images/20211116/68c5e82d3f8e47678c3f30e860890f96.png
[20190731192627213.png]: /images/20211116/c084cde2566a4997ae67024aaf69b0da.png
[20190731114925503.png]: /images/20211116/a7e916677f054876bfe01faa566ad2a6.png
[20190731114955224.png]: /images/20211116/ba7487ca29e54f3c824ae4cb96658099.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 10]: /images/20211116/8d363ad811a84584b945026e35e1d690.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 11]: /images/20211116/e75044eb322c460e964cf58953de5d83.png
[20190731150224910.png]: /images/20211116/b02e891a12cb45c29ad2ccec0707f3b7.png
[20190731150345133.png]: /images/20211116/126b9f96a1974964b0e8b1e6600c0c44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 12]: /images/20211116/5bbb014350d1413083c6514093d63ef7.png
[20190731193959558.png]: /images/20211116/df42c03aa43745b294e15628873eb777.png
[20190731194736664.png]: /images/20211116/dfa3735ebb9048329aa62bfb1e24ed2e.png
[20190731194807342.png]: /images/20211116/6325efaba36649c2a05988198f0383d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 13]: /images/20211116/e81b0e986e124d939f4273772d3e3800.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 14]: /images/20211116/da96debc659745699864902807e40975.png
[20190731194908255.png]: /images/20211116/6dd1d3e9ff274697b5b11cddc03975c3.png
[20190731194932236.png]: /images/20211116/3bbc1d8fecd4424dafd9c04adfac0184.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 15]: /images/20211116/fb134c8e734d43beb578c5ca55b47b09.png
[https_www.cnblogs.com_skywang12345_p_3245399.html_tdsourcetag_s_pctim_aiomsg]: /images/20211116/de83fdafa28c4023ba866c2e8a4fc713.png
[20190731195024354.png]: /images/20211116/b4f0c3dd91dd4b019a39f5ec636905f5.png
[20190731195040568.png]: /images/20211116/c814b1f780be49c1af2e9e40b33498b5.png
[20190731164145136.png]: /images/20211116/448aa1de0657424fa80e91eacba6102a.png
[-]: /images/20211116/e14e52ddf3db4a96a80e8dcd55a58ecd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsZXNzaW5nWFJZ_size_16_color_FFFFFF_t_70 16]: /images/20211116/1628da590da14759b80b0fd1bfb2ded2.png