HashMap源码详解分析，基于jdk1.8

╰半橙微兮° 2021-12-10 10:53 440阅读 0赞

在Java集合中，有一种基于哈希表键值对key-value的形式， 实现了Map接口，并且允许使用 null key 和 null value；

在和jdk1.8版本对之前的hashMap对比，做了很大的优化，包括实现方式：

底层存储由之前的“数组+链表”改为“数组+链表+红黑树”，

还有扩容的一些细节改造等；

**目录**

1、源码前瞻思考

（1）、hashMap 的数据结构形式？

（2）、每一个key,value的键值对存储单元是什么？

（3）、数组是不是应该有个大小呢？

（4）、数据链表大小的一个解决方案

（5）、新插入的数据存哪里？

（6）、数组table(tab)下标怎么来的？为什么用按位&运算？

（7）、为什么计算容量大小等用移位运算？

2、HashMap源码分析

（1）、客户端调用

（2）、类的其他属性

（3）、put(k,v)插入元素方法

（4）、扩容方法resize()

（5）、get方法，获取节点

（6）、其他方法

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

# 1、源码前瞻思考 #

## （1）、hashMap 的数据结构形式？ ##

key,value 键值对进行存储的话，使用的数据结构是什么？

集合 ArrayList 还是 LinkedList？

HashMap既想要查询效率快，也想要增删效率高？

能不能结合数据和链表的优势，所以我们能猜测底层会不会是数据加链表形式？

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70][]

## （2）每一个key,value的键值对存储单元是什么？ ##

Java是一门面向对象的语言，

该怎么存储key,value单元呢，结合上图，需要在每组key,value键值对之间建立关系，如何设计这个对象？

节点对象信息如下：

/**
         * Basic hash bin node, used for most entries.  (See below for
         * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
         */
        static class Node<K,V> implements Map.Entry<K,V> {
            final int hash;
            final K key;
            V value;
            Node<K,V> next;
    
            Node(int hash, K key, V value, Node<K,V> next) {
                this.hash = hash;
                this.key = key;
                this.value = value;
                this.next = next;
            }
    
            ...
        }

有数组的关系，会不会有一个存储数组的节点呢？

数组存储对象节点:

transient Node<K,V>[] table;

## （3）数组是不是应该有个大小呢？ ##

默认初始化大小？上限大小？如果数据增加，大小需要扩容？扩容依据？

/*
    *初始化、扩容数组方法
    */
    final Node<K,V>[] resize()
    
    
    
    /**
     * 默认容量，必须2的次幂
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    
    /**
    * 最大容量，必须2的次幂，小于等于 1<<30
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;
    
    /**
     * 扩容因子 
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

## （4）数据链表大小的一个解决方案 ##

数组table的最大值是 1 << 30；

如果链表大小一直增加，会不会影响效率？

链接转另外的数据结构，红黑树？

转的条件是什么？，如果链表又重新变小，红黑树又转回单链表的数据结构，依据是什么？

看下面的各类阈值（拼音：\[yù zhí\] ；不读fa zhi）

/**
     *数组某个下标的链表节点数超过8个的时候，即hash值相同冲突的链表节点*个数，
    并且数组容量大于64的时候，链表会做红黑树转换
    
    /
    static final int TREEIFY_THRESHOLD = 8;
    /**
     * The bin count threshold for untreeifying a (split) bin during a
     * resize operation. Should be less than TREEIFY_THRESHOLD, and at
     * most 6 to mesh with shrinkage detection under removal.
    
    *删除数组某个下标的链表节点数，少于6个的时候，即hash值相同冲突的链*表节点个数，
    红黑树又转换为普通链表
    
    */
    static final int UNTREEIFY_THRESHOLD = 6;
    /**
     * The smallest table capacity for which bins may be treeified.
     * (Otherwise the table is resized if too many nodes in a bin.)
     * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
     * between resizing and treeification thresholds.
    
    * 数组容量capacity小于MIN_TREEIFY_CAPACITY  64的时候，
    
    * hash值相同的链表先不转为红黑树，先进行一次扩容；
    
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

## （5）、新插入的数据存哪里？ ##

新插入的数据Node<Key,value>存在哪里？释放应该有一个约束，通过计算Key值？怎么计算？

右移16位，充分的把int类型数据32位利用起来，使hash分布更均匀；

低位16位  异或 高位16位： h ^  (h >>> 16)；

异或运算：参与运算的两个值，如果两个相应位相同，则结果为0，否则为1。即：0^0=0， 1^0=1， 0^1=1， 1^1=0；

用为通常h是很小的，当h很小是只能使用上hashCode低16位的数据，这会产生一个问题，既键值对在hash数组中分布不均匀，hash碰撞多，链表过长，而把hashCode>>>16无符号右移16位让高16位间接的与hashCode参加计算，从而让键值对分布均匀，得到扰动后的hash值，降低hash碰撞。

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

数组默认初始化大小是***DEFAULT\_INITIAL\_CAPACITY*** = 1 << 4，如果计算出来的hash值，比数组下标大怎么办？显然hash不能直接用来当做数组的下标;

## （6）、数组table(tab)下标怎么来的？为什么用按位&运算？ ##

为什么数组的大小一定是2的次幂？

这样在进行运算的时候，2的次幂-1，假如这里数组大小是默认的2的4次方16，16-1=15，15的二进制表示如下图第一行，后4位全是1，前面位是0，共32位，这样在与hash(传递进来key计算后的哈希值)进行&运算的时候，数组下标不会越界，并且会使得计算后的下标值均匀的分布在了数组tab中，减少hash碰撞；

等价于hash% n运算，但是二进制运算效率更高；

按位与运算：两个都为1，结果为1，否则为0：

1&1=1 , 1&0=0 , 0&1=0 , 0&0=0；

![20190713183057181.png][]

n是数组大小，hash是扰动后的hash值，这里通过&运算得到该hash值在tab数组中存储的下标位置：

tab\[i = (n - 1) & hash\]

如果说，数组大小不为2的次幂-1，如下图第一行，右第三位的数据为0，那么不管和他&计算的第二行hash值该位是否为1或者0，导致第三行计算结果，该位置都为0，这个位置无法存储数据，那么也导致了数组分布不均匀；

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 1][]

## （7）、为什么计算容量大小等用移位运算？ ##

因为运行效率高，你直接用int数值表示的话，JVM还是会先转换成二进制然后进行移位运算；

# 2、HashMap源码分析 #

## （1）、客户端调用 ##

Map<String,String> map =  **new** HashMap<String,String>();  
  
map.put(**"name"**,**"james"**);

然后到构造方法，常用的构造方法有如下3个：

有默认构造方法，

带参构造方法也可以自定义初始化大小，扩容因子：

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
    
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

我们来看一下第一个构造方法中*tableSizeFor()**方法，用于返回初始容量：*

/**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ?
        MAXIMUM_CAPACITY : n + 1;
    }

*给定一个整数cap, 计算等于或大于这个整数的第一个2次冥，比如输入参数10，会返回16，那么初始大小容量默认就为16，而不是10；*

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 2][]

上面此图来自内容：[https://blog.csdn.net/fan2012huan/article/details/51097331][https_blog.csdn.net_fan2012huan_article_details_51097331]

## （2）类的其他属性 ##

//哈希数组，存放链表。 长度是2的N次方，或者初始化时为0.
    transient Node<K,V>[] table;
    
    //缓存数据到entrySet中，用于后续遍历
    transient Set<Map.Entry<K,V>> entrySet;
    
    //数组大小
    transient int size;
    
    //数组被修改的次数
    transient int modCount;
    
    //阈值，到达这个值，节点数组需要扩容
    int threshold;
    
    //扩容因子 
    final float loadFactor;

## （3）、put(k,v)插入元素方法 ##

下图的流程图来自：[https://blog.csdn.net/carson\_ho/article/details/79373134][https_blog.csdn.net_carson_ho_article_details_79373134]

![ç¤ºæå¾][aHR0cDovL3VwbG9hZC1pbWFnZXMuamlhbnNodS5pby91cGxvYWRfaW1hZ2VzLzk0NDM2NS1jMjYzZDg3ZTVlZWNkY2IwLnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwJTdDaW1hZ2VWaWV3Mi8yL3cvMTI0MA]

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    
    /**
     * Implements Map.put and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
    	//resize()方法数组初始化，这里是延迟初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
    	//计算key的哈希值，通过扰动，得到插入数组tab的下标位置
    	//如果这个索引位置为空，第一次放进来时，说明之前没有元素
    	//创建节点，放到这个数组下标，直接插入这个元素 ,现在无hash冲突；
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
    	    //如果这个索引位置不为空，说明之前有节点插入
            Node<K,V> e; K k;
    	    //判断这个key是否存在，此时hash值相等，并且key相等，
    	    //说明是同一个key，覆盖该元素 
            if (p.hash == hash &&
                ((k = p.key) == key ||
               (key != null && key.equals(k))))
                e = p;
    	    //如果这个节点是树类型，那么走红黑树的插入方式
            else if (p instanceof TreeNode)
              e = ((TreeNode<K,V>)p).
                 putTreeVal(this, tab, hash, key, value);
            else {
    	        //节点不为树类型，开始遍历这个索引位置的链表，
    	        //在这里插入到链表尾部；
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
    	        //在遍历链表时，需要去判断当前链表长度，已经到达阈值
    	        // TREEIFY_THRESHOLD  8，如果达到了，链表转红黑树;
               if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                         treeifyBin(tab, hash);
                        break;
                }
    		    //是否存在相同key，存在则覆盖
                 if (e.hash == hash &&
                  ((k = e.key) == key ||
                     (key != null && key.equals(k))))
                    break;
                    p = e;
                }
            }
    	    //对i情况的后续操作：发现key已存在，直接新value 覆盖
            // 覆盖旧value， 并且返回旧的value
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
    		    // onlyIfAbsent 默认传进来false，默认覆盖value
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
    		    // 替换旧value值调用的方法，LinkedHashMap回调方法
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //修改次数+1
        ++modCount;
        //如果数组大小超过阈值，那么扩容
        //扩容会比较影响效率
        if (++size > threshold)
            resize();
        //插入成功时会调用的方法（LinkedHashMap回调方法）
        afterNodeInsertion(evict);
        return null;
    }

## （4）、扩容方法resize() ##

这个方法主要用来：

a、初始化空的hash数组；

b、对旧的hash数组进行扩容：

例如初始容量是16，当容量达到 16 \* loadFactor(默认值0.75)，大小时候，

直接扩容到以前两倍大小，新容量为32；

扩容因子为什么为 0.75，这是时间和空间成本上一种折衷：

如果加载因子较小，那么扩容的几率就增高，并且浪费不必要的内存空间；

如果加载因子比较大，总是数组快满了才扩容，则增大数字hash碰撞概率，影响查询效率；

所以0.75是官方给的一个折中方案；

增大负载因子可以减少 Hash 表所占用的内存空间，但会增加查询数据的时间开销，而查询是最频繁的的操作（HashMap 的 get() 与 put() 方法都要用到查询）；减小负载因子会提高数据查询的性能，但会增加 Hash 表所占用的内存空间。具体实现细节请看下面：

下图的流程图来自：[https://blog.csdn.net/carson\_ho/article/details/79373134][https_blog.csdn.net_carson_ho_article_details_79373134]

![ç¤ºæå¾][aHR0cDovL3VwbG9hZC1pbWFnZXMuamlhbnNodS5pby91cGxvYWRfaW1hZ2VzLzk0NDM2NS05ZmIzZmVjMDdhMDc2NGVjLnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwJTdDaW1hZ2VWaWV3Mi8yL3cvMTI0MA]

/**
     * Initializes or doubles table size.  If null, allocates in
     * accord with initial capacity target held in field threshold.
     * Otherwise, because we are using power-of-two expansion, the
     * elements from each bin must either stay at same index, or move
     * with a power of two offset in the new table.
     *
     * @return the table
     */
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
    	//如果tab为空，先初始化
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
    	//如果旧的容量大小达到最大值，则不再扩容，返回旧数组
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
    	//新的容量大小为旧的两倍，左移一位；
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
    	//新的阈值为旧的两倍
                newThr = oldThr << 1; // double threshold
        }
    
        //初始化hash数组情况（采用指定值或默认值）	
        else if (oldThr > 0) //initial capacity was placed in threshold
            newCap = oldThr;
        else {  // zero initial threshold signifies using defaults
          newCap = DEFAULT_INITIAL_CAPACITY;
          newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //newThr 为 0 时，按阈值计算公式进行计算
        if (newThr == 0) {
          float ft = (float)newCap * loadFactor;
          newThr = (newCap < MAXIMUM_CAPACITY && 
                    ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        //创建新的hash数组，hash数组的初始化也是在这里完成的
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            //开始遍历旧数组的每个节点
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
    	          //先把旧数组的引用指向为空，便于GC，并且已经赋值给e
                  oldTab[j] = null;
                  if (e.next == null)
    	            //确定新数组大小下标，同样采用了是hash值
    	            //均匀分布在新数组下标的算法
                    newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
    	            //重组时，需要对红黑树节点进行拆分
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
    	            //元素的位置要么是在原位置，要么是在原位置+oldCap容量的位置
                    // 低位链表的lowHead、lowTail头结点、尾节点
                    Node<K,V> loHead = null, loTail = null;
                    // 高位链表的highHead、highTail头结点、尾节点
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    //因为扩容是容量翻倍，所以原链表上的每个节点，
                    //现在可能存放在原来的下标，即low位， 或者扩容后的下标，
                    //即high位。 high位 = low位+原哈希桶容量
                    do {
    			     //原下标位置
                      next = e.next;
                      //这里又是一个利用位运算，代替常规运算的高效点： 
                      //利用哈希值与旧的容量，可以得到哈希值去模后，
                      //是大于等于oldCap还是小于oldCap，
                      //等于0代表小于oldCap，
                      //应该存放在低位，否则存放在高位
                       if ((e.hash & oldCap) == 0) {
                           if (loTail == null)
                              loHead = e;
                            else
                              loTail.next = e;
                              loTail = e;
                            }
    			            // 原下标位置+oldCap
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
    			        // 原下标放到新数组位置
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        // 原下标+oldCap放到新数组位置
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

我们发现一些细节：经过观测，我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置（原位置+旧容量大小）。看下图可以明白这句话的意思，n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果:

![20190713183156754.png][]

我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”；

这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的数组其他下标中去了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，在JDK1.8不会倒置。

## （5）、get方法，获取节点 ##

public V get(Object key) {
        Node<K,V> e;
    	//计算需获取数据的hash值
        return (e = getNode(hash(key), key)) == null 
         ? null : e.value;
    }
    
    /**
     * Implements Map.get and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //计算存放在数组table中的位置
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            // 通过该函数，依次在数组、红黑树、链表中查找
            // （通过equals（）判断）
            // 先在数组中找，若存在，则直接返回
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || 
                (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                        (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

## （6）其他方法 ##

// 返回哈希表中所有 键值对的数量 = 数组中的键值对 + 链表中的键值对；
    
    public int size() {
        return size;
    }
    
    // 判断是否存在该键的键值对；是 则返回true；
    
    public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }
    
    // 判断是否存在该值的键值对；是 则返回true；
    
    public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        if ((tab = table) != null && size > 0) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }
    
    // 删除节点
    
    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }
    
    
    
    //缓存 entrySet，一般遍历用
    
    transient Set<Map.Entry<K,V>> entrySet;
    
    public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
    }

关于数据结构红黑树的分析，可以参照另一篇单独介绍红黑树博客：[https://blog.csdn.net/lejustdoit/article/details/95588894][https_blog.csdn.net_lejustdoit_article_details_95588894]

如果想对HashMap红黑树这块代码熟悉的，请参考贴：[https://blog.csdn.net/v123411739/article/details/78996181][https_blog.csdn.net_v123411739_article_details_78996181]

其他Hashmap参考帖子：[https://blog.csdn.net/carson\_ho/article/details/79373134][https_blog.csdn.net_carson_ho_article_details_79373134]

[https://tech.meituan.com/2016/06/24/java-hashmap.html][https_tech.meituan.com_2016_06_24_java-hashmap.html]

[https://blog.csdn.net/zxt0601/article/details/77413921][https_blog.csdn.net_zxt0601_article_details_77413921]

[ConcurrentHashMap详解 jdk1.8源码分析][ConcurrentHashMap_ jdk1.8]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70]: /images/20211210/fd1c8aa04abf4e9587abb7bb7a42353c.png
[20190713183057181.png]: /images/20211210/04a3420dc8c546d6bab3115a6cae216c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 1]: /images/20211210/305a9c6219bc4096a663cad379a5f629.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlanVzdGRvaXQ_size_16_color_FFFFFF_t_70 2]: /images/20211210/d0a440d1d9884850b71356f752bf12dc.png
[https_blog.csdn.net_fan2012huan_article_details_51097331]: https://blog.csdn.net/fan2012huan/article/details/51097331
[https_blog.csdn.net_carson_ho_article_details_79373134]: https://blog.csdn.net/carson_ho/article/details/79373134
[aHR0cDovL3VwbG9hZC1pbWFnZXMuamlhbnNodS5pby91cGxvYWRfaW1hZ2VzLzk0NDM2NS1jMjYzZDg3ZTVlZWNkY2IwLnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwJTdDaW1hZ2VWaWV3Mi8yL3cvMTI0MA]: /images/20211210/063121594b684b8cacdae96b01e29068.png
[aHR0cDovL3VwbG9hZC1pbWFnZXMuamlhbnNodS5pby91cGxvYWRfaW1hZ2VzLzk0NDM2NS05ZmIzZmVjMDdhMDc2NGVjLnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwJTdDaW1hZ2VWaWV3Mi8yL3cvMTI0MA]: /images/20211210/b6523c09feb94c2aaf84916891dc0b02.png
[20190713183156754.png]: https://img-blog.csdnimg.cn/20190713183156754.png
[https_blog.csdn.net_lejustdoit_article_details_95588894]: https://blog.csdn.net/lejustdoit/article/details/95588894
[https_blog.csdn.net_v123411739_article_details_78996181]: https://blog.csdn.net/v123411739/article/details/78996181
[https_tech.meituan.com_2016_06_24_java-hashmap.html]: https://tech.meituan.com/2016/06/24/java-hashmap.html
[https_blog.csdn.net_zxt0601_article_details_77413921]: https://blog.csdn.net/zxt0601/article/details/77413921
[ConcurrentHashMap_ jdk1.8]: https://blog.csdn.net/lejustdoit/article/details/96757538