HashMap原理

風光小磊發表於2022-01-14
HashMap

1. HashMap 的底層結構

  • Java7 : 陣列 + 連結串列
  • Java8: 陣列 + 連結串列 + 紅黑樹 (連結串列超過8則轉為紅黑樹，小於6則變會連結串列) >> 加快查詢.

2.HashMap引數

原始碼如下：

 

 

 引數解釋：

　　DEFAULT_INITIAL_CAPACITY : 預設初始容量（16）， 必須是2的冪。（ 1 >> 4 也就是轉化為 2進位制後 0000 0001 左移4位 也就是 0001 0000， 也就是16）
　　DEFAULT_LOAD_FACTOR： 預設負載因子0.75，（超過 容量與負載因子的乘積會擴容）
　　TREEIFY_THRESHOLD : 大小為8及以上時連結串列會轉化為紅黑樹 的閾值。
　　UNTREEIFY_THRESHOLD ： 大小為6及以下會轉化為 連結串列 的閥值。


Hashmap中的連結串列大小超過八個時會自動轉化為紅黑樹，當刪除小於六時重新變為連結串列，為啥呢？

　　根據泊松分佈，在負載因子預設為0.75的時候，單個hash槽內元素個數為8的概率小於百萬分之一，所以將7作為一個分水嶺，等於7的時候不轉換，大於等於8的時候才進行轉換為紅黑樹，小於等於6的時候就化為連結串列。

3. put()的實現

　　put函式大致的思路為：

　　1）對key的hashCode()做hash，然後再計算index;
　　2）如果沒碰撞直接放到 tab[i]裡；
　　3）如果碰撞了，以連結串列的形式儲存， （結合第一章節的圖， 化學與數學的hash衝撞後， 轉為連結串列存在數學的下一個節點處。）；
　　4）如果碰撞導致連結串列過長(大於等於TREEIFY_THRESHOLD)，就把連結串列轉換成紅黑樹；
　　5）如果節點已經存在就替換old value(保證key的唯一性)
　　6）當容量將超過 負載因子與初始容量的乘積 （load factor*current capacity)，就要resize。

程式碼實現如下：

HashMap原理 
public V put(K key, V value) {
    // 對key的hashCode()做hash
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // tab為空則建立
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 計算index，並對null做處理,
    if ((p = tab[i = (n - 1) & hash]) == null)
        //直接構造一個Node 存進 tab 以 hash運算後的為下標 裡。
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 節點存在
        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);
                    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;
            }
        }
        // 寫入
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 超過load factor*current capacity，resize
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}
put()實現

4. get()函式實現

在理解了put之後，get就很簡單了。大致思路如下：
　　整個HashMap 稱之為bucket （桶）

　　bucket裡的第一個節點，直接命中；
　　如果有衝突，則通過key.equals(k)去查詢對應的entry
　　若為樹，則在樹中通過key.equals(k)查詢，O(logn)；
　　若為連結串列，則在連結串列中通過key.equals(k)查詢，O(n)。
具體程式碼的實現如下：

HashMap原理 
 1 public V get(Object key) {
 2     Node<K,V> e;
 3     return (e = getNode(hash(key), key)) == null ? null : e.value;
 4 }
 5 
 6 final Node<K,V> getNode(int hash, Object key) {
 7     Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
 8     if ((tab = table) != null && (n = tab.length) > 0 &&
 9         (first = tab[(n - 1) & hash]) != null) {
10         // 直接命中
11         if (first.hash == hash && // always check first node
12             ((k = first.key) == key || (key != null && key.equals(k))))
13             return first;
14         // 未命中
15         if ((e = first.next) != null) {
16             // 在樹中 getTreeNode() 不做深究
17             if (first instanceof TreeNode)
18                 return ((TreeNode<K,V>)first).getTreeNode(hash, key);
19             // 在連結串列中 通過.next() 迴圈獲取，知道找到滿足條件的key為止
20             do {
21                 if (e.hash == hash &&
22                     ((k = e.key) == key || (key != null && key.equals(k))))
23                     return e;
24             } while ((e = e.next) != null);
25         }
26     }
27     return null;
28 }
get()程式碼實現

5. hash() 的實現

在對hashCode()計算hash時具體實現是這樣的：

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

在get和put的過程中，計算下標時，先對hashCode進行hash操作，然後再通過hash值進一步計算下標，如下圖所示：

 6.RESIZE的實現

當put時，如果發現目前的bucket佔用程度已經超過了Load Factor所希望的比例，那麼就會發生resize。在resize的過程，簡單的說就是把bucket擴充為2倍，之後重新計算index，把節點再放到新的bucket中。resize的註釋是這樣描述的：

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.

大致意思就是說，當超過限制的時候會resize，然而又因為我們使用的是2次冪的擴充套件(指長度擴為原來2倍)，所以，元素的位置要麼是在原位置，要麼是在原位置再移動2次冪的位置。

7.總結

我們現在可以回答開始的幾個問題，加深對HashMap的理解：

1） 什麼時候會使用HashMap？他有什麼特點？
是基於Map介面的實現，儲存鍵值對時，它可以接收null的鍵值，是非同步的，HashMap儲存著Entry(hash, key, value, next)物件。

2） 你知道HashMap的工作原理嗎？
通過hash的方法，通過put和get儲存和獲取物件。儲存物件時，我們將K/V傳給put方法時，它呼叫hashCode計算hash從而得到bucket位置，進一步儲存，HashMap會根據當前bucket的佔用情況自動調整容量(超過Load Facotr則resize為原來的2倍)。獲取物件時，我們將K傳給get，它呼叫hashCode計算hash從而得到bucket位置，並進一步呼叫equals()方法確定鍵值對。如果發生碰撞的時候，Hashmap通過連結串列將產生碰撞衝突的元素組織起來，在Java 8中，如果一個bucket中碰撞衝突的元素超過某個限制(預設是8)，則使用紅黑樹來替換連結串列，從而提高速度。

3） 你知道get和put的原理嗎？equals()和hashCode()的都有什麼作用？
通過對key的hashCode()進行hashing，並計算下標( n-1 & hash)，從而獲得buckets的位置。如果產生碰撞，則利用key.equals()方法去連結串列或樹中去查詢對應的節點

4） 你知道hash的實現嗎？為什麼要這樣實現？
在Java 1.8的實現中，是通過hashCode()的高16位異或低16位實現的：(h = k.hashCode()) ^ (h >>> 16)，主要是從速度、功效、質量來考慮的，這麼做可以在bucket的n比較小的時候，也能保證考慮到高低bit都參與到hash的計算中，同時不會有太大的開銷。

5） 如果HashMap的大小超過了負載因子(load factor)定義的容量，怎麼辦？
如果超過了負載因子(預設0.75)，則會重新resize一個原來長度兩倍的HashMap，並且重新呼叫hash方法。

關於Java集合的小抄中是這樣描述的：

 

 

 

 

以上部分參考：https://blog.csdn.net/weixin_41272626/article/details/107629037

 

相關文章