HashMap源码分析2：扩容

本文源码基于JDK1.8.0_45。

 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 {               // zero initial threshold signifies using defaults
         newCap = DEFAULT_INITIAL_CAPACITY;
         newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
     }
     //未指定新的阈值时用容量计算阈值（可以看到在JDK1.8的源码中，只有指定容量的初始化时才会进入下面的逻辑）
     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];
     table = newTab;
     //以上是创建新数组的逻辑，下面再来看HashMap中原来存的数据怎么重新分配到新的数组中
     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 { // preserve order
                     Node<K,V> loHead = null, loTail = null;//数组下标不需要更改的节点放在这个链表里
                     Node<K,V> hiHead = null, hiTail = null;//数组下标需要更改的节点放在这个链表里
                     Node<K,V> next;
                     do {
                         next = e.next;
                         //以容量为16为例，则计算下标的方式是用哈希值与15做与运算。15的二进制为1111，即二级制数保留低4位的值
                         //假设当前扩容容量为32，则要与31做与运算。31的二级制为11111，即保留二进制数低5位的值
                         //如果哈希值与当前容量即16（二进制10000）做与运算等于0，表示该哈希值在新增的第五位为0，扩容后不影响其下标的计算
                         //因此这部分数据在新的数组中位于相同的位置
                         if ((e.hash & oldCap) == 0) {
                             if (loTail == null)
                                 loHead = e;
                             else
                                 loTail.next = e;
                             loTail = e;
                         }
                         //与上述相反，如果与运算结果为1，表示其哈希值有影响，且下标移动的位置刚好是oldCap的值
                         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;
                     }
                     //下标的为原数组下标 + oldCap
                     if (hiTail != null) {
                         hiTail.next = null;
                         newTab[j + oldCap] = hiHead;
                     }
                 }
             }
         }
     }
     return newTab;
 }

本文同样忽略了扩容时红黑树的实现，这些内容将在之后介绍。