jdk 1.8 Hashmap源码分析之resize()方法

自己阅读源码才是王道，以前没好好看源码，今天就做个简单的吧，还有就是要注意区分版本，我之前有次面试就把版本给记混了，望引以为鉴！

 /** 如果表为空,即未被初始化，如果threshold.大于0，用其值作为初始化的表的长度，方法结束；如果threshold.为0，用默认值值作为初始化的表的长度，方法结束；
 * 如果表不为空,即已经被初始化，再看原来的表长度已经很大了（>= MAXIMUM_CAPACITY），则把threshold 变为最大（Integer.MAX_VALUE）并返回即可，不需要额外的扩容操作
 *                              如果原来的表长度不是很大，表长度扩大一倍，如果扩大后表长度扔小于最大长度（2^30），并且原来的表长度大于默认的初始长度，则新的阈值为原来阈值的二倍 （也即新长度的loadfactor倍）
 * 如果表不为空,即已经被初始化，出了表长度做改变，还需要复制原来表的内容
 * @return the table
 */

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) {//表被初始化过
        //如果原来的表长度已经很大了（>= MAXIMUM_CAPACITY），
        // 则把threshold 变为最大（Integer.MAX_VALUE）,
        // 并返回即可，不需要额外的扩容操作
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // 使用自定的长度，初始表长度保存在threshold中，注意：表长度不一定是指定的长度，表长度是大于等于自定义长度的最小的2的幂，详见tableSizeFor()方法
        newCap = oldThr;
    else {               // threshold 为0代表使用默认值
        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"})
        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)//只有一个节点重新计算桶的位置
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)//红黑树的情况
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // 链表的情况，保持原来的链表中的相对顺序
                        //把原来的链表拆分为两个，一个桶的位置还为原来的位置(newTab[j )，一个为原来桶的位置原来表长度的位置(newTab[j + oldCap])
                        //拆分的依据为节点hash值&oldCap是否为0
                    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;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}