HashMap從認識到原始碼分析

Map

Map在開發過程中使用頻率很高的資料結構，Map是Key-value鍵值對對映的抽象介面，該對映不包括重複的鍵，既一個鍵對應一個值。HashMap、HashTable、ConcurrentHashMap都是Java Collection Framework的重要成員。Map介面提供三種collection檢視，允許以鍵集(keySet())、值集(values())或鍵-值對映關係集(entrySet())的形式檢視某個對映的內容。

HasH表

我們知道陣列的儲存方式是在記憶體上分配固定的連續的空間，定址速度快（查詢速度快），時間複雜度為O(1)，但是在插入、刪除元素時候需要移動陣列的元素，所以插入、刪除時候速度慢，時間複雜度為O(n)。連結串列的儲存方式在記憶體上是不連續的，每個元素都儲存著下個元素的記憶體地址，通過這個地址找到下個元素，所以連結串列在查詢的時候速度慢，時間複雜度為O(n)，在插入和刪除的時候速度快，時間複雜度為O(1)。
如果我們想要一個資料結構既查詢速度快，插入和刪除速度也要快，那我們應該怎麼做呢？這時雜湊(Hash)表就應時而生了，通過雜湊函式計算出鍵在雜湊表中指定的儲存位置(注意這裡的儲存位置是在表中的位置，並不是記憶體的地址)，稱為雜湊地址，然後將值儲存在這個雜湊地址上，然後通過鍵就可以直接操作到值，查詢、插入、刪除等操作時間複雜度都是O(1)。
既然是鍵通過雜湊函式計算出儲存位置，那麼雜湊函式的好壞直接影響到雜湊表的操作效率，如會出現浪費儲存空間、出現大量衝突(即不同的鍵計算出來的儲存位置一樣)。

雜湊函式可以將任意長度的輸入對映成固定長度的輸出，也就是雜湊地址 雜湊衝突是不可避免的，常用的雜湊衝突解決辦法有以下2種方法。

1. 鏈地址法(拉鍊法)
   採用陣列和連結串列結合的方法，對雜湊表中每個雜湊地址建立一個線性表，將雜湊地址相同的資料儲存線上性表中，並將連結串列的頭指標儲存在陣列中，雜湊地址、鍵、值等資訊一般儲存在連結串列節點中。一般通過雜湊地址計算出陣列的下標，將雜湊值相同的儲存在下標相同的陣列中的。拉鍊法適合經常進行插入、刪除操作的情況。

   

2. 開放定址法
   開放定址法也稱線性探測法，基本思想是：將雜湊表T[0...m-1]看成是個迴圈向量，若初始探測地址為d，則最長的探測路徑為：d，d+i，d+2i，...，m-1。即探測時候從地址d開始，首先探測T[d]，如果T[d]發生雜湊衝突則繼續探測下一個T[d+1]...直到探測到T[m-1]為止，i為自定義的常數。開放定址法很容易產生堆聚現象，所謂堆聚現象就是雜湊表中的資料連成一片，在加入新元素的時候就容易產生雜湊衝突。
3. 拉鍊法和開放定址比較
   拉鍊法：處理衝突簡單，無堆聚現象，同時連結串列插入、刪除操作簡單，所以拉鍊法適合經常進行插入、刪除操作的情況。
   開放定址法：為了減少衝突，要求**負載因子(裝填因子)**較小，當節點規模較大時候會浪費很多空間。且開放定址法在刪除節點的時候，不能簡單的將節點所在的空間置為空，否則將截斷在它之後的節點的查詢路徑，這是因為各種開放定址法中，空地址單元都是查詢失敗的條件。因此在進行刪除節點操作的時候，需要使用邏輯刪除，即在被刪除的節點上做刪除標記。

負載因子 = 填入雜湊表中的元素個數 / 雜湊表的陣列長度

HashMap

資料結構

HashMap採用上述的拉鍊法解決雜湊衝突.HashMap是非執行緒安全的，允許鍵、值為null，不保證有序(比如插入的順序)，也不保證順序不隨時間變化(雜湊表加倍擴容後，資料會有遷移)。
我們建立個HashMap執行看看

HashMap<String, Integer> map = new HashMap();
map.put("語文", 1);
map.put("數學", 2);
map.put("英語", 3);
map.put("歷史", 4);
map.put("政治", 5);
map.put("地理", 6);
map.put("生物", 7);
map.put("化學", 8);
複製程式碼

通過圖可以看到HashMap並不是按照插入順序儲存的(無序的)。
接下來我們看看HashMap的資料結構

HashMap有幾個重要的成員變數，table，size，threshold，loadFactor，modCount。

• table：是一個Entry[]陣列型別，而Entry實際上是一個單向連結串列，雜湊表的鍵值對都是儲存在Entry陣列中，每個Entry對應一個雜湊地址，這裡的Entry即常說的桶
• size：是HashMap的大小，為儲存的鍵值對的數量
• DEFAULT_INITIAL_CAPACITY：HashMap預設容量(陣列的大小) 預設為16
• MAXIMUM_CAPACITY：HashMap的最大容量(2的30)，如果傳入的容量大於這個值，則被最大容量替換
• threshold：是HashMap的閾值，用於判斷是否需要調整HashMap的容量。threshold=容量*負載因子，當HashMap中儲存的鍵值對數量到達threshold時，HashMap就會將容量加倍的擴容
• loadFactor：即負載因子
• modCount：用來實現快速失敗(fail-fast)機制的

快速失敗機制：對於執行緒不安全(注意是執行緒不安全的集合才有這個機制)的集合物件的迭代器，如果在使用迭代器的過程中有其他的執行緒修改了集合物件的結構或者元素數量，那麼迭代立刻結束，迭代器將丟擲ConcurrentModificationException。

建構函式

HashMap有4個建構函式，如下：

//無參建構函式，負載因子為預設的0.75，HashMap的容量(陣列大小)預設容量為16
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

//指定HashMap容量大小的建構函式 負載因子為預設的0.75
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

//指定HashMap容量大小和負載因子的建構函式
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);
}

//包含子Map的建構函式，負載因子為預設的0.75
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}
複製程式碼

為什麼負載因子預設是0.75？按照官方給出的解釋是，當負載因子為0.75時候，Entry單連結串列的長度幾乎不可能超過8(到達8的概率是0.00000006)，作用就是讓Entry單連結串列的長度儘量小，讓HashMap的查詢效率儘可能高。

由於當HashMap的大小(即size)大於初始容量(capacity)時候，HashMap就會擴大一倍，由於很多時候並不需要擴大這麼多，所以當我們知道我們的資料的大小的時候，就可以在HashMap初始化的時候指定容量(陣列大小)。
需要注意的是，我們指定的容量必須是2的冪次方，即使我們傳入的容量不是2的冪次方，原始碼中也會將容量轉成2的冪次方，比如我們傳入的是5，最終的容量是8。

為什麼容量一定要是2的冪次方？因為HashMap是陣列+單連結串列的結構，我們希望元素的存放的更均勻，最理想的狀態是每個Entry中只存放一個元素，這樣在查詢的時候效率最高。那怎麼才能均勻的存放呢？我們首先想到的是取模運算 雜湊地址%容量大小，SUN的大師們的想法和我們的也一樣，只不過他們使用位運算來實現這個運算(位運算效率高)，為了使位運算和取模運算結果一樣，即hash & (capacity - 1) == hash % capacity，容量(Capacity)的大小就必須為2的冪次方。

put方法

在JDK1.8之前hashMap的插入是在連結串列的頭部插入的，本文分析的是JDK1.8原始碼，是在連結串列的尾部插入的。

1. 根據鍵(key)的hashCode()計算出當前鍵值對的雜湊地址，用於定位鍵值對在HashMap陣列中儲存的下標
2. 判斷table是否初始化，沒有初始化則呼叫resize()為table初始化容量，以及threshold的值
3. 根據**table陣列長度和雜湊地址做&運算(i = (n - 1) & hash)**計算出該key對應的table陣列索引，如果對應的陣列索引位置沒有值，則呼叫newNode(hash, key, value, null)方法，為該鍵值對建立節點。

這裡思考個問題，當table陣列長度變化後，是不是取到的值就不正確了？後面給出分析。這裡簡單分析下為什麼不是直接按照雜湊地址做陣列下標，而是用table陣列長度和雜湊地址做&運算(i = (n - 1) & hash)(因為陣列的大小是2的冪次方，所以這個運算等效於mod 陣列大小的運算)計算陣列下標，因為雜湊地址可能超過陣列大小，還有就是為了讓鍵值對更均勻的分佈的在各個桶(連結串列)中，也因為容量會變所以各個桶(連結串列)中的節點的雜湊地址並不是相同的，相同的雜湊地址也可能分到不同的下標。

4. 如果根據雜湊地址計算出該key對應的table陣列索引有節點，且節點的鍵key和傳入的鍵key相等，雜湊地址和傳入的雜湊地址也相等，則將對應的節點引用賦值給e。
5. 如果根據雜湊地址計算出該key對應的table陣列索引有節點，且節點的雜湊地址和傳入的雜湊地址一樣，但是節點的鍵key和傳入的鍵key不相等，則遍歷連結串列，如果遍歷過程中找到節點的鍵key和傳入的鍵key相等，雜湊地址和傳入的雜湊地址也相等，則將對應的value值更新。否則呼叫newNode(hash, key, value, null)方法，為該鍵值對建立節點新增到連結串列尾部，如果追加節點後的連結串列長度 >= 8，則轉為紅黑樹
6. 如果e不為空，且onlyIfAbsent為true則不會覆蓋相同key和相同雜湊地址的value。

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

//如果引數onlyIfAbsent是true，那麼不會覆蓋相同key的值value。如果evict是false。那麼表示是在初始化時呼叫的
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    //tab存放 當前的雜湊桶， p用作臨時連結串列節點  
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //如果當前雜湊表是空的，代表是初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        //那麼直接去擴容雜湊表，並且將擴容後的雜湊桶長度賦值給n
        n = (tab = resize()).length;
    //如果當前index的節點是空的，表示沒有發生雜湊碰撞。 直接構建一個新節點Node，掛載在index處即可。
    //這裡再囉嗦一下，陣列下標index 是利用 雜湊地址 & 雜湊桶的長度-1，替代模運算
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {//否則 發生了雜湊衝突。
        //e
        Node<K,V> e; K k;
        //如果雜湊值相等，key也相等，則是覆蓋value操作
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;//將當前節點引用賦值給e
        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);
                    //如果追加節點後，連結串列數量》=8，則轉化為紅黑樹
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //如果找到了要覆蓋的節點
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //如果e不是null，說明有需要覆蓋的節點，
        if (e != null) { // existing mapping for key
            //則覆蓋節點值，並返回原oldValue
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            //這是一個空實現的函式，用作LinkedHashMap重寫使用。
            afterNodeAccess(e);
            return oldValue;
        }
    }
    //如果執行到了這裡，說明插入了一個新的節點，所以會修改modCount，以及返回null。

    //修改modCount
    ++modCount;
    //更新size，並判斷是否需要擴容。
    if (++size > threshold)
        resize();
    //這是一個空實現的函式，用作LinkedHashMap重寫使用。
    afterNodeInsertion(evict);
    return null;
}
複製程式碼

hashCode()是Object類的一個方法，hashCode()方法返回物件的hash code，這個方法是為了更好的支援hash表，比如Set、HashTable、HashMap等。hashCode()的作用：如果用equals去比較的話，如果存在1000個元素，你new一個新的元素出來，需要去呼叫1000次equals去逐個和它們比較是否是同一個物件，這樣會大大降低效率。ashcode實際上是返回物件的儲存地址，如果這個位置上沒有元素，就把元素直接儲存在上面，如果這個位置上已經存在元素，這個時候才去呼叫equal方法與新元素進行比較，相同的話就不存了，雜湊到其他地址上。

get方法

1. table不為空，且table的長度大於0，且根據鍵key的hashCode()計算出雜湊地址，再根據桶的數量-1和雜湊地址做&運算計算出陣列的下標，該下標下不為空(即存有連結串列頭指標)則繼續往下進行，否則返回null。
2. 如果和第一個節點的雜湊地址、鍵key都相同，則返回第一個節點。
3. 如果第一個節點的下個節點不為空，則繼續，如果第一個節點為樹的節點，則執行getTreeNode(hash, key)，在樹中尋找節點，並且返回。否則遍歷連結串列，找到鍵key、雜湊地址一樣的則返回此節點。

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // 如果索引到的第一個Node，key 和 hash值都和傳遞進來的引數相等，則返回該Node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) { //如果索引到的第一個Node 不符合要求，迴圈變數它的下一個節點。
            if (first instanceof TreeNode) // 在樹中get
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {// 在連結串列中get
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}
複製程式碼

remove方法

1. table不為空，且table的長度大於0，且根據鍵key的hashCode()計算出雜湊地址，再根據雜湊地址計算出陣列的下標，該下標下不為空(即存有連結串列頭指標)則繼續往下進行，否則執行6`。
2. 如果雜湊地址、鍵key一樣，則將對應的節點引用賦值給node，然後執行4。否則執行3。
3. 如果為樹，則執行getTreeNode(hash, key)在樹中尋找節點並且返回，否則遍歷連結串列，找到鍵key、雜湊地址一樣的節點然後將對應的節點引用賦值給node，然後執行4，否則執行6。
4. 如果節點node不為空(即查詢到鍵key對應的節點)，且當matchValue為false的時候或者value也相等的時候，則執行5，否則執行6。
5. 如果節點為樹，則呼叫removeTreeNode(this, tab, movable)移除相應的節點。否則在連結串列中移除相應的節點，
6. 返回null。

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    // p 是待刪除節點的前置節點
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    //如果雜湊表不為空，則根據hash值算出的index下 有節點的話。
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        //node是待刪除節點
        Node<K,V> node = null, e; K k; V v;
        //如果連結串列頭的就是需要刪除的節點
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;//將待刪除節點引用賦給node
        else if ((e = p.next) != null) {//否則迴圈遍歷 找到待刪除節點，賦值給node
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        //如果有待刪除節點node，  且 matchValue為false，或者值也相等
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)//如果node ==  p，說明是連結串列頭是待刪除節點
                tab[index] = node.next;
            else//否則待刪除節點在表中間
                p.next = node.next;
            ++modCount;//修改modCount
            --size;//修改size
            afterNodeRemoval(node);//LinkedHashMap回撥函式
            return node;
        }
    }
    return null;
}
複製程式碼

containsKey方法

如果存在指定的鍵key，返回true，否則返回false。
containsKey方法呼叫的get呼叫的方法一樣的方法，參考get方法的解析。

public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}
複製程式碼

雜湊表的初始化和加倍擴容resize方法

分析resize方法，我們就可以知道為什麼雜湊表的容量變化後，仍然能取到正確的值

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        //如果雜湊表是空的 則將舊容量置為0，否則置為舊雜湊表的容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //舊的雜湊表的閾值
        int oldThr = threshold;
        //新的雜湊表的容量和閾值 都置為0
        int newCap, newThr = 0;
        //如果舊的容量大於0 即不是第一次初始化 是擴容操作
        if (oldCap > 0) {
            //舊的容量是否大於2的30次冪方(容量的最大值)
            if (oldCap >= MAXIMUM_CAPACITY) {
                //閾值設定為Integer的最大值
                threshold = Integer.MAX_VALUE;
                //返回舊的雜湊表(舊的雜湊表已經到最大的容量了，不能繼續擴容 所以返回)
                return oldTab;
            }
            //新的雜湊表容量的=舊的容量<<1，即新的容量=舊的2倍，如果新的容量小於2的30次冪方(容量的最大值) 且 舊的容量大於等於預設的容量(16)
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                //新的雜湊表的閾值=舊的雜湊表的閾值<<1，既即新的閾值=舊的2倍 擴容table
                newThr = oldThr << 1; // double threshold
        }
        //第一次初始化，如果舊的閾值>0
        即HashMap是以傳入容量大小或者傳入容量大小、負載因子的建構函式進行初始化的，閾值thr
        eshlod已經在建構函式初始化過了，所以閾值在這裡大於0
        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);
        }
        //新的閾值=0，即執行的是上面的else if (oldThr >
        0)(使用帶引數的建構函式初始化)，是使用帶引數的建構函式進行的初始化，並且計算出新的
        閾值
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @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) {
                    oldTab[j] = null;
                    //如果節點沒有下個節點了(即只有一個節點)，則直接放到新的雜湊表中
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        //將舊的雜湊表的節點全部重新定位，比如舊的雜湊表容量是16，有一個
                        值a放在陣列下標為0上，現在新的雜湊表容量是32，重新定位後值a就被重
                        新定位到下標為32上，即新的雜湊表的下標為32儲存值a，簡單來說就是新
                        的下標=舊的雜湊表的下標+新的雜湊表的容量，正是因為這個節點的遷移，
                       所以我們在hashMapputget操作的時候，在雜湊表容量變化後仍讓取到正確
                       的值，但是也因為這個遷移操作，會消耗很多資源，所以儘量在建立HashMa
                       p的時候就估計雜湊表的容量，儘量不要讓他加倍擴容。這裡的遷移也都是
                       運用的位運算，所以在初始化的時候，桶的數量必須是2冪次方，才能保證
                       位運算和取模運算結果一樣。
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            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;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }
複製程式碼

我們可以執行個例子，除錯看看。

HashMap<String, Integer> map = new HashMap();
for (int i = 1; i <= 24; i ++) {
    map.put(String.valueOf(i), i);
}
for (int i = 25; i <= 80; i ++) {
    map.put(String.valueOf(i), i);
}
複製程式碼

我們以無參建構函式(即雜湊表容量預設是16，負載因子預設是0.75)new一個HashMap，然後除錯看看

執行第一個for迴圈，看到11儲存的下標為0，12儲存的下標是1
在繼續執行第二個for，發現下標為0的變成了44，下標為1的變成了45

那我們的11和12儲存在哪了？可以發現11和12到了下標為32、33上，即當執行第二個for的時候雜湊表發生了擴容，然後節點都遷移了，新的下標=舊的下標+新的雜湊表的容量

參考資料

Java HashMap工作原理及實現
Map 綜述（一）：徹頭徹尾理解 HashMap

原文地址：https://ddnd.cn/2019/03/07/jdk1.8-hashmap/