关于HashMap resize()方法

final Node<K,V>[] resize() {
    // 老的bucket 桶
    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; // double threshold
    }
    // 用于带参数的初始化HashMap,因为你有参数，在构造函数就已经赋值了 初始化容器大小、加载因子、临界值
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        // 无参的，需要赋值默认的参数
        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]; // 初始化新的Node数组
    table = newTab;
    if (oldTab != null) {
        // 遍历老数组
        for (int j = 0; j < oldCap; ++j) {
            // 这里的e特殊说明下，就是老数组 下标相同的链表元素
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                // 如果没有next，直接通过这个元素的hash和新数组长度减一 获取新的数组下标
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                // 如果是二叉树，需要把树分解
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                /**
                 * 如果有多个，就需要copy到新的表中
                 * 与1.7不同，1.7是每一个都rehash。
                 * 1.8 是根据根据一个链表，然后和老数组长度按位与。然后如果为0，到新数组还是原来的位置。如果不为0，位置就是之前的位置加老数组的长度作为新的下标。
                 * 说一下为什么用 (e.hash & oldCap) == 0 判断：
                 * 因为在1.7的时候，每个链表（hash值相同）都是重新根据新数组（原数组大小的2倍）进行取模的，比较麻烦。但其实1.8的做法和rehash结果一样，
                 * 但为什么1.8这样做呢？因为 数组的容量都是2的幂，数组容量减1得到的二进制位数要小于本来数组容量的位数（小1位 2^10 = 10000000000,2^10-1 = 1111111111 明显少1位）
                 * 前提 oldCap是2的幂，所以二进制肯定只有一个1，其他为0。那如果(e.hash & oldCap) == 0，e哈希值对应oldCap1的位置上的数肯定为0。
                 * 那数组变为2倍再减一，和之前的数组长度减一，就是最高位补了一个1（可以用15和31,31除以2 上15，余1 然后这个1就把之前最前面那个1顶上去了），
                 * 补的这个1和原数组最高位那个1在一个位置。前面也说到了，e.hash 对应的那个位置是0.所以扩容了，位置还是原来的位置。
                 *
                  */
                else { // preserve order
                    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;
}

对于1.8旧数组转新数组我画个图：

先记住 & 的前提是两个为1，才是1.有一个为0就是0.

图里面abcde代表e.hash，前面的就不需要管了，因为数组容量最高位1前面都是0，与完了肯定是0。

假如老数组大小（oldCap）是16，减一是15，看上面的图。位数是相差1位的（记住前面的高位都是0）。

那用e.hash和老数组长度按位与的时候，老数组因为是2的幂，所以只有最高位那1个1。如果

(e.hash & oldCap) == 0，那说明老数组里面的1对应e.hash位置肯定是0。

接着，数组的长度变为两倍，然后减一。就是之前数组减一的二进制前面补了一个1。补的这个1和之前数组最高位那个1是在一个位置（这是关键）。那我们知道e.hash 图中a位置是0，那么数组为2倍减一 补的那个1和0与还是0。所以数组位置不变。

 

我写的可能比较啰嗦，主要是为了我和大家理解。你可以按照这个思路来考虑：1.8为什么不像1.7那样重新哈希了，但1.8这样搞和重新哈希结果是一样的。那数组长度2倍减一和之前数组长度减一 就是在原来的基础上最高位多了一个1。那我们怎么知道e.hash 对应的那个位置是1还是0呢，是0反正原位置就不变了。那怎么判断呢？然后看人家用e.hash和原数组长度比，如果(e.hash & oldCap) == 0 得出原数组长度最高位那个1对应的e.hash那个位置是0.那为0就不变了吗？因为这个0的位置就是数组长度2倍减一和之前数组长度减一比较高位多的那个1的位置。