目錄

• Java小白的原始碼學習系列：HashMap
  • 官方文件解讀
  • 基本資料結構
  • 基本原始碼解讀
    • 基本成員變數
    • 構造器
    • 巧妙的tableSizeFor
    • put方法
    • 巧妙的hash方法
  • JDK1.8的putVal方法
  • JDK1.8的resize方法
    • 初始化部分
    • 陣列搬移部分

Java小白的原始碼學習系列：HashMap

春節拜年取消，在家花了好多天時間啃一啃HashMap的原始碼，同樣是找了很多很多的資料，有JDK1.7的，也有JDK1.8的，當然本文基於JDK1.8。將所學到的東西進行整理，希望回過頭再看的時候，有更深刻的見解。

官方文件解讀

先來看看史詩級長屏之官方介紹

基本資料結構

實際上，在JDK1.8中，HashMap底層是依據陣列+單鏈表+紅黑樹的結構儲存資料的。具體是怎麼樣的呢？

HashMap實現了Map介面，維護的是一組組鍵值對，以便於我們根據鍵就能立刻獲取其對應值。另外，HashMap用了特殊的手法，優化了它的效能，我們本篇來具體學習並總結一下。

• 我們知道，陣列的結構利於查詢，HashMap依據雜湊函式，將元素以某種方式對映到陣列的某個位置上，就可以依據陣列結構查詢快的特點迅速鎖定目標。

• 但是，雜湊函式並不是萬能的，兩個不同的元素完全有可能算出相同的雜湊值，這個時候就產生了雜湊碰撞。

• HashMap是如何解決的呢？上面已經提到，採用的是鏈地址法，就是將每個元素看成單鏈表中的節點，都有指向下一個節點的指標。這是一個不錯的辦法，能夠減少重雜湊的概率。

• 但，又有一個問題，要是真的出現了極端的情況：有大量的元素通過雜湊函式求得的值聚集在同一個連結串列上，這時想要找到這個元素，需要花費大量的時間。JDK1.8中，運用了紅黑樹結構，連結串列中的節點數>TREEIFY_THRESHOLD時，連結串列結構將會轉化為樹形結構，將查詢元素的時間複雜度從O(n)降為O(logn)，大大提高了效率。

基本原始碼解讀

基本成員變數

再看看HashMap中定義的一些常量：

    //序列號
    private static final long serialVersionUID = 362498820763181265L;
    //預設的初始容量為16（必須為2的冪）
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    //允許的最大容量2的30次冪
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //沒有指定負載因子時，預設為0.75f
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //連結串列轉化為紅黑樹的閾值
    static final int TREEIFY_THRESHOLD = 8;
    //紅黑樹退化為連結串列的閾值
    static final int UNTREEIFY_THRESHOLD = 6;
    //陣列的容量大於64時，桶才有可能轉化為樹形結構
    static final int MIN_TREEIFY_CAPACITY = 64;

還有一些成員變數：

    //儲存的元素的陣列，陣列容量一定時2的冪次
    transient Node<K,V>[] table;    
    //存放具體元素的集
    transient Set<Map.Entry<K,V>> entrySet;
    //存放元素的個數
    transient int size;
    //每次更改結構的計數器
    transient int modCount;
    //閾值，還沒有分配陣列時，閾值為預設容量或指定容量，之後該值等於容量*負載因子
    int threshold;
    //負載因子
    final float loadFactor;

構造器

我們根據原始碼，來看看在JDK1.8中，這些到底是如何實現的，以及為什麼要這樣考慮。
還是先看看其中三個構造器（暫時先忽略最後一個）：

    //無參構造器
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
    //指定容量的構造器
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    //兩參構造器
    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(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

這就是HashMap中提供的四個構造器，我們從中可以察覺出一些端倪。

• 如果沒有指定負載因子，預設為0.75，且指定的負載因子需要大於0。
• 初始容量並沒有在構造器中直接指定，我們暫時保留疑惑。
• 通過兩個引數的構造器，我們發現通過tableSizeFor對我們傳入的初始容量進行計算，併為閾值賦值。

巧妙的tableSizeFor

說到這，我們來看看這個巧妙的tableSizeFor，我們通過註解可以知道，這個方法返回的是大於等於傳入值的最小2的冪次方（傳入1時，為1）。它到底是怎麼實現的呢，我們來看看具體的原始碼：

    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;
    }

說實話，我再看到這個方法具體實現之後，感嘆了一句，數學好牛！我通過代入具體數字，翻閱了許多關於這部分的文章與視訊，通過簡單的例子，來做一下總結。

• 我們先試想一下，我們想得到比n大的最小2次冪只需要在最高位的前一位置1，後面全置0就ok了吧。如0101代表的是5，1000就符合我們的需求為8。

• 我們再傳入更大的數，為了寫著方便，這裡就以8位為例：
  

• 第一步int n = cap -1這一步其實是為了防止cap本身為2的冪次的情況，如果沒有這一步的話，在一頓操作之後，會出現翻倍的情況。比如傳入為8，算出來會是16，所以事先減去1，保證結果。
• 最後n<0的情況的判定，排除了傳入容量為0的情況。

• n>=MAXIMUM_CAPACITY的情況的判定，排除了移位和或運算之後全部為1的情況。

講到這裡，我知道了為什麼陣列的容量總是2的冪次數了：是因為運算規定,但是這基本不算是原因，選擇2的冪次方數一定有出於便利的方面的原因，這部分我們待會再說。

我們在分析成員變數的時候說過，threshold是用來表示一個閾值，表示陣列容量和負載因子的乘積。但是我們發現，還沒分配陣列的時候，其實是我們不小於指定容量的二次冪。

那麼，陣列什麼時候才進行初始化呢？腦瓜子轉一下，應該就知道，是往裡面存元素的時候。我們來看一看HashMap裡面儲存元素的方法。

put方法

    //聯絡指定的鍵Key和值Value，如果在這之前map包含相同的key，返回舊key對應的value
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

巧妙的hash方法

其中呼叫了hash方法，對傳入的鍵key進行雜湊計算，具體計算細節如下：

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

我們著重瞭解一下，key不為null的情況下hash函式的實現，具體為啥要這樣設計，我們之後再總結：

• h儲存的是傳入key的雜湊值，這個方法繼承於Object類，產生一個int值。
• 將上面這個老雜湊值和無符號右移16位（將原高16位向低位移動，原高位全部以0填充）之後的新雜湊值進行亦或運算，相同為0，不同為1。

有效地將高低位二進位制特徵混合，防止由高位的細微區別產生的頻繁雜湊碰撞，具體可以看一下文末的參考連結。

JDK1.8的putVal方法

下面是一個及其關鍵的方法putVal。

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //如果陣列未初始化或者長度為0，則呼叫resize()初始化陣列
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //根據hash值計算陣列中的桶位，如果為null，則在該桶位上新建節點
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //hash值相同，落入同一個桶中，且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 {
                //在節點後面插入新節點，桶中連結串列最多有8個節點，再加就變成了樹
                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;
                    }
                    //判斷後面節點是否存在key相同的情況
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    //e=p.next;p=e;這兩步完成遍歷
                    p = e;
                }
            }
            //如果存在相同key值相同，新值替換舊值
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //容量大於閾值，resize();
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

在沒了解resize方法之前，我們暫且將他定義成擴容和重雜湊的重要方法，我們先就putVal方法進行一些總結：

• 我們看到，在沒有新增鍵值對的時候，陣列並沒有初始化；在呼叫put方法之後，putVal中將會呼叫resize()真正對陣列進行初始化，至於如何實現，我們待會分析resize。
• 我們還說過，HashMap主要利用了雜湊函式對傳入的key值進行雜湊運算，然後利用特殊的方法將求得的雜湊值正確放入陣列中的每個桶中。這個特殊的方法即:p = tab[i = (n - 1) & hash]，n為陣列的長度，它是2的冪次方，我們很容易能夠明白，通過(n-1)&hash產生的索引值必然落在0~n-1的範圍內，相當於i=hash%n,但是位運算的效率更高。這就是容量設定為2的冪次方數的另外原因。
• (k = p.key) == key || (key != null && key.equals(k))),這一步兩邊分別表示key是否為null的情況。
• 我們知道，TREEIFY_THRESHOLD為8，是連結串列結構轉換為樹形結構的闕值，通過原始碼我們可以知道，連結串列結構最多隻能儲存8個節點，如果要存第9個，就需要呼叫treeifyBin(tab, hash);，轉換為樹。
• 通過遍歷的結構，我們可以發現，JDK1.8中，新增的操作會在連結串列的尾部執行。
• 遍歷之後，節點e不為null，說明確實找到了key相同的節點，這時替換value值，返回舊值。
• ++size > threshold),從這部分我們可以看出，除了初始化的時候是先resize再插入，其他的時候都是先插入，再判斷是否需要擴容。

JDK1.8的resize方法

那麼接下來，終於輪到resize方法了，我們先看一下程式碼的實現部分，哇這部分可是花了我好多的功夫，如果還有理解不正確的地方，還希望評論區批評指正：

    final Node<K,V>[] resize() {
        //oldTab儲存的是擴容前的陣列
        Node<K,V>[] oldTab = table;
        //oldCap儲存的是擴容前的陣列容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //oldThr儲存的是擴容前的閾值
        int oldThr = threshold;
        //newCap新陣列容量，newThr新陣列閾值
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                //如果老陣列容量比陣列最大容量還大，閾值變為Integer的最大值，返回老陣列
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //新陣列容量變為老陣列容量的兩倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                //新閾值變為兩倍需要上面的條件都成立（1、擴容兩倍之後的陣列容量小於最大容量2、老容量大於等於16）
                newThr = oldThr << 1; // double threshold
        }
        
        else if (oldThr > 0) // initial capacity was placed in threshold
            //使用帶有初始容量構造器，讓新容量變為通過initial capacity求得的threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            //使用預設構造器，初始化容量為16
            newCap = DEFAULT_INITIAL_CAPACITY;
            //新容量變為16，新閾值變為0.75*16 = 12
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //使用帶有初始容量的構造器進行擴容
        if (newThr == 0) {
            //新閾值 = 新容量 * 指定的負載因子
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        //將newThr賦值給threshold表示閾值
        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) {
                //建立臨時節點儲存老陣列oldTab上的元素
                Node<K,V> e;
                //如果老陣列上索引j的位置不為null
                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
                        
                        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迴圈保證從到到尾遍歷連結串列
                        } while ((e = next) != null);
                        //如果尾節點不為空，就讓它的next指向空，連結串列完整
                        if (loTail != null) {
                            loTail.next = null;
                            //新陣列的原索引位置指向連結串列頭節點
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            //新陣列的原索引加老陣列容量的索引位置指向連結串列頭節點
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

初始化部分

我們先談一談陣列的初始化部分：

• 結合之前的putVal方法，我們知道當我們通過預設構造器建立HashMap，初始化為空的陣列，threshold = 0。當第一次新增元素時進行擴容，此時陣列容量為16，threshold為12。
• 當我們指定指定initialCapacity的時候，threshold一開始表示的是大於等於initialCapacity最小的2的冪次方數，直到第一次新增元素時進行擴容，陣列容量為threshold的值，而threshold此時為指定負載因子與陣列容量的乘積。
• 若陣列已經初始化，即陣列容量>0時，再擴容，新容量變為原容量的兩倍，如果新容量小於最大容量，並且老容量>=16,此時threshold也變為原來的兩倍，否則threshold不變。
• 如果老陣列的容量比最大容量還要大的話，閾值變為Integer的最大值，原陣列不變。

陣列搬移部分

我們重點談一談陣列的搬移的基礎部分：

• 可以看到，通過for迴圈，通過j的改變，遍歷陣列中的每個桶的位置。
• 如果桶位上只有一個節點，搬移操作很簡單：newTab[e.hash & (newCap - 1)] = e;。
• 如果桶位上為樹形節點，就按樹形操作來：((TreeNode<K,V>)e).split(this, newTab, j, oldCap);。

最難的是，發生雜湊碰撞時，陣列的搬移是如何實現的呢？我們可以發現，原始碼中對e.hash & oldCap的值是0還是1進行了分類判斷，為啥要這樣做呢？

• 我們知道，獲取陣列中的桶的位置，可以通過陣列容量-1&hash求得。
• 也就是說假如舊容量為16時，雜湊值10和26和15進行與運算之後，都會保留二進位制後四位的數，也就是都為10,其實這就是雜湊碰撞產生的原因嘛。

我們首先必須明確，同樣的雜湊值，擴容前後的區別只是在於被擷取的那一位，就拿26而言（0001 1010），以16為容量時，它的有效索引位置為1010，而以32為容量時，它的有效索引則是11010，剛好差了10000，即oldCap，如下圖：

• e.hash&oldCap為0，節點在新陣列中的索引不變，newTab[j]。
• e.hash&oldCap為1，節點在新陣列中的索引值 = 老陣列容量+原索引值，newTab[j + oldCap]。

瞭解完這個，我們對其中雜湊碰撞時節點搬移的程式碼的分析開始！
關於其中針對e.hash & oldCap不同而定義的一對作用相同的節點，我們暫且將他們單獨拎出來，研究loHead和loTail，另外一對其實同理即可。

• 我們知道，單鏈表的組成由儲存的值和指向下一節點的指標next組成。
• 通過do……while迴圈從連結串列的頭節點向後，一直向尾節點進行遍歷，直到其為空。
• 建立臨時節點e指向老連結串列的頭節點，擁有相同的地址，其實就是擁有了與老連結串列相同的結構。
• 其實連結串列的遍歷的操作我們之前的文章已經分析過，這邊是通過下面的語句完成的。

//do……while迴圈
do{
    next = e.next;
}while((e = next)!=null);

• 第一次進入迴圈時，loHead和loTail同時指向e，我在圖中用灰色表示loHead，用白色表示loTail。
• 後面每次進入迴圈，都會利用loTail節點向後移動，並將老連結串列的節點賦給新連結串列，一直串在頭節點之後。
• 直到遍歷至老連結串列的最後一個節點，退出迴圈。
• 如果新連結串列的尾節點不為null，將它的next指向null，此時一個完整的新連結串列就已經誕生。loTail.next = null;
• 將原陣列的索引位置指向這個新連結串列的頭節點。newTab[j] = loHead;
  

最後的最後，本文還有許多方面需要完善或者修改，之後會陸續將新體會上傳，還望評論區批評指正。

參考：

HashMap中的hash演算法中的幾個疑問
HashMap中的hash函式
jdk1.8 HashMap工作原理和擴容機制(原始碼解析)
Java 1.8中HashMap的resize()方法擴容部分的理解