HashMap原理(二) 擴容機制及存取原理

咱們在上一個章節《HashMap原理(一) 概念和底層架構》中講解了HashMap的存儲數據結構以及經常使用的概念及變量，包括capacity容量，threshold變量和loadFactor變量等。本章主要講解HashMap的擴容機制及存取原理。

先回顧一下基本概念：

table變量：HashMap的底層數據結構，是Node類的實體數組，用於保存key-value對；

capacity：並非一個成員變量，但倒是一個必需要知道的概念，表示容量；

size變量：表示已存儲的HashMap的key-value對的數量；

loadFactor變量：裝載因子，用於衡量滿的程度；

threshold變量：臨界值，當超出該值時，表示table表示該擴容了；

一. put方法

HashMap使用哈希算法獲得數組中保存的位置，而後調用put方法將key-value對保存到table變量中。咱們經過圖來演示一下存儲的過程。

簡單解釋一下：

1）經過hash(Object key)算法獲得hash值；

2）判斷table是否爲null或者長度爲0，若是是執行resize()進行擴容；

3）經過hash值以及table數組長度獲得插入的數組索引i，判斷數組table[i]是否爲空或爲null；
4）若是table[i] == null，直接新建節點添加，轉向 8），若是table[i]不爲空，轉向 5）；
5）判斷table[i]的首個元素是否和key同樣，若是相同直接覆蓋value，這裏的相同指的是hashCode以及equals，不然轉向 6）；
6）判斷table[i] 是否爲treeNode，即table[i] 是不是紅黑樹，若是是紅黑樹，則直接在樹中插入鍵值對，不然轉7）；
7）遍歷table[i]，判斷鏈表長度是否大於8，大於8的話把鏈表轉換爲紅黑樹，在紅黑樹中執行插入操做，不然進行鏈表的插入操做；遍歷過程當中若發現key已經存在直接覆蓋value便可；
8）插入成功後，判斷實際存在的鍵值對數量size是否超多了最大容量threshold，若是超過，進行擴容。

咱們關注一下這裏面最重要的三個方法，hash()，putVal()，resize().

1. hash方法

咱們經過hash方法計算索引，獲得數組中保存的位置，看一下源碼

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

咱們能夠看到HashMap中的hash算法是經過key的hashcode值與其hashcode右移16位後獲得的值進行異或運算獲得的，那麼爲何不直接使用key.hashCode()，而要進行異或操做？咱們知道hash的目的是爲了獲得進行索引，而hash是有可能衝突的，也就是不一樣的key獲得了一樣的hash值，這樣就很容易產業碰撞，如何減小這種狀況的發生呢，就經過上述的hash(Object key)算法將hashcode 與 hashcode的低16位作異或運算，混合了高位和低位得出的最終hash值，衝突的機率就小多了。舉個例子：

有個蒸籠，第一層是豬肉包、牛肉包、雞肉包，第二層是白菜包，第三層是豆沙包，第四層是香菇包。這時你來買早餐，你指着第一層說除了豬肉包，隨便給我一個包子，由於外表沒法分辨，這時拿到豬肉包的機率就有1/3，若是將二層、三層、四層與一層混合在一塊兒了，那麼拿到豬肉包的機率就小多了。

咱們的hash(Object key)算法一個道理，最終的hash值混合了高位和低位的信息，摻雜的元素多了，那麼最終hash值的隨機性越大，而HashMap的table下標依賴於最終hash值與table.length()-1的&運算，這裏的&運算相似於挑包子的過程，天然衝突就小得多了。計算過程以下：

最開始的hashCode： 1111 1111 1111 1111 0100 1100 0000 1010

右移16位的hashCode：0000 0000 0000 0000 1111 1111 1111 1111

異或運算後的hash值： 1111 1111 1111 1111 1011 0011 1111 0101

2. putVal方法

經過putVal方法將傳遞的key-value對添加到數組table中。

/**
 * 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;
    /**
     * 若是當前HashMap的table數組還未定義或者還未初始化其長度，則先經過resize()進行擴容,
     * 返回擴容後的數組長度n
     */
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //經過數組長度與hash值作按位與&運算獲得對應數組下標，若該位置沒有元素，則new Node直接將新元素插入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    //不然該位置已經有元素了，咱們就須要進行一些其餘操做
    else {
        Node<K,V> e; K k;
        //若是插入的key和原來的key相同，則替換一下就完事了
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        /**
         * 不然key不一樣的狀況下，判斷當前Node是不是TreeNode,若是是則執行putTreeVal將新的元素插入
         * 到紅黑樹上。
         */
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        //若是不是TreeNode,則進行鏈表遍歷
        else {
            for (int binCount = 0; ; ++binCount) {
                /**
                 * 在鏈表最後一個節點以後並無找到相同的元素，則進行下面的操做，直接new Node插入，
                 * 但條件判斷有可能轉化爲紅黑樹
                 */
                if ((e = p.next) == null) {
                    //直接new了一個Node
                    p.next = newNode(hash, key, value, null);
                    /**
                     * TREEIFY_THRESHOLD=8,由於binCount從0開始，也便是鏈表長度超過8（包含）時，
                     * 轉爲紅黑樹。
                     */
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                /**
                 * 若是在鏈表的最後一個節點以前找到key值相同的（和上面的判斷不衝突，上面是直接經過數組
                 * 下標判斷key值是否相同），則替換
                 */
                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;
            //onlyIfAbsent爲true時:當某個位置已經存在元素時不去覆蓋
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //最後判斷臨界值，是否擴容。
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

3. resize方法

HashMap經過resize()方法進行擴容，容量規則爲2的冪次

/**
 * 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;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    //之前的容量大於0，也就是hashMap中已經有元素了，或者new對象的時候設置了初始容量
    if (oldCap > 0) {
        //若是之前的容量大於限制的最大容量1<<30,則設置臨界值爲int的最大值2^31-1
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        /**
         * 若是之前容量的2倍小於限制的最大容量，同時大於或等於默認的容量16，則設置臨界值爲之前臨界值的2
         * 倍，由於threshold = loadFactor*capacity，capacity擴大了2倍，loadFactor不變，
         * threshold天然也擴大2倍。
         */
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    /**
     * 在HashMap構造器Hash(int initialCapacity, float loadFactor)中有一句代碼，this.threshold      
     * = tableSizeFor(initialCapacity)， 表示在調用構造器時，默認是將初始容量暫時賦值給了
     * threshold臨界值，所以此處至關於將上一次的初始容量賦值給了新的容量。什麼狀況下會執行到這句？當調用     
     * 了HashMap(int initialCapacity)構造器，尚未添加元素時
     */
    else if (oldThr > 0) 
        newCap = oldThr;
    /**
     * 調用了默認構造器，初始容量沒有設置，所以使用默認容量DEFAULT_INITIAL_CAPACITY（16），臨界值
     * 就是16*0.75
     */
    else {               
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //對臨界值作判斷，確保其不爲0，由於在上面第二種狀況(oldThr > 0)，並無計算newThr
    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
    table = newTab;
    if (oldTab != null) {
        //遍歷將原來table中的數據放到擴容後的新表中來
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                //沒有鏈表Node節點，直接放到新的table中下標爲【e.hash & (newCap - 1)】位置便可
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                //若是是treeNode節點，則樹上的節點放到newTab中
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                //若是e後面還有鏈表節點，則遍歷e所在的鏈表，
                else { // 保證順序
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        //記錄下一個節點
                        next = e.next;
                        /**
                         * newTab的容量是之前舊錶容量的兩倍,由於數組table下標並非根據循環逐步遞增
                         * 的，而是經過（table.length-1）& hash計算獲得，所以擴容後，存放的位置就
                         * 可能發生變化，那麼到底發生怎樣的變化呢，就是由下面的算法獲得.
                         *
                         * 經過e.hash & oldCap來判斷節點位置經過再次hash算法後，是否會發生改變，如
                         * 果爲0表示不會發生改變，若是爲1表示會發生改變。到底怎麼理解呢，舉個例子：
                         * e.hash = 13 二進制：0000 1101
                         * oldCap = 32 二進制：0001 0000
                         *  &運算：  0  二進制：0000 0000
                         * 結論：元素位置在擴容後不會發生改變
                         */
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        /**
                         * e.hash = 18 二進制：0001 0010
                         * oldCap = 32 二進制：0001 0000
                         * &運算：  32 二進制：0001 0000
                         * 結論：元素位置在擴容後會發生改變，那麼如何改變呢？
                         * newCap = 64 二進制：0010 0000
                         * 經過(newCap-1)&hash
                         * 即0001 1111 & 0001 0010 得0001 0010，32+2 = 34
                         */
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        /**
                         * 若(e.hash & oldCap) == 0，下標不變，將原表某個下標的元素放到擴容表一樣
                         * 下標的位置上
                         */
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        /**
                         * 若(e.hash & oldCap) != 0，將原表某個下標的元素放到擴容表中
                         * [下標+增長的擴容量]的位置上
                         */
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

二. get方法

咱們先簡單說一下get(Object key)流程，經過傳入的key經過hash()算法獲得hash值，在經過(n - 1) & hash找到數組下標，若是數組下標所對應的node值正好key同樣就返回，不然找到node.next找到下一個節點，看是不是treenNode，若是是，遍歷紅黑樹找到對應node，若是不是遍歷鏈表找到node。咱們看一下源碼

public V get(Object key) {
    Node<K,V> e;
    //先經過hash(key)找到hash值，而後調用getNode(hash,key)找到節點
    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;
    //經過(n - 1) & hash找到數組對應位置上的第一個node
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        //若是這個node恰好key值相同，直接返回
        if (first.hash == hash && 
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        //若是不相同就再往下找
        if ((e = first.next) != null) {
            //若是是treeNode，就遍歷紅黑樹找到對應node
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            //若是是鏈表，遍歷鏈表找到對應node
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

這幾個方法是核心，雖然HashMap還有不少經常使用方法，不過大致和這幾個方法有關，或者實現邏輯類似，這裏就再也不多說了。

三. 總結

本文在上一章基本概念和底層結構的基礎上，從源碼的角度講解了擴容機制以及存取原理，主要分析了put方法和get方法，put方法的核心爲hash()，putVal()，resize()，get方法的核心爲getNode()，如有不對之處，請批評指正，望共同進步，謝謝！