看完你要是還搞不懂HashMap，我直接倒立喝水

前言

HashMap是基於哈希表的Map接口的非同步實現。此實現提供全部可選的映射操做，並容許使用null值和null鍵。此類不保證映射的順序，特別是它不保證該順序恆久不變。

HashMap的數據結構

在Java編程語言中，最基本的結構就是兩種，一個是數組，另一個是模擬指針（引用），全部的數據結構均可以用這兩個基本結構來構造的，HashMap也不例外。HashMap其實是一個「鏈表散列」的數據結構，即數組和鏈表的結合體。

文字描述永遠要配上圖才能更好的講解數據結構，HashMap的結構圖以下。

從上圖中能夠看出，HashMap底層就是一個數組結構，數組中的每一項又是一個鏈表或者紅黑樹。當新建一個HashMap的時候，就會初始化一個數組。

下面先經過大概看下HashMap的核心成員。

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

    // 默認容量，默認爲16，必須是2的冪
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

    // 最大容量，值是2^30
    static final int MAXIMUM_CAPACITY = 1 << 30

    // 裝載因子，默認的裝載因子是0.75
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    // 解決衝突的數據結構由鏈表轉換成樹的閾值，默認爲8
    static final int TREEIFY_THRESHOLD = 8;

    // 解決衝突的數據結構由樹轉換成鏈表的閾值，默認爲6
    static final int UNTREEIFY_THRESHOLD = 6;

    /* 當桶中的bin被樹化時最小的hash表容量。
     *  若是沒有達到這個閾值，即hash表容量小於MIN_TREEIFY_CAPACITY，當桶中bin的數量太多時會執行resize擴容操做。
     *  這個MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

    static class Node<K,V> implements Map.Entry<K,V> {
        //...
    }
    // 存儲數據的數組
    transient Node<K,V>[] table;

    // 遍歷的容器
    transient Set<Map.Entry<K,V>> entrySet;

    // Map中KEY-VALUE的數量
    transient int size;

    /**
     * 結構性變動的次數。
     * 結構性變動是指map的元素數量的變化，好比rehash操做。
     * 用於HashMap快速失敗操做，好比在遍歷時發生告終構性變動，就會拋出ConcurrentModificationException。
     */
    transient int modCount;

    // 下次resize的操做的size值。
    int threshold;

    // 負載因子，resize後容量的大小會增長現有size * loadFactor
    final float loadFactor;
}

HashMap的初始化

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // 其餘值都是默認值
    }

整理了一下2021年的 Java工程師經典面試真題，共485頁大概850道含答案的面試題PDF，包含了Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、Redis、MySQL、Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、Linux 等幾乎全部技術棧，每一個技術棧都有很多於50道經典面試真題，不敢說刷完包你進大廠，但有針對性的刷讓你面對面試官的時候多幾分底氣仍是沒問題的。

經過源碼能夠看出初始化時並無初始化數組table，那隻能在put操做時放入了，爲何要這樣作？估計是避免初始化了HashMap以後不使用反而佔用內存吧，哈哈哈。

HashMap的存儲操做

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

下面咱們詳細講一下HashMap是如何肯定數組索引的位置、進行put操做的詳細過程以及擴容機制(resize)

hash計算，肯定數組索引位置

無論增長、刪除、查找鍵值對，定位到哈希桶數組的位置都是很關鍵的第一步。前面說過HashMap的數據結構是數組和鏈表的結合，因此咱們固然但願這個HashMap裏面的元素位置儘可能分佈均勻些，儘可能使得每一個位置上的元素數量只有一個，那麼當咱們用hash算法求得這個位置的時候，立刻就能夠知道對應位置的元素就是咱們要的，不用遍歷鏈表，大大優化了查詢的效率。HashMap定位數組索引位置，直接決定了hash方法的離散性能。

看下源碼的實現:

static final int hash(Object key) {   //jdk1.8
     int h;
     // h = key.hashCode() 爲第一步 取hashCode值
     // h ^ (h >>> 16)  爲第二步 高位參與運算
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

經過hashCode()的高16位異或低16位實現的：(h = k.hashCode()) ^ (h >>> 16)，主要是從速度、功效、質量來考慮的，這麼作能夠在數組table的length比較小的時候，也能保證考慮到高低Bit都參與到Hash的計算中，同時不會有太大的開銷。

你們都知道上面代碼里的key.hashCode()函數調用的是key鍵值類型自帶的哈希函數，返回int型散列值。理論上散列值是一個int型，若是直接拿散列值做爲下標訪問HashMap主數組的話，考慮到2進制32位帶符號的int表值範圍從‑2147483648到2147483648。先後加起來大概40億的映射空間。只要哈希函數映射得比較均勻鬆散，通常應用是很難出現碰撞的。但問題是一個40億長度的數組，內存是放不下的。你想，HashMap擴容以前的數組初始大小才16。因此這個散列值是不能直接拿來用的。用以前還要先作對數組的長度取模運算，獲得的餘數才能用來訪問數組下標。源碼中模運算是在這個indexFor( )函數里完成。

bucketIndex = indexFor(hash, table.length);
//indexFor的代碼也很簡單，就是把散列值和數組長度作一個"與"操做，
static int indexFor(int h, int length) {
   return h & (length-1);
}

順便說一下，這也正好解釋了爲什麼HashMap的數組長度要取2的整次冪。由於這樣（數組長度‑1）正好至關於一個「低位掩碼」。「與」操做的結果就是散列值的高位所有歸零，只保留低位值，用來作數組下標訪問。以初始長度16爲例，16‑1=15。2進製表示是000000000000000000001111。和某散列值作「與」操做以下，結果就是截取了最低的四位值。

10100101 11000100 00100101
& 00000000 00000000 00001111
----------------------------------
  00000000 00000000 00000101 //高位所有歸零，只保留末四位

但這時候問題就來了，這樣就算個人散列值分佈再鬆散，要是隻取最後幾位的話，碰撞也會很嚴重。更要命的是若是散列自己作得不好，分佈上成等差數列的漏洞，剛好使最後幾個低位呈現規律性重複，就無比蛋疼。這時候「擾動函數」的價值就出來了，說到這你們應該都明白了，看下圖。

hash計算過程

右位移16位，正好是32bit的一半，本身的高半區和低半區作異或，就是爲了混合原始哈希碼的高位和低位，以此來加大低位的隨機性。並且混合後的低位摻雜了高位的部分特徵，這樣高位的信息也被變相保留下來。

putVal方法

HashMap的put方法執行過程能夠經過下圖來理解，本身有興趣能夠去對比源碼更清楚地研究學習。

源碼以及解釋以下:

// 真正的put操做
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // 若是table沒有初始化，或者初始化的大小爲0，進行resize操做
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 若是hash值對應的桶內沒有數據，直接生成結點而且把結點放入桶中
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 若是hash值對應的桶內有數據解決衝突，再放入桶中
        else {
            Node<K,V> e; K k;
            //判斷put的元素和已經存在的元素是相同(hash一致，而且equals返回true)
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // put的元素和已經存在的元素是不相同(hash一致，而且equals返回true)
            // 若是桶內元素的類型是TreeNode，也就是解決hash解決衝突用的樹型結構，把元素放入樹種
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                // 桶內元素的類型不是TreeNode，而是鏈表時，把數據放入鏈表的最後一個元素上
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 若是鏈表的長度大於轉換爲樹的閾值(TREEIFY_THRESHOLD)，將存儲元素的數據結構變動爲樹
                        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;
                    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;
        // 若是K-V數量大於閾值，進行resize操做
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

擴容機制

HashMap的擴容機制用的很巧妙，以最小的性能來完成擴容。擴容後的容量就變成了變成了以前容量的2倍，初始容量爲16，因此通過rehash以後，元素的位置要麼是在原位置，要麼是在原位置再向高下標移動上次容量次數的位置，也就是說若是上次容量是16，下次擴容後容量變成了16+16，若是一個元素在下標爲7的位置，下次擴容時，要不還在7的位置，要不在7+16的位置。

咱們下面來解釋一下Java8的擴容機制是怎麼作到的？n爲table的長度，圖（a）表示擴容前的key1和key2兩種key肯定索引位置的示例，圖（b）表示擴容後key1和key2兩種key肯定索引位置的示例，其中hash1是key1對應的哈希與高位運算結果。

元素在從新計算hash以後，由於n變爲2倍，那麼n-1的mask範圍在高位多1bit(紅色)，所以新的index就會發生這樣的變化：

所以，咱們在擴充HashMap的時候，不須要像JDK1.7的實現那樣從新計算hash，只須要看看原來的hash值新增的那個bit是1仍是0就行了，是0的話索引沒變，是1的話索引變成「原索引+oldCap」，能夠看看下圖爲16擴充爲32的resize示意圖：

而hash值的高位是否爲1，只須要和擴容後的長度作與操做就能夠了，由於擴容後的長度爲2的次冪，因此高位必爲1，低位必爲0，如10000這種形式，源碼中有e.hash & oldCap來作到這個邏輯。

這個設計確實很是的巧妙，既省去了從新計算hash值的時間，並且同時，因爲新增的1bit是0仍是1能夠認爲是隨機的，所以resize的過程，均勻的把以前的衝突的節點分散到新的bucket了。這一塊就是JDK1.8新增的優化點。有一點注意區別，JDK1.7中rehash的時候，舊鏈表遷移新鏈表的時候，若是在新表的數組索引位置相同，則鏈表元素會倒置，可是從上圖能夠看出，JDK1.8不會倒置。下面是JDK1.8的resize源碼，寫的很贊，以下:

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 計算新的容量值和下一次要擴展的容量
        if (oldCap > 0) {
        // 超過最大值就再也不擴充了，就只好隨你碰撞去吧
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 沒超過最大值，就擴充爲原來的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        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);
        }
        // 計算新的resize上限
        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) {
            // 把每一個bucket都移動到新的buckets中
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                //若是位置上沒有元素，直接爲null
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //若是隻有一個元素，新的hash計算後放入新的數組中
                    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;
                            //hash碰撞後高位爲0，放入低Hash值的鏈表中
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            //hash碰撞後高位爲1，放入高Hash值的鏈表中
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 低hash值的鏈表放入數組的原始位置
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        // 高hash值的鏈表放入數組的原始位置 + 原始容量
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }