阿里面試題：說說HashMap的擴容過程？

　　這是一道阿里的面試題，考察你對HashMap源碼的了解情況，廢話不多說，咱們就直接上源碼吧！

jdk 1.7 源碼

void resize(int newCapacity) {
        Entry[] oldTable = table;//保存舊數組
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {//判斷當前數組大小是否達到最大值
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];//創建一個新數組
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean rehash = oldAltHashing ^ useAltHashing;//是否需要重新計算hash值
        transfer(newTable, rehash);//將oldTable的元素遷移到newTable
        table = newTable;//將新數組重新賦值
              //重新計算閾值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {//遍歷oldTable遷移元素到newTable
            while(null != e) {//①處會導致閉環，從而導致e永遠不為空，然后死循環，內存直接爆了
                Entry<K,V> next = e.next;
                if (rehash) {//是否需要重新計算hash值
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];//①
                newTable[i] = e;//①
                e = next;//①
            }
        }
}

jdk 1.8 源碼(比較長，慢慢品哈)

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;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; //擴容兩倍的閾值
        }
        else if (oldThr > 0) // 初始化新的數組大小
            newCap = oldThr;
        else {//上面條件都不滿足，則使用默認值
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        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"})
              //創建一個newCap大小的數組Node
        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;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;//釋放空間
                    if (e.next == null)
                      //如果舊數組中e后面沒有元素，則直接計算新數組的位置存放
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)//如果是紅黑樹則單獨處理
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { //鏈表結構邏輯，解決hash沖突
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            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) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        //原索引+oldCap放入數組中
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;//jdk1.8優化的點
                        }
                    }
                }
            }
        }
        return newTab;
    }

總結

　　jdk1.7擴容是重新計算hash；jdk1.8是要看看原來的hash值新增的那個bit是1還是0好了，如果是0則索引沒變，如果是1則索引變成"原索引+oldCap".這是jdk1.8的亮點，設計的確實非常的巧妙，即省去了重新計算hash值得時間，又均勻的把之前的沖突的節點分散到新的數組bucket上

 　　jdk1.7在rehash的時候，舊鏈表遷移到新鏈表的時候，如果在新表的數組索引位置相同，則鏈表元素會倒置，但是jdk1.8不會倒置