HashMap源码解析之resize()扩容

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//将当前table暂存到oldtab来操作
        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;//阈值设置为Integer的最大值，好像是2147483647，远大于默认的最大容量
                return oldTab;//直接返回当前table，不用扩容
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // 双倍扩大老内存和老阈值并赋给新的table
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               //这种情况是初始化HashMap时啥参数都没加
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {//当只满足老阈值大于0的条件时，新阈值等于新容量*默认扩容因子
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;//把新的阈值赋给当前table
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//创建容量为newCap的新table
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {//对老table进行遍历
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {//遍历到的赋给e进行暂存，同时将老table对应项赋值为null
                    oldTab[j] = null;
                    if (e.next == null)//将不为空的元素复制到新table中
                        newTab[e.hash & (newCap - 1)] = e;//等于是创建一个新的空table然后重新进行元素的put，这里的table长度是原table的两倍
                    else if (e instanceof TreeNode)//暂时没了解红黑树
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;//用于保存put后不移位的链表
                        Node<K,V> hiHead = null, hiTail = null;//用于保存put后移位的链表
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {//如果与的结果为0，表示不移位，将桶中的头结点添加到lohead和lotail中，往后如果桶中还有不移位的结点，就向tail继续添加
                                if (loTail == null)//在后面遍历lohead和lotail保存到table中时，lohead用于保存头结点的位置，lotail用于判断是否到了末尾
                                    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：

if (e.next == null){
    newTab[e.hash & (newCap - 1)] = e;
}

newtab中的length是原table的两倍，所以在put的时候，如果原来的put是e.hash&(n-1),新的put位置就应该是e.hash&(2n-1)，

举个例子：

       原来的leng结果为th=8，有三个hash值，01000110,00000110,00001110，和length-1与，也就是00000111，结果为0110,0110,0110，也就是6，当table长度*2时，也就是hash值和15(00001111)与，结果为0110,0110,1110，即6,6,14。

          这样看来，数组扩容之后，hash1和hash2还是保持原位在6桶中，而hash3则由6桶迁移到了14桶，这个迁移量就等于原数组的长度。

if ((e.hash & oldCap) == 0) {
    if (loTail == null)
        loHead = e;
    else
        loTail.next = e;
    loTail = e;
}

为什么这里是e.hash&oldcap而不是oldcap-1：

        当table扩容之后，也就是length的二进制表示前面加了个1，因为length为2的幂，所以只有一个1，如果e.hash与length等于0，即表示length的1位置，hash在那个位置是0，put的时候位置由hash的后几位决定，因为hash不会变所以位置也不会变；

如果e.hash与length的结果不等于0，即length的1位置hash为1，就会产生结点的偏移，偏移量为原数组长度。以上面的例子来看，hash1和hash2并未偏移，而hash3偏移量正好是1000，也就是8.

         然后把偏移的结点和不偏移的结点分别用不同的结点保存~