HashMap的扩容机制resize()方法源码解读

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) {          		
            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) // initial capacity was placed in threshold
            newCap = oldThr;
        else {
		    //第一次时初始化的逻辑 没有指定默认容量的情况 
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {//指定了默认容量  计算新的threshold
            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表
        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 { //表项中有多个元素 形成了一个链表
                        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) {
                                //这个节点保持不动
                                //会生成一个lo链表
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next   = e;
                                loTail = e;
                            }
                            else {
                                //这个节点需要移动
                                //会生成一个hi链表
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            //lo链表不为空 接到新的桶中原来的位置
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            //hi链表不为空 接到新的桶中原index+oldCap的位置
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

 从代码Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; 开始就是正式进行扩容的过程。之前都是进行属性计算的流程，在注释中也已经说明。主要的难点就是在于从这行代码之后的数据转存逻辑。

首先通过一个循环，遍历旧的table的每个表项，然后依次决定扩容后它们的索引

每个表项的处理逻辑分为以下几步:

(1) 表项中只有一个元素，那么直接通过newTab[e.hash & (newCap - 1)] = e为该元素在新生成的表中确定插入位置

(2 )表项中存放的是一颗红黑树，那么就调用((TreeNode<K,V>)e).split(this, newTab, j, oldCap);将这颗红黑树转存到newTab中。这一部分涉及红黑树的算法，留在以后详细解析。

(3) 表项中存放的是一个链表。这一部分个人认为最难理解也是最巧妙的。在这一部分我们需要一点位运算的知识。首先我们来看这个判断条件(e.hash & oldCap) == 0，在考虑这个判断条件之前，我们先思考(n - 1) & hash。假设大小n = 2^m，那么该运算是取得hash二进制值得低m位，由于扩容机制(容量扩充两倍)，n变成了2^(m+1),那么在新的表中进行索引计算时，计算的索引便是n的低(m+1)位。

这样一想，如果两次计算过程中,如果第(m+1)位还是0，说明这个元素在新的表中根本不需要移动位置，仍然放在原来的地方即可。那如果第(m+1)位为1，索引位置就发生了改变，它就是在旧的索引值新增了一个2^m。

所以我们计算第(m+1)位的值呢，就是通过e.hash & oldCap来获取，它的取值要么是0，要么是1.

如果是0，直接接在lo链表

如果是1，直接接在hi链表

遍历结束之后，lo链表按照旧表的索引直接存在新表同样的索引中，对应于代码newTab[j] = loHead;

hi链表接在新表的索引中，该索引是原索引+oldCap的值。对应于newTab[j + oldCap] = hiHead;

至此，新表扩容结束，数据转存完毕，直接返回