HashMap源碼我的解讀

時間 2021-04-02

標籤 java node 算法數組 app less 函數 this spa .net 欄目 Java 简体版

原文原文鏈接

HashMap的源碼比較複雜，最近也是結合視頻以及其他大佬的博客，想着記錄一下本身的理解或者看成筆記java

JDK1.8後，HashMap底層是數組+鏈表+紅黑樹。在這以前都是數組+鏈表，而改變的緣由也就是若是鏈表過長，查詢的效率就會下降，所以引入了紅黑樹。node

這裏的鏈表是一個單向鏈表算法

 static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

接下來是類的屬性數組

 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16默認的初始容量是16

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量

    /**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;//負載因子

    /**
     * The bin count threshold for using a tree rather than list for a
     * bin.  Bins are converted to trees when adding an element to a
     * bin with at least this many nodes. The value must be greater
     * than 2 and should be at least 8 to mesh with assumptions in
     * tree removal about conversion back to plain bins upon
     * shrinkage.
     */
    static final int TREEIFY_THRESHOLD = 8;//樹化閾值

    /**
     * The bin count threshold for untreeifying a (split) bin during a
     * resize operation. Should be less than TREEIFY_THRESHOLD, and at
     * most 6 to mesh with shrinkage detection under removal.
     */
    static final int UNTREEIFY_THRESHOLD = 6;//樹降級成爲鏈表的閾值

    /**
     * The smallest table capacity for which bins may be treeified.
     * (Otherwise the table is resized if too many nodes in a bin.)
     * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
     * between resizing and treeification thresholds.
     */
    static final int MIN_TREEIFY_CAPACITY = 64;//桶中的結構轉化爲紅黑樹對應的table，也就是桶的最小數量。

transient Node<K,V>[] table;//存放元素的數組，老是2的冪次方

    /**
     * Holds cached entrySet(). Note that AbstractMap fields are used
     * for keySet() and values().
     */
    transient Set<Map.Entry<K,V>> entrySet;存放具體元素的集

    /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;存放元素的個數，不是數組的長度

    /**
     * The number of times this HashMap has been structurally modified
     * Structural modifications are those that change the number of mappings in
     * the HashMap or otherwise modify its internal structure (e.g.,
     * rehash).  This field is used to make iterators on Collection-views of
     * the HashMap fail-fast.  (See ConcurrentModificationException).
     */
    transient int modCount;//每次擴容和更改map結構的計數器

    /**
     * The next size value at which to resize (capacity * load factor).
     *
     * @serial
     */
    // (The javadoc description is true upon serialization.
    // Additionally, if the table array has not been allocated, this
    // field holds the initial array capacity, or zero signifying
    // DEFAULT_INITIAL_CAPACITY.)
    int threshold;//臨界值，當實際大小（容量*負載因子）超過臨界值時，會進行擴容

    /**
     * The load factor for the hash table.
     *
     * @serial
     */
    final float loadFactor;//負載因子

構造方法中將兩個參數的構造方法app

 public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)//初始容量不能小於0，不然報錯
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)//初始容量不能大於最大值，不然爲最大值
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))//負載因子不能小於或者等於0，不能爲非數字
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;//初始化填充因子
        this.threshold = tableSizeFor(initialCapacity);//初始化threshold大小
    }

tableSizeFor(initialCapacity)這個方法的做用就是返回大於等於initialCapacity的最小的二的次方數。注意是最小

    /**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;//0b1001
        n |= n >>> 1;//1001 | 0100 = 1101
        n |= n >>> 2;//1101 | 0011 = 1111
        n |= n >>> 4;//1111 | 0000 = 1111
        n |= n >>> 8;
        n |= n >>> 16;//那麼後面這兩步就獲得的結果仍是1111。
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;//1111就是15.加1等於16
    }

加色cap等於10，那麼n = 10-1 = 9。n轉化爲二進制的話，就是0b1001。那麼無符號右移一位，就是0100。less

這裏cap-1的操做就是爲了保證最後獲得的n是最小的大於等於initialCapacity的二的次方數。好比這裏比10大的2的次方數就是16。若是沒有減1.通過上述屢次右移和或運算以後，獲得的就不是16了。而是32。就不是最小的了。就變成了2倍了。函數

接下來分析put方法。this

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

首先研究hash（key）這個方法spa

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

這個就叫擾動函數，他讓hash值得高16位與第16位進行異或處理。這樣能夠減小碰撞。採用位運算也是由於這樣更高效。而且當數組的長度很短時，只有低位數的hashcode值能參與運算。而讓高16位參與運算能夠更好的均勻散列，減小碰撞，進一步下降hash衝突的概率。而且使得高16位和低16位的信息都被保留了。.net

而後講述putVal方法，執行過程能夠用下面圖來理解：

1.判斷數組table是否爲空或者位null，不然執行resize()進行擴容；

2.根據鍵值key計算數組hash值獲得插入的數組索引i，若是table[i]==null，那麼就能夠直接新建節點添加到該處。轉向6，若是不爲空，轉向3

3.判斷table[i]的首個元素是否和key同樣，若是相同直接覆蓋value，不然轉向4，這裏的相同指的是hashCode以及equals；
4.判斷table[i] 是否爲treeNode，即table[i] 是不是紅黑樹，若是是紅黑樹，則直接在樹中插入鍵值對，不然轉向5；
5.遍歷table[i]，判斷鏈表長度是否大於8（且），大於8的話（且Node數組的數量大於64）把鏈表轉換爲紅黑樹，在紅黑樹中執行插入操做，不然進行鏈表的插入操做；遍歷過程當中若發現key已經存在直接覆蓋value便可；
6.插入成功後，判斷實際存在的鍵值對數量size是否超多了最大容量threshold，若是超過，進行擴容。
————————————————
版權聲明：本文爲CSDN博主「錢多多_qdd」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處連接及本聲明。
原文連接：https://blog.csdn.net/moneywenxue/article/details/110457302

源碼以下：

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：引用當前hashMap的散列表；p：表示當前散列表的元素，n：表示散列表數組的長度 i：表示路由尋址結果
　　　　　　//這裏是延遲初始化邏輯，第一次調用putVal時會初始化hashMap對象中的最耗內存的散列表
//　　　　步驟1
        if ((tab = table) == null || (n = tab.length) == 0)//table就是Hash，table就是HashMap的一個數組，類型是Node[]，這裏說明散列表還沒建立出來
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)//n在上面已經賦值了。這是步驟2。 tab[i = (n - 1) & hash])這一塊就是路由算法，賦予p所在table數組的位置，並把這個位置的對象，賦給p，若是這個位置的節點位null，那麼表示這個位置還沒存放元素。
            tab[i] = newNode(hash, key, value, null);就在該位置建立一個新節點，這個新節點封裝了key value
        else {//桶中這個位置有元素了
            Node<K,V> e; K k;//步驟3
            if (p.hash == hash &&//若是當前索引位置對應的元素和準備添加的key的hash值同樣
                ((k = p.key) == key || (key != null && key.equals(k))))而且知足準備加入的key和該位置的key是同一個對象，那麼後續就會進行替換操做。
                e = p;
            else if (p instanceof TreeNode)//步驟4.判斷該鏈是不是紅黑樹
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);若是是，則放入該樹中
            else {//步驟5 該鏈爲鏈表  使用尾插法插入數據
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {//桶的位置的next爲e，若是e爲null，在for的循環中就說明沒有找到同樣的key的位置，那麼久加入末尾
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st加入後判斷是否會樹化
                            treeifyBin(tab, hash);
                        break;//而後跳出
                    }
                    if (e.hash == hash &&//這種狀況就是找到了一個key以及hash都同樣了，那麼久要進行替換。
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;//這是循環用的，與前面的e=p.next組合，能夠遍歷鏈表。
                }
            }
            if (e != null) { // existing mapping for key//這裏就是替換操做，表示在桶中找到key值，hash值與插入元素相等的節點
                V oldValue = e.value;//記錄e的value
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;//用心智替換舊值，
                afterNodeAccess(e);//訪問後回調
                return oldValue;//返回舊值
            }
        }
        ++modCount;//結構性修改
        if (++size > threshold)//步驟6，若是超過最大容量就擴容。
            resize();
        afterNodeInsertion(evict);//插入後回調
        return null;
    }

總結一下流程：1根據key計算獲得key.hash = (h = k.hashCode())^(h>>>16);

2.根據key.hash計算獲得桶數組中的索引，其路由算法就是index = key.hash &(table.length-1)，就是哈希值與桶的長度-1作與操做，這樣就能夠找到該key的位置

2.1若是該位置沒有數據，那正好，直接生成新節點存入該數據

2.2若是該位置有數據，且是一個紅黑樹，那麼執行相應的插入/更新操做；

2.3若是該位置有數據，且是一個鏈表，若是該鏈表有這個數據，那麼就找到這個點而且更新這個數據。若是沒有，則採用尾插法插入鏈表中。

接下來說解最重要的resize()方法。

擴容的目的就是爲了解決哈希衝突致使的鏈化影響查詢效率的問題。擴容能夠緩解。

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//oldTab引用擴容前的哈希表
　　　　　////oldCap表示擴容以前table數組的長度
　　　　　　//oldTab==null就是第一次new HashMap()的時候，那時候尚未放值，數組就是null。那麼初始化的時候
　　　　　　//也要擴容。這句就是若是舊的容量爲null的話，那麼oldCap是0，不然就是oldTab的長度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;//表示擴容以前的擴容閾值，也就是觸發本次擴容的閾值
　　　　//newCap：擴容以後table數組的大小
 //newThr：擴容以後，下次再次觸發擴容的條件
        int newCap, newThr = 0;
        if (oldCap > 0) {//條件若是成立，那麼就是表明hashMap中的散列表已經初始化過了，這是一次正常的擴容
            if (oldCap >= MAXIMUM_CAPACITY) {//擴容以前的table數組大小已經達到最大閾值後，則不擴容，且設置擴容條件爲int最大值，這種狀況很是少數
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
　　　　　　　　//oldCap左移一位實現數值翻倍，而且賦值給newCap，newCap小於數組最大值限制 且 擴容以前的閾值>=16
 * //這種狀況下，則下一位擴容的閾值等於當前閾值翻倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold這裏閾值翻倍也能夠理解，若是原先table是16長度，那麼oldThr就是16*0.75=12；那麼oldCap翻倍的時候，那麼新的閾值就是2*16*0.75 = 24；
        }
　　　　　//這是oldCap==0的第一種狀況，說明hashMap中的散列表是null
　　　　　//哪些狀況下散列表爲null，可是閾值卻大於零呢
　　　　//1.new HashMap(initCap,loadFactor);
　　　　//2.new HashMap(initial);
　　　　//3.new HashMap(map);而且這個map有數據，着三種狀況下oldThr是有值得
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else { 這是oldCap==0,oldThr==0的狀況，是new HashMap();的時候// zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;//16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//12
        }
        if (newThr == 0) {//newThr爲0時，經過newCap和loadFactor計算出一個newThr
            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];//建立一個大小爲newCap的新的數組
        table = newTab;//把新的數組賦值給table
        if (oldTab != null) {//說明hashmap本次擴容以前，table不爲null
            for (int j = 0; j < oldCap; ++j) {//將舊數組中的全部數據都要處理，因此來個循環
                Node<K,V> e;//當前node節點
                if ((e = oldTab[j]) != null) {//說明當前桶位中有數據，可是數據具體是單個數據，仍是鏈表仍是紅黑樹並不知道
                    oldTab[j] = null;//將舊的數組的這個點置空，用於方便VM GC時回收內存
                    if (e.next == null)//若是當前的下一個不爲空，也就是在桶位中是單個數據，
                        newTab[e.hash & (newCap - 1)] = e;//那麼根據路由算法e的hash與上新的table的長度-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;
　　　　　　　　　　　　　　　　//假如oldCap = 16，那麼就是0b10000
　　　　　　　　　　　　　　　　//假如hash爲 .....1 1111.前面的不用看，就看着五位
　　　　　　　　　　　　　　　　//或者hash爲 .....0 1111.
　　　　　　　　　　　　　　　　那麼與上  000000.. 1 0000.前面都是0。因此與完以後，若是爲0，那麼就是下面這種.....0 1111，就表明應該在低位鏈。
                            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) {//若是原先舊數組中的鏈表中低位鏈後面不爲null，也就是後面是高位鏈的。複製到新的數組中就要置爲null。
                            loTail.next = null;
                            newTab[j] = loHead;//而後把這個低鏈表的頭節點放到新的數組中的索引位置。這樣低位鏈的這個節點，就到了新的數組的地方了
                        }
                        if (hiTail != null) {//同理
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

從下圖能夠看出上面擴容的第三種狀況，鏈表的狀況。在第15這個桶位的時候，爲啥擴容到32的長度的時候，有的鏈表節點還在15，而有一些卻到31處了。由於舊數組中的索引15是根據路由算法算出來的，

公式爲hash&(table.length-1),此時索引爲15，那麼就是hash&(table.length-1) =15.又由於table.length-1=15，也就是1111，那麼hash的低四位確定就知道了，也是1111，可是第五位就不知道了有多是1有可能

是0，也就是11111或者01111.那麼在新的數組中求索引的時候，根據路由算法，此時新的數組長度爲32，那麼32-1=31，也就是11111那麼舊數組中的數若是是11111，那麼算出來就是11111，就是在新數組

31的位置上，若是是01111，那麼與以後就是01111。就仍是15。別的位置也是這樣，若是是原索引爲1的地方，那麼有可能到新數組的17的位置，就是1+16=17；不是都是加16；而是加這個舊數組的長度。

接下來是get()方法；

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;//這裏hash(key)的緣由是由於存的時候，hash了一下，那麼取的時候，確定的要取他的hash值同樣的。
    }

因此主要是getNode方法：

final Node<K,V> getNode(int hash, Object key) {
　　　　////tab：引用當前hashMap的散列表
 　　　　//first：桶位中的頭元素
 　　　　//e：臨時node元素
　　　　 //n：table數組長度
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&  //(tab = table) != null&& (n = tab.length) > 0表示散列表不爲空，這樣才能取到值，要否則沒有水的水池不可能取到水。
            (first = tab[(n - 1) & hash]) != null) {//這個表明在這個索引的位置的頭節點不爲null。也就是這個地方有數據。
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;//若是頭元素就是正好要找的數據，那麼直接返回頭元素
            if ((e = first.next) != null) {//若是這個桶的索引處不是單個數據，那麼就進一步查找，若是是單個元素，那麼下面不執行，直接返回null，由於沒有找到
                if (first instanceof TreeNode)//若是是樹，那麼就去找
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {//桶位這裏所在的節點是鏈表
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;//若是找到同樣的e，那麼就返回，不然就一直循環，到結尾的話，就還沒找到，那麼就返回null
                } while ((e = e.next) != null);
            }
        }
        return null;//若是上述條件不知足，也就是桶爲null或者在指定位置沒有數據，那麼就返回null
    }

接下來是remove(Object key)方法。

public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

其實就是removeNode方法

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
　　　　//matchValue是用來判斷的，由於remove還有一個方法，是兩個參數的，remove(Object key, Object value).這個方法也是套娃了removeNode方法，意思是不只key得一致，value也得一致才能刪除。不然刪不了。matchValue就是用來作這個判斷得

* //tab：引用當前hashMap中的散列表
* //p：當前node元素
* //n：表示散列表數組長度
* //index：表示尋址結果，索引位置。
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&//這裏仍是同樣，先判斷有沒有水，否則不須要取水了。
            (p = tab[index = (n - 1) & hash]) != null) {//找到對應的桶位是有數據的，要否則爲null還刪啥
            Node<K,V> node = null, e; K k; V v; //node爲查找到的結果， e表示當前node的下一個元素
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))//當前定位的桶位的索引處的頭節點就是要找的結果
                node = p;//那麼把p賦值給node
            else if ((e = p.next) != null) {說明當前桶位的頭節點有下一個節點，要麼是紅黑樹，要麼是鏈表
                if (p instanceof TreeNode)//若是是紅黑樹
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;//這裏條件是說明若是是鏈表中的某一個，那麼就找到了這個節點，並把則會個結果賦值給node。用於返回。並退出循環
                            break;
                        }
                        p = e;//這裏是還沒找到繼續挨個迭代
                    } while ((e = e.next) != null);
                }
            }//上述是查找過程。下面是刪除過程
            if (node != null && (!matchValue || (v = node.value) == value ||//!matchValue || (v = node.value) == value就是用來判斷值是否須要判斷同樣再刪除，就是兩個參數的remove方法的條件。若是不是，那麼!matchValue就是對的，後面值得判斷就不用判斷了
                                 (value != null && value.equals(v)))) {//這裏就是判斷是不是要刪除這個節點。
                if (node instanceof TreeNode)//這種狀況表明結果是樹的節點。就走樹的刪除邏輯
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)//噹噹前桶位的元素就是要刪除的元素，那麼node纔會等於p，那麼就把node以後的頭節點放到這個桶位就行
                    tab[index] = node.next;
                else
                    p.next = node.next;//鏈表的狀況的時候，node必定是在後面。由於上述查找過程當中e一直都是p.next，e又賦值給node。因此node就在p後面。這裏刪除node節點就行。
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }