jvm源码解析（二）HashMap

static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table; // oldTab指向扩容前的HashMap的底层Node数组
    int oldCap = (oldTab == null) ? 0 : oldTab.length; // oldCap指向原来HashMap数组长度
    int oldThr = threshold; // oldThr指向原HashMap的扩容阈值,初始化大小的最近的二进制（相等或向上）
    int newCap, newThr = 0; // 新table暂时不初始化
    if (oldCap > 0) { // 原来的HashMap有值
        if (oldCap >= MAXIMUM_CAPACITY) { // 原来的元素个数大于等于最大元素个数 1 << 30
            threshold = Integer.MAX_VALUE; // 扩容阈值设置为最大值
            return oldTab; // 返回老HashMap 即不扩容
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY) // 如果老的容量双倍都没有超过最大容量，且大于等于16
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // 如果老的容量小于等于零，且老的阈值大于零
        newCap = oldThr; // 新的容量等于阈值
    else {               // 老的阈值和容量小于等于零
        newCap = DEFAULT_INITIAL_CAPACITY; // 新table容量为默认容量16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 阈值为默认阈值 16*0.75
    }
    if (newThr == 0) { // 如果新table的阈值没有设置
        float ft = (float)newCap * loadFactor; // ft等于新容量 * 扩容因子（没传入默认0.75） 
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE); // 新容量和ft都小于最大容量，则新阈值为ft，否则为Int最大值
    }
    threshold = newThr; // 这个table的阈值改变
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 新建Node数组
    table = newTab;
    if (oldTab != null) { // 扩容前的Node数组非空
        for (int j = 0; j < oldCap; ++j) { // 遍历数组
            Node<K,V> e;
            if ((e = oldTab[j]) != null) { // e = 数组j索引位置不为空（有Node）
                oldTab[j] = null; // 老数组j索引位置制空
                if (e.next == null) // 老数组j索引位置只有一个node
                    newTab[e.hash & (newCap - 1)] = e; // 老的hash重新分配在新数组的新索引
                else if (e instanceof TreeNode) // 老数组j索引位置不止一个Node，且是红黑树
                // 红黑树中做Node重新计算索引，与下面else类似，不同的是对新的链表检验是否需要生成红黑树
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else {
                    // loHead标记不需要移动的链表头部，Tail为尾部
                    Node<K,V> loHead = null, loTail = null;
                    // hiHead标记需要移动的链表的头部，Tail为尾部
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next; // 循环的下一个Node
                    do { // 循环完Node数组j索引下所有Node
                        next = e.next;
                        if ((e.hash & oldCap) == 0) { // 不需要移动索引
                            // 1.7用的是(e.hash & newCap-1)，计算模运算，重新计算索引
                            // 1.8的(e.hash & oldCap)用的是高位运算，只能得出0或者oldCap
                            // 所以新的索引要么是j，要么是j+oldCap
                            if (loTail == null) // 如果尾部为空，也就是刚初始化
                                loHead = e; // 当前Node为头部
                            else
                            // 否则尾部的Next为当前Node
                                loTail.next = e;
                            loTail = e; // 尾部指针指向当前节点
                        }
                        else {
                            if (hiTail == null) // 需要移动的尾部为空
                                hiHead = e; // 需要移动的头部为当前Node
                            else
                            // 否则尾部的Next为当前Node
                                hiTail.next = e;
                            hiTail = e; // 尾部指针指向当前节点
                        }
                    } while ((e = next) != null);
                    if (loTail != null) { // 不需要迁移的尾部不为空
                        loTail.next = null; // 尾部的Next为空
                        newTab[j] = loHead; // 新数组的j索引指向不需要迁移的链表
                    }
                    if (hiTail != null) { // 需要迁移的链表不为空
                        hiTail.next = null; // 需要迁移的链表的尾部的next制空
                        newTab[j + oldCap] = hiHead; // 新数组新索引指向需要迁移的链表的头部
                    }
                }
            }
        }
    }
    return newTab; // 返回新链表
}