品HashMap（java8）

前言

做爲java開發人員，HashMap可謂是業務中的一把利器，9龍再次撿起這老生常談的知識點，深刻源碼，細細品味。java

首先，咱們拋出幾個關於HashMap的問題，帶着問題去學習，就像捉迷藏同樣有意思。node

一、爲何要使用HashMap？HashMap有什麼特性？數組

二、HashMap的主要參數有哪些？都有什麼做用？緩存

三、HashMap是基於什麼數據結構實現的？markdown

四、構造HashMap時傳入的初始容量是如何處理的？爲何要這樣作？數據結構

五、HashMap在何時擴容？擴容的時候都作了什麼事？hash碰撞8次必定會轉換爲紅黑樹嗎？併發

六、在foreach時對hashMap進行增刪操做會發生什麼？app

一、爲何要使用HashMap?

咱們在使用一種工具的時候，確定是由於其的某種特性很符合咱們的需求，可以快速準確的解決咱們的問題。那咱們爲何要使用HashMap呢？ide

This implementation provides constant-time performance for the basic operations (get and put), assuming the hash function disperses the elements properly among the buckets.函數

源碼註釋裏有這樣一句話，這就是咱們使用HashMap的緣由。

意爲：HashMap爲基本操做(get和put)提供了常數時間性能（即O(1)），假設散列函數將元素適當地分散到各個bucket中。

咱們能夠這樣理解，若是當你須要快速存儲並查詢值，可使用HashMap，它能夠保證在O(1)的時間複雜度完成。前提是你鍵的hashCode要足夠不一樣。

Map還有一個特性就是key不容許重複。下面咱們就來看看HashMap如何保證O(1)進行get和put。

二、細嚼HashMap主要參數

2.一、靜態常量

    //默認的初始化桶容量，必須是2的冪次方（後面會說爲何）
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    //最大桶容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //默認的負載因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //判斷是否將鏈表轉化爲樹的閾值
    static final int TREEIFY_THRESHOLD = 8;
    //判斷是否將樹轉化爲鏈表的閾值
    static final int UNTREEIFY_THRESHOLD = 6;
    //判斷是否能夠執行將鏈表轉化爲樹，若是當前桶的容量小於此值，則進行resize()。避免表容量太小，較容易產生hash碰撞。
    static final int MIN_TREEIFY_CAPACITY = 64;
複製代碼

2.二、字段

    //hash表
    transient Node<K,V>[] table;
    //緩存的EntrySet，便與迭代使用
    transient Set<Map.Entry<K,V>> entrySet;
    //記錄HashMap中鍵值對的數量
    transient int size;
    //當對hashMap進行一次結構上的變動，會進行加1。結構變動指的是對Hash表的增刪操做。
    transient int modCount;
    //判斷是否擴容的閾值。threshold = capacity * load factor
    int threshold;
    //負載因子，用於計算threshold，能夠在構造函數時指定。
    final float loadFactor;
複製代碼

三、嗅探HashMap數據結構

上面咱們看到一個Node[] table的Node數組。

爲何要使用數組呢？

答：爲了能快速訪問元素。哦，說的什麼鬼，那我得追問，爲何數組能快速訪問元素了？

數組只需對 [首地址+元素大小*k] 就能找到第k個元素的地址，對其取地址就能得到該元素。
CPU緩存會把一片連續的內存空間讀入，由於數組結構是連續的內存地址，因此數組所有或者部分元素被連續存在CPU緩存裏面。

讓咱們看看Node的結構。

 static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;    //key 的hash
        final K key;    //key對象
        V value;        //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;
        }
 }
複製代碼

咱們看到，Node節點內部保留了一個next節點的引用，太熟悉了，這不就是鏈表嘛。

到這，咱們知道了HashMap的底層數據結構是基於數組+鏈表。可是，這就完了嗎？在jdk1.7確實只是這樣，jdk1.8爲了提升hash碰撞時鏈表查詢效率低的問題，在hash碰撞達到8次以後會將鏈表轉化爲紅黑樹，以致於將鏈表查詢的時間複雜度從O(N)提升到O(logN)。

到這咱們就能夠明白，HashMap若是可以均勻的將Node節點放置到table數組中，咱們只要可以經過某種方式知道指定key的Node所在數組中的索引，基於數組，咱們就能夠很快查找到所需的值。

接着咱們就要看看如何定位到table數組中。

四、走進HashMap構造函數

有了上面的基礎知識，知道字段含義及數據結構，咱們就有一點信心能夠正式進入源碼閱讀。我以爲了解一個類，得從構造函數入手，知道構造對象的時候作了哪些初始化工做，其次再深刻經常使用的方法，抽絲剝繭。

    public HashMap(int initialCapacity) {
        //若是隻傳入初始值，則負載因子使用默認的0.75
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

   public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
       //保證初始容量最大爲2^30
        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);
    }
複製代碼

咱們能夠看到，構造函數主要是爲了初始化負載因子及hash表的容量。可能你們會疑問，這不是初始化的是threshold嗎？不要被表面所欺騙，這只是臨時將hash表的容量存儲在threshold上，我想是由於HashMap不想增長多餘的字段來保存hash表的容量，由於數組的length就能夠表示，只是暫時數組還未初始化，因此容量暫先保存在threshold。

咱們看到將用戶指定的initialCapacity傳入tableSizeFor方法返回了一個值，返回的值纔是真正初始化的容量。？？？搞毛子這是？然咱們揭開它神祕的面紗。

/**
 * Returns a power of two size for the given target capacity.
 */
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;
    }
複製代碼

好吧，咱們仍是把它蓋上吧，9龍也沒去推算過。咱們從jdk給的方法註釋看出，該方法返回一個目標值的2的冪次方，進一步9龍翻譯爲：返回大於或等於目標值的第一個數，該數必須是2的冪次方。

舉例說一下：

若是輸入10，大於等於10的第一個數，又是2的冪次方的數是16；

若是輸入7，大於等於7的第一個數，又是2的冪次方的數是8；

若是輸入20；大於等於20的第一個數，又是2的冪次方的是32；

到這咱們又得問本身，爲何hash表的容量必須是2的冪次方呢？

五、解剖HashMap主要方法

5.一、put

當咱們new出HashMa的對象，都會調用put方法進行添加鍵值對。我跟那些直接貼代碼的能同樣嗎？有啥不同，哈哈哈。9龍會先讀源碼，再貼流程圖，這樣你們會更理解一點。

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

static final int hash(Object key) {
        int h;
    //將key的高16位與低16位異或，減少hash碰撞的機率
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
複製代碼

讓咱們看看putVal幹了什麼。

    /**
     * 此方法用於將(k,v)鍵值對存儲到HashMap中
     *
     * @param hash key的hash
     * @param key key對象
     * @param value key對應的value對象
     * @param onlyIfAbsent 若是是true,則不覆蓋原值。
     * @param evict if false, the table is in creation mode.
     * @return 返回舊值，若是沒有，則返回null。
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //在第一次put的時候，此時Node表還未初始化，上面咱們已經知道，構造HashMap對象時只是初始化了負載因子及初始容量，但並無初始化hash表。在這裏會進行第一次的初始化操做。
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //若是獲得了一個hash值，而且hash值在不多相同的狀況下，如何均勻的分佈到table數組裏呢？最容易想到的就是用hash%n，n爲table數組的長度。可是%運算是很慢的，咱們知道位運算纔是最快的，計算機識別的都是二進制。因此若是保證n爲2的冪次方，hash%n 與 hash&(n-1)的結果就是相同的。這就是爲何初始容量要是2的冪次方的緣由。
        //當找到的hash桶位沒有值時，直接構建一個Node進行插入
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            //不然，代表hash碰撞產生。
            Node<K,V> e; K k;
            //判斷hash是否與桶槽的節點hash是否相同而且key的equals方法也爲true,代表是重複的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 {
                //代表是鏈表，還未轉換爲紅黑樹。
                for (int binCount = 0; ; ++binCount) {
                    //若是節點的next索引是null，代表後面沒有節點，則使用尾插法進行插入
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //此時鏈表長度爲9，即hash碰撞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;
                }
            }
            //判斷是不是重複的key
            if (e != null) { // existing mapping for key
                //拿到舊值
                V oldValue = e.value;
                //由於put操做默認的onlyIfAbsent爲false，因此，默認都是使用新值覆蓋舊值
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                //返回舊值
                return oldValue;
            }
        }
        //到這裏，代表有新數據插入到Hash表中，則將modCount進行自增
        ++modCount;
        //判斷當前鍵值對容量是否知足擴容條件，知足則進行擴容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
複製代碼

總結一下：

put方法先經過計算key的hash值；
若是hash表沒有初始化，則進行初始化；
而後計算該hash應該處於hash桶的哪一個位置；
若是該位置沒有值，則直接插入；
若是有值，判斷是否爲樹節點，是的話插入到紅黑樹中；
不然則是鏈表，使用尾插法進行插入，插入後判斷hash碰撞是否知足8次，若是知足，則將鏈表轉化爲紅黑樹；
插入後判斷key是否相同，相同則使用新值覆蓋舊值；
進行++modCount，代表插入了新鍵值對；再判斷是否進行擴容。

靈魂拷問：真的hash碰撞8次必定會轉換爲紅黑樹嗎？？？

其實否則，在put中，若是hash碰撞8次會調用此方法將鏈表轉換爲紅黑樹，但不必定調用就會真正轉換。須要tab.length大於等於64纔會真正的執行轉換操做。由於在表容量太小的時候，hash碰撞纔會比較明顯，但不是說表越大越好。

 final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
     //若是表的長度小於64，是先擴容
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            //只有大於等於64纔會真正的轉換
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }
複製代碼

5.二、resize()

put方法中用到了兩次resize()方法，如今讓咱們來品一品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;
        //若是舊table中有數據
        if (oldCap > 0) {
            //當表的長度達到定義的最大值時，再也不進行擴容，只是將判斷擴容的閾值改成Integer.MAX_VALUE。
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //先將新容量爲原來的2倍，若是結果小於MAXIMUM_CAPACITY而且舊的容量大於等於默認值16，則也將新的閾值爲原來的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
    //oldCap等於0 若是舊閾值大於0,則將舊閾值賦值給新容量。這一步對應於指定的容量構造器，指定容量時，賦值給了閾值
        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);
        }
    //這裏是由於在oldCap大於0但沒有大於默認的16，不會更改newThr的值，仍是0。這時候須要根據newCap的值計算newThr。
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
    //將新閾值覆蓋threshold
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
    //使用newCap初始化新表。這裏的newCap是oldCap的2倍
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
    //至此，完成了新表容量的計算及新閾值的計算，而且建立了新表。下面開始將舊錶數據移至新表
        if (oldTab != null) {
            //從表的前日後遷移
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                //若是下標j對應的位置有值，拿到引用賦值給e
                if ((e = oldTab[j]) != null) {
                    //由於已經有了引用e,能夠將原數組的賦值爲null, help gc
                    oldTab[j] = null;
                    //若是e.next沒有指向，則證實當前槽位只有一個節點，直接計算在新表的位置賦值便可
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    //證實當前槽位不止一個節點，判斷e是否爲TreeNode，若是是，則使用樹的遷移方法
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        //由於擴容後的節點不是在j處，就在j + oldCap處。
                        //loHead節點記錄了j處的鏈表的頭指針，loTail記錄j處尾指針
                        //hiHead節點記錄了j+oldCap處鏈表的頭指針，hiTail記錄了j+oldCap處的尾指針
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            //判斷是否還處於j處（後面會詳細解釋）
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    //記錄j的頭指針
                                    loHead = e;
                                else
                                    //連接節點
                                    loTail.next = e;
                                loTail = e;
                            }
                            //不然在[j+oldCap]處
                            else {
                                if (hiTail == null)
                                    //記錄j+oldCap的頭指針
                                    hiHead = e;
                                else
                                    //連接節點
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            //將位置沒變的鏈表放在j處
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            //將位置改變的鏈表放在[j+oldCap]處
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
    //返回新鏈表
        return newTab;
    }
複製代碼

如今咱們仔細分析e.hash & oldCap。二話不說，直接上圖。

如此詳細，是否是不點贊都有點過度了。

resize()中咱們看到若是是樹節點，調用了((TreeNode)e).split(this, newTab, j, oldCap)方法。有了上面的知識，其實這個方法乾的事情是同樣的。將紅黑樹拆分爲兩棵子樹，仍是分別放置於原來位置和原來位置+oldCap位置。但要注意，這個方法在樹的節點小於等於6的時候會將紅黑樹轉換回鏈表。

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
            TreeNode<K,V> b = this;
            // Relink into lo and hi lists, preserving order
            TreeNode<K,V> loHead = null, loTail = null;
            TreeNode<K,V> hiHead = null, hiTail = null;
            int lc = 0, hc = 0;
            for (TreeNode<K,V> e = b, next; e != null; e = next) {
                next = (TreeNode<K,V>)e.next;
                e.next = null;
                //判斷位置是否更改
                if ((e.hash & bit) == 0) {
                    if ((e.prev = loTail) == null)
                        loHead = e;
                    else
                        loTail.next = e;
                    loTail = e;
                    ++lc;
                }
                else {
                    if ((e.prev = hiTail) == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                    ++hc;
                }
            }

            if (loHead != null) {
                //數量小於等於6，轉換回鏈表
                if (lc <= UNTREEIFY_THRESHOLD)
                    tab[index] = loHead.untreeify(map);
                else {
                    tab[index] = loHead;
                    if (hiHead != null) // (else is already treeified)
                        loHead.treeify(tab);
                }
            }
            if (hiHead != null) {
                if (hc <= UNTREEIFY_THRESHOLD)
                    tab[index + bit] = hiHead.untreeify(map);
                else {
                    tab[index + bit] = hiHead;
                    if (loHead != null)
                        hiHead.treeify(tab);
                }
            }
        }
複製代碼

到此，resize()方法9龍啃完了，牙好疼啊。

5.二、get

知道了HashMap的數據結構及如何以常數時間將鍵值對put保存管理的，那get這不是很容易嗎？請你們嚐嚐這道小菜。咱們保存的是鍵值對，存儲的時候都是以key做爲條件存儲的，因此在咱們取值的時候也是經過key獲取值。

    public V get(Object key) {
        Node<K,V> e;
        //計算key的hash，用於定位桶的位置
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
     final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
         //若是hash桶有值，而且基於hash繼續的桶位置也存在值
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //先檢查第一個節點是否匹配，找到則返回
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            //若是第一個不匹配，則判斷next是否存在
            if ((e = first.next) != 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;
                } while ((e = e.next) != null);
            }
        }
         //沒有找到，則返回null
        return null;
    }
複製代碼

總結一下get流程：

更加key計算hash值
使用hash&(n-1)判斷hash桶位是否有值，若是沒有值，則返回null
若是有值，判斷第一個是否匹配。（匹配指：hash值相同而且equals方法返回結果爲true），匹配則返回
若是第一個不匹配，判斷是否爲樹節點，是樹節點則從紅黑樹查找
若是不是樹節點，則是鏈表，則從表頭到表尾依次查找。

六、簡述modCount

這個字段並非map獨有的，Collection集合（List、Set）也有。此字段用於迭代時的快速失敗，也就是在迭代的過程當中，若是調用了put、clear、remove等會對容器內部數據的數量產生增長或減小的操做時，拋出ConcurrentModificationException異常。

HashMap有三個迭代器，分別是KeyIterator、ValueIterator、EntryIterator，它們分別對應於KeySet、Values、EntrySet內部類中，當用戶調用其對應的iterator()方法時都會new一個對應的迭代器。

這裏我就不貼代碼了，太多，有興趣的能夠去看一看。這裏主要講解爲何快速失敗。

final class KeyIterator extends HashIterator
        implements Iterator<K> {
        public final K next() { return nextNode().key; }
    }

    final class ValueIterator extends HashIterator
        implements Iterator<V> {
        public final V next() { return nextNode().value; }
    }

    final class EntryIterator extends HashIterator
        implements Iterator<Map.Entry<K,V>> {
        public final Map.Entry<K,V> next() { return nextNode(); }
    }
複製代碼

使用者能夠根據本身的需求選擇使用的迭代器。每個都繼承自HashIterator，咱們來看一看。

 abstract class HashIterator {
        Node<K,V> next;        // next entry to return
        Node<K,V> current;     // current entry
        int expectedModCount;  // for fast-fail
        int index;             // current slot

        HashIterator() {
            //關鍵在這裏，當每一次使用迭代器的時候，會將modCount賦值給內部類的expectedModCount
            expectedModCount = modCount;
            Node<K,V>[] t = table;
            current = next = null;
            index = 0;
            if (t != null && size > 0) { // advance to first entry
                do {} while (index < t.length && (next = t[index++]) == null);
            }
        }

        public final boolean hasNext() {
            return next != null;
        }

        final Node<K,V> nextNode() {
            Node<K,V>[] t;
            Node<K,V> e = next;
            //每次取值以前會判斷modCount和expectedModCount是否相等，若是不等則代表在迭代過程當中有其餘線程或當前線程調用了put、remove等方法。
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (e == null)
                throw new NoSuchElementException();
            if ((next = (current = e).next) == null && (t = table) != null) {
                do {} while (index < t.length && (next = t[index++]) == null);
            }
            return e;
        }

         //若是想刪除，只能調用迭代器本身的remove方法，可是，它刪除的是調用nextNode()拿到的節點
        public final void remove() {
            Node<K,V> p = current;
            if (p == null)
                throw new IllegalStateException();
            //刪除以前也會判斷modCount是否被修改
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            current = null;
            K key = p.key;
            removeNode(hash(key), key, null, false, false);
            expectedModCount = modCount;
        }
    }
複製代碼

因此，在迭代過程當中對HashMap進行增刪操做會拋出ConcurrentModificationException異常。還記得一開始提出的一個問題嗎？對的，就是它。你能夠去看看List等的源碼，modCount也存在，並且實現都是同樣的。

七、總結

樓主花了很大的精力與時間與你們細嚼慢嚥HashMap，我想如今你們都知道了最開始的問題的答案了，包括過程當中樓主提出的一些問題，也都一一進行了詳解。9龍沒去討論併發條件出現的問題，也不討論1.7併發擴容時鏈表死循環問題，網上太多了。更重要是，HashMap自己就不支持併發操做，那你想到了什麼呢？

9龍才疏學淺，文中若有錯誤，敬請指出，也歡迎你們有疑問能夠提出，一塊兒探討進步。

若是以爲9龍本文對你有幫助，請幫忙點贊、分享以示支持，若是轉載請註明出處。話很少說，點關注，不迷路。