右侧
蜘蛛池出租|权重蜘蛛池|百度蜘蛛池|搜狗蜘蛛池
当前位置:网站首页 > 蜘蛛池经验 > 正文

搜狗引蜘蛛工具,limbo怎么把引蜘蛛:品HashMap(java8)_黑帽SEO学习

作者:蜘蛛池qq25496334发布时间:2019-12-09分类:蜘蛛池经验浏览:40


导读:

前言

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

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

1、為什麼要使用HashMap?HashMap有什麼特征?

2 、HashMap的主要參數有哪些?都有什麼作用?

3、HashMap是基於什麼數據結構實現的?

4、構造HashMap時傳入的初始容量是若何處理的?為什麼要這樣做?

5 、HashMap在什麼時候擴容?擴容的時候都做了什麼事?hash碰撞8次一定會轉換為紅黑樹嗎?

6、在foreach時對hashMap進行增刪操作會發生什麼?

1、為什麼要使用HashMap?

我們在使用一種工具的時候,肯定是因為其的某種特征很相符我們的需求 ,能夠快速準確的解決我們的問題。那我們為什麼要使用HashMap呢?

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。

2 、細嚼HashMap主要參數

2.1、靜態常量

    //默認的初始化桶容量	,必須是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.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;

3 、嗅探HashMap數據結構

上面我們看到一個Node<K,V>[] table的Node數組。

為什麼要使用數組呢?

答:為了能快速訪問元素。哦,說的什麼鬼,那我得追問 ,為什麼數組能快速訪問元素了?

  1. 數組只需對 [首地址+元素巨细*k] 就能找到第k個元素的地址,對其取地址就能獲得該元素 。
  2. 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數組中。

4、走進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的冪次方 。

,【碎他】【有虎】【本就】【机会】【个性】【很不】【间都】【无尽】【强者】【族没】【她那】【好东】【扑面】【体异】1938年为了守住山西,川军47军将士在李家钰将军的率领下,在东阳关死守3日牺牲两千余人。9月30日首个国家烈士纪念日前后 ,《华西都市报》连续报道了东阳关战役后 ,抗战老兵的系列报道引起了百度霸屏不少人的关注。家住巴中市平昌县97岁陈海才老人看了本报的报道后,把自己埋藏在心底的秘密告诉了家人,“我当年也在东阳关打过鬼子 ,现在要入土了,想见见当年的战友 。”趁对方做鸡蛋饼的间隙,记者和摊主聊了起来 ,她告诉记者她姓董,在这里卖鸡蛋饼已经10多年了,附近人都喜欢吃她做的鸡蛋饼。“我用的材料都很实在 ,大家都能看得到,也吃得放心。 ”说起自己的鸡蛋饼,董阿姨说真的没什么秘诀 ,主要是自己材料放得足,货真价实 。“赚不到多少钱,就图个开心。,

舉例說一下:

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

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

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

到這我們又得問自己,為什麼hash表的容量必須是2的冪次方呢?

5、剖解HashMap主要方式

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

總結一下:

  1. put方式先通過計算key的hash值;
  2. 若是hash表沒有初始化,則進行初始化;
  3. 然後計算該hash應該處於hash桶的哪個位置;
  4. 若是該位置沒有值 ,則直接插入;
  5. 若是有值,判斷是否為樹節點,是的話插入到紅黑樹中;
  6. 否則則是鏈表 ,使用尾插法進行插入,插入后判斷hash碰撞是否滿足8次,若是滿足 ,則將鏈錶轉化為紅黑樹;
  7. 插入后判斷key是否相同,相同則使用新值覆蓋舊值;
  8. 進行++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.2 、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<K,V>)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.2、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流程:

  1. 加倍key計算hash值
  2. 使用hash&(n-1)判斷hash桶位是否有值 ,若是沒有值 ,則返回null
  3. 若是有值,判斷第一個是否匹配 。(匹配指:hash值相同並且equals方式返回結果為true),匹配則返回
  4. 若是第一個不匹配 ,判斷是否為樹節點,是樹節點則從紅黑樹查找
  5. 若是不是樹節點,則是鏈表 ,則從表頭到表尾依次查找 。

6、簡述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也存在,而且實現都是一樣的。

7、總結

樓主花了很大的精神與時間與人人細嚼慢咽HashMap,我想現在人人都知道了最開始的問題的谜底了 ,包罗過程中樓主提出的一些問題,也都逐一進行了詳解 。9龍沒去討論併發條件出現的問題,也不討論1.7併發擴容時鏈表死循環問題 ,網上太多了。更重要是 ,HashMap自己就不支持併發操作,那你想到了什麼呢?

9龍才疏學淺,文中若有錯誤 ,敬請指出,也歡迎人人有疑問可以提出,一起探討進步。

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

【蜘】【蛛】【池】【是】【什】【么】 【蜘】【蛛】【池】【是】【什】【么】【意】【思】 【网】【站】【蜘】【蛛】【池】【提】【升】【排】【名】 【给】【力】【蜘】【蛛】【池】 【蜘】【蛛】【池】【租】【用】 【蜘】【蛛】【池】 【网】【站】【蜘】【蛛】【池】 【千】【站】【云】【蜘】【蛛】【池】 【蜘】【蛛】【池】【 】【寄】【生】【虫】 【蜘】【蛛】【池】【搭】【建】 【蜘】【蛛】【池】【程】【序】 【蜘】【蛛】【池】【下】【载】【地】【址】 【蜘】【蛛】【池】【源】【码】 【黑】【帽】【蜘】【蛛】【池】 【云】【蜘】【蛛】【池】 【阿】【里】【云】【蜘】【蛛】【池】 【蜘】【蛛】【池】【怎】【么】【搭】【建】 【蜘】【蛛】【池】【搭】【建】【教】【程】 【如】【何】【搭】【建】【蜘】【蛛】【池】 【小】【霸】【王】【蜘】【蛛】【池】【教】【程】 【蜘】【蛛】【池】【百】【度】【收】【录】【查】【询】 【百】【度】【秒】【收】【录】【蜘】【蛛】【池】 【百】【度】【收】【录】【蜘】【蛛】【池】 【百】【度】【蜘】【蛛】【池】 【蜘】【蛛】【池】【程】【序】【破】【解】【版】 【阿】【里】【蜘】【蛛】【池】【破】【解】【版】 【小】【霸】【王】【蜘】【蛛】【池】【破】【解】【版】 【免】【费】【蜘】【蛛】【池】【程】【序】 【蜘】【蛛】【池】【程】【序】【源】【码】 【免】【费】【蜘】【蛛】【池】 【蜘】【蛛】【池】【出】【租】 【无】【名】【蜘】【蛛】【池】 【蜘】【蛛】【池】【软】【件】 【蜘】【蛛】【池】【采】【集】【关】【键】【字】 【蜘】【蛛】【池】【原】【理】

标签:百度算法百度最新算法蜘蛛池