一、概述

HashMap的resize方法的作用：在向HashMap裡put元素的時候，HashMap基於擴容規則發現需要擴容的時候會呼叫該方法來進行擴容。

二、方法解析

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
        if (oldCap > 0) {	// 如果老陣列長度大於0，說明已經存在元素
            // PS1
 

            if (oldCap >= MAXIMUM_CAPACITY) { // 如果陣列元素個數大於等於限定的最大容量（2的30次方）
                // 擴容閥值設定為int最大值（2的31次方 -1 ），因為oldCap再乘2就溢位了。
                threshold = Integer.MAX_VALUE;	
                return oldTab;	// 返回老的元素陣列
            }

           /*
            * 如果陣列元素個數在正常範圍內，那麼新的陣列容量為老的陣列容量的2倍（左移1位相當於乘以2）
            * 如果擴容之後的新容量小於最大容量  並且  老的陣列容量大於等於預設初始化容量（16），那麼新陣列的擴容閥值設定為老閥值的2倍。（老的陣列容量大於16意味著：要麼建構函式指定了一個大於16的初始化容量值，要麼已經經歷過了至少一次擴容）
            */
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }

        // PS2
 

        // 執行到這個else if  說明老陣列沒有任何元素
        // 如果老陣列的擴容閥值大於0，那麼設定新陣列的容量為該閥值
        // 這一步也就意味著構造該map的時候，指定了初始化容量。
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            // 能執行到這裡的話，說明是呼叫無參建構函式建立的該map，並且第一次新增元素
            newCap = DEFAULT_INITIAL_CAPACITY;	// 設定新陣列容量 為 16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 設定新陣列擴容閥值為 16*0.75 = 12。0.75為負載因子（當元素個數達到容量了4分之3，那麼擴容）
        }

        // 如果擴容閥值為0 （PS2的情況）
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);  // 參見：PS2
        }
        threshold = newThr; // 設定map的擴容閥值為 新的閥值
        @SuppressWarnings({"rawtypes","unchecked"})
            // 建立新的陣列（對於第一次新增元素，那麼這個陣列就是第一個陣列；對於存在oldTab的時候，那麼這個陣列就是要需要擴容到的新陣列）
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;	// 將該map的table屬性指向到該新陣列
        if (oldTab != null) {	// 如果老陣列不為空，說明是擴容操作，那麼涉及到元素的轉移操作
            for (int j = 0; j < oldCap; ++j) { // 遍歷老陣列
                Node<K,V> e;
                if ((e = oldTab[j]) != null) { // 如果當前位置元素不為空，那麼需要轉移該元素到新陣列
                    oldTab[j] = null; // 釋放掉老陣列對於要轉移走的元素的引用（主要為了使得陣列可被回收）
                    if (e.next == null) // 如果元素沒有有下一個節點，說明該元素不存在hash衝突
                        // PS3
 

                        // 把元素儲存到新的陣列中，儲存到陣列的哪個位置需要根據hash值和陣列長度來進行取模
                        // 【hash值  %   陣列長度】   =    【  hash值   & （陣列長度-1）】
                        //  這種與運算求模的方式要求  陣列長度必須是2的N次方，但是可以通過建構函式隨意指定初始化容量呀，如果指定了17,15這種，豈不是出問題了就？沒關係，最終會通過tableSizeFor方法將使用者指定的轉化為大於其並且最相近的2的N次方。 15 -> 16、17-> 32
                        newTab[e.hash & (newCap - 1)] = e;

                        // 如果該元素有下一個節點，那麼說明該位置上存在一個連結串列了（hash相同的多個元素以連結串列的方式儲存到了老陣列的這個位置上了）
                        // 例如：陣列長度為16，那麼hash值為1（1%16=1）的和hash值為17（17%16=1）的兩個元素都是會儲存在陣列的第2個位置上（對應陣列下標為1），當陣列擴容為32（1%32=1）時，hash值為1的還應該儲存在新陣列的第二個位置上，但是hash值為17（17%32=17）的就應該儲存在新陣列的第18個位置上了。
                        // 所以，陣列擴容後，所有元素都需要重新計算在新陣列中的位置。


                    else if (e instanceof TreeNode)  // 如果該節點為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;  // 按命名來翻譯的話，應該叫高位首尾節點
                        // 以上的低位指的是新陣列的 0  到 oldCap-1 、高位指定的是oldCap 到 newCap - 1
                        Node<K,V> next;
                        // 遍歷連結串列
                        do {  
                            next = e.next;
                            // 這一步判斷好狠，拿元素的hash值  和  老陣列的長度  做與運算
                            // PS3裡曾說到，陣列的長度一定是2的N次方（例如16），如果hash值和該長度做與運算，結果為0，就說明該hash值一定小於陣列長度（例如hash值為1），那麼該hash值再和新陣列的長度取摸的話，還是hash值本身，所該元素的在新陣列的位置和在老陣列的位置是相同的，所以該元素可以放置在低位連結串列中。
                            if ((e.hash & oldCap) == 0) {  
                                // PS4
                                if (loTail == null) // 如果沒有尾，說明連結串列為空
                                    loHead = e; // 連結串列為空時，頭節點指向該元素
                                else
                                    loTail.next = e; // 如果有尾，那麼連結串列不為空，把該元素掛到連結串列的最後。
                                loTail = e; // 把尾節點設定為當前元素
                            }

                            // 如果與運算結果不為0，說明hash值大於老陣列長度（例如hash值為17）
                            // 此時該元素應該放置到新陣列的高位位置上
                            // 例：老陣列長度16，那麼新陣列長度為32，hash為17的應該放置在陣列的第17個位置上，也就是下標為16，那麼下標為16已經屬於高位了，低位是[0-15]，高位是[16-31]
                            else {  // 以下邏輯同PS4
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) { // 低位的元素組成的連結串列還是放置在原來的位置
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {  // 高位的元素組成的連結串列放置的位置只是在原有位置上偏移了老陣列的長度個位置。
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead; // 例：hash為 17 在老陣列放置在0下標，在新陣列放置在16下標；    hash為 18 在老陣列放置在1下標，在新陣列放置在17下標；                   
                        }
                    }
                }
            }
        }
        return newTab; // 返回新陣列
    }