HashMap源码分析（二）

扩容

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table; //table默认是null
    //求原容器的长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold; //赋值原threshold
    int newCap, newThr = 0;
    if (oldCap > 0) { //初始不为0，那就是表示要扩容
        if (oldCap >= MAXIMUM_CAPACITY) { //已经到了限制最大大小，直接返回，没得扩了
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //原容量乘以2，再判断小于MAXIMUM_CAPACITY && 原容量大于等于DEFAULT_INITIAL_CAPACITY（默认16）
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && 
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; //  threshold 也乘以 2
    }
    else if (oldThr > 0) // 初始状态下 capacity 是用 threshold 来代替的，所以第一次是走到这个判断
        newCap = oldThr; //将初始的threshold设置为新的table的长度
    else {               // zero initial threshold signifies using defaults
        //能走到这，表示原来的oldCap容量是0或者完全没有初始化数组
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        //根据容量大小乘以loadFactor求得新的threshold的值
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr; //赋新值threshold
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //创建newCap大小的数组
    table = newTab;
    if (oldTab != null) {
        //遍历原数组
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) { //取出索引j的值
                oldTab[j] = null; //原数组该索引值设置为Null，方便gc
                if (e.next == null)
                    //索引j没有链表/树，直接用hash与新数组大小-1求与位运算，得出在新数组中的位置，并设置值
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    //如果是树节点，那就要遍历树，并将每个树节点重新与新数组与位运算，得出在新数组中的位置，并设置值，这就可能把树拆成链表，举个例子，假如原数组长度16，但是某个节点的hash是17，那么在原数组中存放在索引1（17 % 16）的位置，但是在新的数组中的位置却是17（扩容后大小是 32，17 % 32 = 17），所以原来的树就可能被拆了
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // 链表处理
                    //低位节点维持，低位就是原来的数组
                    Node<K,V> loHead = null, loTail = null;
                    //高位节点维持，高位就是扩容后的那部分数组
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        /*只要hash值与原容量求值为0的，那么在新数组中也都在低位存放，这个怎么理解呢，我举个例子：
                        假设oldCap = 16，二进制就是 00010000，那么只要hash值的第5位不为1，其他情况与 & 16 都是0，这些处理新数组的低段：
                        00001111  15
                      & 00010000  16
                      = 00000000   //为0
                      然后再与新数组的大小 - 1求 &
                        00001111  15
                      & 00011111  31 （32 -1）
                      = 00001111  15  这就是对应的数组索引，15属于低数组段
                      
                      只要hash值的第5位为1，那么 & 16都不为0，这些就处理在新数组的高段：
                        00011111   31
                      & 00010000   16
                      = 00010000   16 //不为0
                       然后再与新数组的大小 - 1求 &
                        00011111  15
                      & 00011111  31 （32 -1）
                      = 00011111  31  这就是对应的数组索引，31属于高数组段
                        
                        */
                        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;
                    }
                }
            }
        }
    }
    //返回新的table
    return newTab;
}