Java HashMap原理及內部存儲結構

本文將經過以下簡單的代碼來分析HashMap的內部數據結構的變化過程。

public static void main(String[] args) {
    Map<String, String> map = new HashMap<>();
    for (int i = 0; i < 50; i++) {
        map.put("key" + i, "value" + i);
    }
}
複製代碼

1 數據結構說明

HashMap中本文須要用到的幾個字段以下：

下面說明一下幾個字段的含義

1）table

// HashMap內部使用這個數組存儲全部鍵值對
transient Node<K,V>[] table;
複製代碼

Node的結構以下：

能夠發現，Node實際上是一個鏈表，經過next指向下一個元素。

2）size

記錄了HashMap中鍵值對的數量

3）modCount

記錄了HashMap在結構上更改的次數，包括能夠更改鍵值對數量的操做，例如put、remove，還有能夠修改內部結構的操做，例如rehash。

4）threshold

記錄一個臨界值，當已存儲鍵值對的個數大於這個臨界值時，須要擴容。

5）loadFactor

負載因子，一般用於計算threshold，threshold=總容量*loadFactor。

2.new HashMap

new HashMap的源碼以下：

/** * The load factor used when none specified in constructor. * 負載因子，當 已使用容量 > 總容量 * 負載因子 時，須要擴容 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
複製代碼

此時，HashMap只初始化了負載因子（使用默認值0.75），並無初始化table數組。 其實HashMap使用的是延遲初始化策略，當第一次put的時候，才初始化table（此時table是null）。

3.table數組的初始化

當第一次put的時候，HashMap會判斷當前table是否爲空，若是是空，會調用resize方法進行初始化。 resize方法會初始化一個容量大小爲16 的數組，並賦值給table。 並計算threshold=16*0.75=12。 此時table數組的狀態以下：

4.put過程

map.put("key0", "value0");
複製代碼

首先計算key的hash值，hash("key0") = 3288451 計算此次put要存入數組位置的索引值：index=(數組大小 - 1) & hash = 3 判斷 if (table[index] == null) 就new一個Node放到這裏，此時爲null，因此直接new Node放到3上，此時table以下：

而後判斷當前已使用容量大小(size)是否已經超過臨界值threshold，此時size=1，小於12，不作任何操做，put方法結束（若是超過臨界值，須要resize擴容）。

繼續put。。。

map.put("key1", "value1");
複製代碼

map.put("key1", "value1");
map.put("key2", "value2");
map.put("key3", "value3");
map.put("key4", "value4");
map.put("key5", "value5");
map.put("key6", "value6");
map.put("key8", "value7");
map.put("key9", "value9");
map.put("key10", "value10");
map.put("key11", "value11");
複製代碼

此時size=12，下一次put後size爲13，大於當前threshold，將觸發擴容（resize）

map.put("key12", "value12");
複製代碼

計算Key的hash值，hash("key12")=101945043，計算要存入table位置的索引值 = (總大小 - 1) & hash = (16 - 1) & 101945043 = 3 從目前的table狀態可知，table[3] != null，但此時要put的key與table[3].key不相等，咱們必需要把他存進去，此時就產生了哈希衝突（哈希碰撞）。

這時鏈表就派上用場了，HashMap就是經過鏈表解決哈希衝突的。 HashMap會建立一個新的Node，並放到table[3]鏈表的最後面。 此時table狀態以下：

5.resize擴容

此時table中一共有13個元素，已經超過了threshold(12)，須要對table調用resize方法擴容。 HashMap會建立一個容量爲以前兩倍(162=32)的table，並將舊的Node複製到新的table中，新的臨界值(threshold)爲24(320.75)。

下面主要介紹一下複製的過程（並非原封不動的複製，Node的位置可能發生變化）

先來看源碼：

for (int j = 0; j < oldCap; ++j) { // oldCap：舊table的大小 =16
    Node<K,V> e;
    if ((e = oldTab[j]) != null) { // oldTab：舊table的備份
        oldTab[j] = null;
        // 若是數組中的元素沒有後繼節點，直接計算新的索引值，並將Node放到新數組中
        if (e.next == null)
            newTab[e.hash & (newCap - 1)] = e;
        // 忽略這個else if。其實，若是鏈表的長度超過8，HashMap會把這個鏈表變成一個樹結構，樹結構中的元素是TreeNode
        else if (e instanceof TreeNode)
            ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
        // 有後繼節點的狀況
        else { // preserve order
            Node<K,V> loHead = null, loTail = null;
            Node<K,V> hiHead = null, hiTail = null;
            Node<K,V> next;
            do {
                next = e.next;
                // 【說明1】
                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;
                //【說明2】
                newTab[j + oldCap] = hiHead;
            }
        }
    }
}
複製代碼

【說明1】遍歷鏈表，計算鏈表每個節點在新table中的位置。

計算位置的方式以下：

1）若是節點的 (hash & oldCap) == 0，那麼該節點還在原來的位置上，爲何呢？

由於oldCap=16，二進制的表現形式爲0001 0000，任何數&16，若是等於0，那麼這個數的第五個二進制位必然爲0。

以當前狀態來講，新的容量是32，那麼table的最大index是31，31的二進制表現形式是00011111。 計算index的方式是 hash & (容量 - 1)，也就是說，新index的計算方式爲 hash & (32 - 1) 假設Node的hash = 01101011，那麼

01101011
& 00011111
----------
  00001011 = 11
複製代碼

2）下面再對比(hash & oldCap) != 0的狀況

若是節點的(hash & oldCap) != 0，那麼該節點的位置=舊index + 舊容量大小

假設Node的hash = 01111011，那麼

01111011
& 00011111
----------
  00011011 = 27
複製代碼

上一個例子的hash值01101011跟這個例子的hash值01111011只是在第5位二進制上不一樣，能夠發現，這兩個值在舊的table中，是在同一個index中的，以下：

01101011
& 00001111
----------
  00001011 = 11
複製代碼

01111011
& 00001111
----------
  00001011 = 11
複製代碼

因爲擴容老是以2倍的方式進行，也就是：舊容量 << 1，這也就解釋了【說明2】，當(hash & oldCap) != 0時，這個Node的新index = 舊index + 舊容量大小。

擴容後，table狀態以下所示：

最終，從新分配完全部的Node後，擴容結束。

---

歡迎關注個人微信公衆號