JDK7 HashMap源码详细解读

客官°小女子只卖身不卖艺 2022-10-30 04:29 205阅读 0赞

## 重要参数 ##

// 初始化默认值 16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    // 数组最大容量 2的30次方
    static final int MAXIMUM_CAPACITY = 1 << 30;
    // 默认加载因子 0.75
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 创建一个空的Entry数组
    static final Entry<?,?>[] EMPTY_TABLE = {};
    // 将空数组赋值给当前数组
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
    // 表示键值对的数目
    transient int size;
    //  阈值   threshold = capacity * loadFactor 例：16*0.75 = 12
    int threshold;
    //  加载因子，默认0.75
    final float loadFactor;

## **构造函数** ##

// 无参构造，传入默认初始容量16、默认加载因子0.75
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
    // 传入自定义桶（数组）容量，默认加载因子为0.75
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    // 泛型上限，Map对象传入键值对，键-传入K类或K的子类，值-传入V类或V的子类
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        putAllForCreate(m);
    }
    // 传入自定义初始容量和加载因子
    public HashMap(int initialCapacity, float loadFactor) {
        // 如果初始容量小于0，则抛出异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        // 如果初始容量大于最大容量，则不再进行扩容操作
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        // 如果负载因子小于等于0,或者等于空，则抛出异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
        // 将加载因子赋值给当前对象的加载因子
        this.loadFactor = loadFactor;
        // 将当前容量赋值给阈值
        threshold = initialCapacity;
        // 此方法为LinkedHashMap所使用
        init();
    }

## put()方法 ##

public V put(K key, V value) {
        // 如果当前数组为空，则给表扩容，此时threshold默认为16
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        // 如果key为null的情况，添加到下标为0的位置
        if (key == null)
            return putForNullKey(value);
        // 计算出key的hash值
        int hash = hash(key);
        // 通过hash值计算数组下标
        int i = indexFor(hash, table.length);
        // 问题？JDK1.7是使用头插法为什么还需要遍历链表
        // 答：因为当前插入的Entry对象可能与链表中的key值重复，需要遍历链表寻找有没有要被替换的。
        // 计算得到哈希地址在在数组中的位置，不为空就开始遍历链表
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
        // 判断hash值是否一样，如果一样再判断键是否相同
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
        // 如果相同，则记录原来的值，并更新为传入的值
        V oldValue = e.value;
                e.value = value;
        // 此方法为LinkedHashMap所使用
                e.recordAccess(this);
        // 返回原来的值
                return oldValue;
            }
        }
        // 哈希映射被修改的次数++，这个跟一个异常有关系
        // Fail-Fast 机制，目的是为了防止并发修改
        // 这是jdk在面对迭代遍历的时候为了避免不确定性而采取的快速失败原则
        modCount++;
        // 问题？为什么不在遍历后直接插入链表？
        // 答：因为有可能遍历不完链表就找到相同的key的情况，需要返回原来的值，所以综合考虑采用头插效率比较高。
        // 将Entry添加到数组中
        addEntry(hash, key, value, i);
        // 添加成功返回null
        return null;
    }

> **Fail-Fast 机制**：
> 
>           java.util.HashMap是线程不安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。这一策略在源码中的实现是通过 modCount 域，modCount 顾名思义就是修改次数，对HashMap 内容的修改都将增加这个值，那么在迭代器初始化过程中会将这个值赋给迭代器的 expectedModCount。在迭代过程中，判断 modCount 跟 expectedModCount 是否相等，如果不相等就表示已经有其他线程修改了Map：注意到 modCount 声明为 volatile，保证线程之间修改的可见性。
> 
> 解决办法：**遍历那些非线程安全的数据结构时，尽量使用迭代器**

**Fail-Fast错误示例：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70][]![20210217153047530.png][]

**Fail-Fast修改如下：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 1][]![20210217153100774.png][]  结果正确！

**头插法链表示意图：**

![20210217153249707.png][]![20210217153254230.png][]

put()中的inflateTable()方法：

private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
        // 找到一个大于或等于tosize的2次幂值
        // 例如：toSize=7，则经过roundUpToPowerOf2后得到的capacity值就为8；toSize=9，计算后的值为16；toSize=8，则计算后的值不变为8
        int capacity = roundUpToPowerOf2(toSize);
        // 计算阈值 例如：16*0.75=12
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        // 创建capacity容量大小的Entry数组
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

inflateTable()中的roundUpToPowerOf2()方法：

private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        // 如果number大于最大容量，则返回最大容量，如果number小于1(等于0的情况)，则返回1
        // 否则返回小于或等于当前number的最大的2次幂值(Integer类方法)
        // highestOneBit()方法返回一个小于或等于2的幂次值，如：传入9，返回8；传入6，返回4
        // 也就是先减一再翻倍找小于翻倍后的最大二次幂值（这种情况就是考虑到2的幂次值）
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

> **符号运算**：true=1，false=0
> 
>         &        逻辑与(并且 and)，遇0则0（都为 1 返回 1，否则返回 0）
> 
>         &&     具有短路效果，左边为0则右边不执行
> 
>         |         逻辑或(or)，遇1则1（遇见 1 返回 1，否则返回 0）
> 
>         ||        具有短路效果，左边为0则右边不执行.
> 
>         ^        逻辑异或(位异或)，两边相同为0，两边不同为1
> 
>         !         逻辑非，非0则1，非1则0
> 
>         <<      左位移-->左边最高位丢弃，右边补齐0                      -->向左移动几位就是乘以2的几次幂
> 
>         >>     右位移-->最高位是0，左边补齐0；最高为是1，左边补齐1   -->向右移动几位就是除以2的几次幂
> 
>         >>>   无符号右移-->无论最高位是0还是1，左边补齐0

> 其中(number - 1) << 1)举例：（先减一再翻倍）
> 
>        16       0001 0000     默认容量大小                      63       0011 1111      随机产生
> 
>        -1       0000 1111       =15                                     -1        0011 1110     =62
> 
>        <<1    0001 1110      =30**最大二进制为16**            <<1     0111 1100      =124**最大二进制为64**

**为什么在roundUpToPowerOf2()方法中****先****减一****再翻倍找小于翻倍后的最大幂次值？**

答：考虑到临界情况，如number=8，如果不减一，直接翻倍就会是16，然后找小于等于16的最大幂次值就会返回16，跟roundUpToPowerOf2()方法要返回结果8违背。如果先减一，就会是7，然后翻倍得到14，找小于等于14的最大幂次值为8，结果与roundUpToPowerOf2()所要返回的结果一致，所以要减一操作。

highestOneBit()方法：

public static int highestOneBit(int i) {
        // HD, Figure 3-1
        i |= (i >>  1);
        i |= (i >>  2);
        i |= (i >>  4);
        i |= (i >>  8);
        i |= (i >> 16);
        return i - (i >>> 1);
    }

看不懂代码？举例跟容易理解

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 2][]

**结论**：移动1次，2次，4次，8次，16次后共移动31位，因为int类型4个bite**最大32位**，所有不论怎么**与运算**后都会得到高位数以下的都为1，然后减去右移的二进制数，就会得到最高位的那个二进制数，也就是当前值的最大次幂值。

put()中hash()方法：

final int hash(Object k) {
        // hashSeed哈希种子
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        // ^位异或  两边相同为0，两边不同为1
        h ^= k.hashCode();
        // 这里的右移做法是为了让高位参与indexFor()方法中的数组做&运算，使结果更加散列
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

put()中indexFor()方法：

static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        // 问题1：传入的数组长度length为什么是2的整数次幂？（&运算，同1才1，否则为0）
        //     答：  h		1001 1101  随机的hashcode
        //           length-1	0000 1111  数组长度16，下标范围[0-15]
        //           &		0000 1101  =13 -->在数组下标范围内
        //     结论：数组下标减一得到的二进制与任何一个二进制做&运算(一定小于等于15)，都会在数组的范围内
        // 问题2：为什么这里采用&运算，不采用%呢？（取余也可以计算出在数组下标范围内）
        // 	  答：这里的hashcode与length-1的相等长度二进制，hashcode值分布随机，得到的地址更有效；位运算比取余运算速度更快一些
        return h & (length-1);
    }

put()中的putForNullKey()方法：

private V putForNullKey(V value) {
        // 如果下标为0号数组不为空，则遍历它
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        // 如果遍历找到key有null，则覆盖它，并返回原来的值
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        // 哈希映射被修改的次数++
        modCount++;
        // 在0号下标添加元素
        addEntry(0, null, value, 0);
        return null;
    }

put()方法中addEntry()方法：

void addEntry(int hash, K key, V value, int bucketIndex) {
        // 判断数组中元素是否超过阈值
        if ((size >= threshold) && (null != table[bucketIndex])) {
            // 如果超过阈值并且不为空
            // 给数组扩容，成倍扩容
            resize(2 * table.length);
            // 如果key等于null返回，否则计算当前key的hash值
            hash = (null != key) ? hash(key) : 0;
            // 计算扩容后要存放的数组下标位置
            bucketIndex = indexFor(hash, table.length);
        }
        // 采用头插法进行插入元素。效率比较高
        createEntry(hash, key, value, bucketIndex);
    }

addEntry()中resize()方法：

void resize(int newCapacity) {
        // 记录原来Entry数组信息
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        // 创建新的数组，其中newCapacity = 2 * table.length
        Entry[] newTable = new Entry[newCapacity];
        // 转移数组 initHashSeedAsNeeded(newCapacity)是判断需不需要生成哈希种子，如果为true则改变了哈希种子，重新hash
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        // 将新表赋值给原来的表
        table = newTable;
        // 计算新表的阈值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

initHashSeedAsNeeded()方法，判断是否需要修改哈希种子

// 此方法就是为了多次扩容后，使更加散列，链更短
    final boolean initHashSeedAsNeeded(int capacity) {
        // hashSeed默认为0，此时currentAltHashing 默认为false
        boolean currentAltHashing = hashSeed != 0;
        // 当设置虚拟机运行时参数为（容量 >= -Djdk.map.althashing.threshold=?）时才会为true
        boolean useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        // ^运算，不同为true，相同为0
        boolean switching = currentAltHashing ^ useAltHashing;
        // 如果要使switching为true，此时currentAltHashing 为false，那么需要useAltHashing为true
        if (switching) {
        // 改变哈希种子的值
            hashSeed = useAltHashing
                ? sun.misc.Hashing.randomHashSeed(this)
                : 0;
        }
        return switching;
    }

resize()中transfer()方法：

void transfer(Entry[] newTable, boolean rehash) {
        // 新表的长度
        int newCapacity = newTable.length;
        // 遍历Entry数组中数据
        for (Entry<K,V> e : table) {
            // 遍历每个Entry对象中链表信息
            while(null != e) {
                // 记录当前链表的下一个节点
                Entry<K,V> next = e.next;
                // rehash默认是false，为true才重新计算哈希（在initHashSeedAsNeeded会改变哈希种子的值）
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                // 重新计算当前节点的hash值
                int i = indexFor(e.hash, newCapacity);
                // 赋值给新数组，采用头插法（多线程情况容易导致死循环）
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }

**转移数组情况：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 3][]

重新计算k1在newTable中的地址，例如在下标3的位置，将当前节点下个节点指向新表的位置：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 4][]

在将当前节点赋值给数组为3的位置，并把e.next赋值给e继续循环，直到遍历完链表：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 5][]

以下假如k2，k3重新计算的hash值都在3的位置，遍历完链表，结果**链表倒置**：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 6][]

**下面演示多个线程访问 死循环情况**：

两个线程同时进入transfer()方法，线程1和线程2都拿到k1和next，两个线程分别新建了两个数组

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 7][]

当线程1把链表循环完，假如重新计算的hash值都在下标1的地方，线程2还是在k1的位置：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 8][]

![20210217155143331.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 9][]

此时线程 1 已经遍历完，线程 2 开始工作：（因为有两个线程进来，所以创建了两个新数组）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 10][]

此时会向第二个数组转移内容：

![20210217155223509.png][]

这时会将**e2赋值给e2.next，e2.next指向k1**，这时就出现了死循环情况了

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 12][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 13][]

**死循环情况出现**。

**问题****：为什么要扩容，扩容的目的是什么？**

答：为了**稀释链表长度，提高查询效率**

**问题****：如何防止在多线程情况下死循环情况？**

答：1、在创建HashMap时不要它扩容，就固定的长度，会防止扩容产生的死循环情况。

2、在业务层判断的时候进行并发控制也可以防止死循环，加锁等。

addEntry()中createEntry()方法：

void createEntry(int hash, K key, V value, int bucketIndex) {
        // 将当前位置的元素记录在e中
        Entry<K,V> e = table[bucketIndex];
        // 创建一个新的Entry对象，将当前对象的下一个元素指向e，并将当前对象赋值给表当前位置
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

## get()方法 ##

public V get(Object key) {
        // 如果key等于null，则查找下标为0的数组，并遍历
        if (key == null)
            return getForNullKey();
        // 根据键找值
        Entry<K,V> entry = getEntry(key);
        // 如果都没有找到键，则返回null，否则返回对应的值
        return null == entry ? null : entry.getValue();
    }

getForNullKey()方法：

private V getForNullKey() {
        // 数组为空，则返回null
        if (size == 0) {
            return null;
        }
        // 循环遍历下标为0的数组中的链表，直到找到key为null的键
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        // 没有找到返回null
        return null;
    }

getEntry()方法：

final Entry<K,V> getEntry(Object key) {
        // 数组为空，返回null
        if (size == 0) {
            return null;
        }
        // 计算key的hash值
        int hash = (key == null) ? 0 : hash(key);
        // 根据hash值找到数组元素，并遍历链表，找到就返回Entry对象
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        // 没有找到就返回null
        return null;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210217153041297.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw,size_16,color_FFFFFF,t_70
[20210217153047530.png]: /images/20221024/2474cd0fad8e49b6b7d6825ad52119e9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210217153054929.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw,size_16,color_FFFFFF,t_70
[20210217153100774.png]: /images/20221024/72818b9882bc427682f580b72358989d.png
[20210217153249707.png]: https://img-blog.csdnimg.cn/20210217153249707.png
[20210217153254230.png]: /images/20221024/9252a77582ac44839cade2a24bd5f486.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 2]: /images/20221024/4b461b4ed73b433e930389a78d57b077.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 3]: /images/20221024/2c972e6684884dc18f18bba311016498.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 4]: /images/20221024/d9067763af234abf8c3d9247f2af8366.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 5]: /images/20221024/738ec890b86a43a9b540af99ac21b822.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 6]: /images/20221024/d415d0be29d04320bba1436075c197ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 7]: /images/20221024/930a642823b04fe3ba6e518289bd3e8f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 8]: /images/20221024/552b59d438b946dbae923a452945d202.png
[20210217155143331.png]: /images/20221024/5b56de94ef304d54abf468b23dccc9e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 9]: /images/20221024/605664e7ec784d61adef72e84575cf8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 10]: /images/20221024/7de35dd9c76a4ddf8cd2bb5720191408.png
[20210217155223509.png]: /images/20221024/b09f457c7a05448db5af40d61f001d2e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 11]: /images/20221024/60935a3914bc438c9588f471636f4a53.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 12]: /images/20221024/353ce92ebc4b4fd189aba0928fb82b9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTQyNzIw_size_16_color_FFFFFF_t_70 13]: /images/20221024/468b2650cc0642c3a9de5265c6d606c6.png