static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 相當(dāng)于16
static final float DEFAULT_LOAD_FACTOR = 0.75f;


public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

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，也就是hashMap中已經(jīng)有元素了，或者new對象的時候設(shè)置了初始容量
    if (oldCap > 0) {
        //如果以前的容量大于限制的最大容量1<<30,則設(shè)置臨界值為int的最大值2^31-1
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        /**
         * 如果以前容量的2倍小于限制的最大容量，同時大于或等于默認(rèn)的容量16，則設(shè)置臨界值為以前臨界值的2
         * 倍，因為threshold = loadFactor*capacity，capacity擴(kuò)大了2倍，loadFactor不變，
         * threshold自然也擴(kuò)大2倍。
         */
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    /**
     * 在HashMap構(gòu)造器Hash(int initialCapacity, float loadFactor)中有一句代碼，this.threshold    
     * = tableSizeFor(initialCapacity)， 表示在調(diào)用構(gòu)造器時，默認(rèn)是將初始容量暫時賦值給了
     * threshold臨界值，因此此處相當(dāng)于將上一次的初始容量賦值給了新的容量。什么情況下會執(zhí)行到這句？當(dāng)調(diào)用    
     * 了HashMap(int initialCapacity)構(gòu)造器，還沒有添加元素時
     */
    else if (oldThr > 0) 
        newCap = oldThr;
    /**
     * 調(diào)用了默認(rèn)構(gòu)造器，初始容量沒有設(shè)置，因此使用默認(rèn)容量DEFAULT_INITIAL_CAPACITY（16），臨界值
     * 就是16*0.75
     */
    else {               
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //對臨界值做判斷，確保其不為0，因為在上面第二種情況(oldThr > 0)，并沒有計算newThr
    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"})
    /**構(gòu)造新表，初始化表中數(shù)據(jù)*/
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    //將剛創(chuàng)建的新表賦值給table
    table = newTab;
    if (oldTab != null) {
        //遍歷將原來table中的數(shù)據(jù)放到擴(kuò)容后的新表中來
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                //沒有鏈表Node節(jié)點(diǎn)，直接放到新的table中下標(biāo)為【e.hash & (newCap - 1)】位置即可
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                //如果是treeNode節(jié)點(diǎn)，則樹上的節(jié)點(diǎn)放到newTab中
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                //如果e后面還有鏈表節(jié)點(diǎn)，則遍歷e所在的鏈表，
                else { // 保證順序
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        //記錄下一個節(jié)點(diǎn)
                        next = e.next;
                        /**
                         * newTab的容量是以前舊表容量的兩倍,因為數(shù)組table下標(biāo)并不是根據(jù)循環(huán)逐步遞增
                         * 的，而是通過（table.length-1）& hash計算得到，因此擴(kuò)容后，存放的位置就
                         * 可能發(fā)生變化，那么到底發(fā)生怎樣的變化呢，就是由下面的算法得到.
                         *
                         * 通過e.hash & oldCap來判斷節(jié)點(diǎn)位置通過再次hash算法后，是否會發(fā)生改變，如
                         * 果為0表示不會發(fā)生改變，如果為1表示會發(fā)生改變。到底怎么理解呢，舉個例子：
                         * e.hash = 13 二進(jìn)制：0000 1101
                         * oldCap = 32 二進(jìn)制：0001 0000
                         *  &運(yùn)算：0  二進(jìn)制：0000 0000
                         * 結(jié)論：元素位置在擴(kuò)容后不會發(fā)生改變
                         */
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        /**
                         * e.hash = 18 二進(jìn)制：0001 0010
                         * oldCap = 32 二進(jìn)制：0001 0000
                         * &運(yùn)算：32 二進(jìn)制：0001 0000
                         * 結(jié)論：元素位置在擴(kuò)容后會發(fā)生改變，那么如何改變呢？
                         * newCap = 64 二進(jìn)制：0010 0000
                         * 通過(newCap-1)&hash
                         * 即0001 1111 & 0001 0010 得0001 0010，32+2 = 34
                         */
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        /**
                         * 若(e.hash & oldCap) == 0，下標(biāo)不變，將原表某個下標(biāo)的元素放到擴(kuò)容表同樣
                         * 下標(biāo)的位置上
                         */
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        /**
                         * 若(e.hash & oldCap) != 0，將原表某個下標(biāo)的元素放到擴(kuò)容表中
                         * [下標(biāo)+增加的擴(kuò)容量]的位置上
                         */
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}