1. final Node<K, V>[] resize() {
    2.         // 旧数组
    3.         Node<K, V>[] oldTab = table;
    4.         // 旧数组容量
    5.         int oldCap = (oldTab == null) ? 0 : oldTab.length;
    6.         // 旧数组扩容阈值
    7.         int oldThr = threshold;
    8.         int newCap, newThr = 0;
    9.         if (oldCap > 0) {
    10.             if (oldCap >= MAXIMUM_CAPACITY) {
    11.                 // 如果旧数组容量达到了最大容量则不再扩容
    12.                 threshold = Integer.MAX_VALUE;
    13.                 return oldTab;
    14.             }
    15.             // 如果旧容量的两倍小于最大容量并且旧容量大于默认初始容量（16），则容量扩大为两倍，扩容门槛也扩大为两倍
    16.             else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
    17.                     oldCap >= DEFAULT_INITIAL_CAPACITY)
    18.                 newThr = oldThr << 1; // double threshold
    19.         } else if (oldThr > 0) // initial capacity was placed in threshold
    20.             // 使用非默认构造方法创建的map，第一次插入元素会走到这里
    21.             // 如果旧容量为0且旧扩容门槛大于0，则把新容量赋值为旧门槛
    22.             newCap = oldThr;
    23.         else {               // zero initial threshold signifies using defaults
    24.             // 调用默认构造方法创建的map，第一次插入元素会走到这里
    25.             // 如果旧容量旧扩容门槛都是0，说明还未初始化过，则初始化容量为默认容量，扩容门槛为默认容量*默认装载因子
    26.             newCap = DEFAULT_INITIAL_CAPACITY;
    27.             newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    28.         }
    29.         if (newThr == 0) {
    30.             // 如果新扩容门槛为0，则计算为容量*装载因子，但不能超过最大容量
    31.             float ft = (float) newCap * loadFactor;
    32.             newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
    33.                     (int) ft : Integer.MAX_VALUE);
    34.         }
    35.         // 赋值扩容门槛为新门槛
    36.         threshold = newThr;
    37.         @SuppressWarnings({"rawtypes", "unchecked"})
    38.         Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];   // 新建一个新容量的数组
    39.         // 把桶赋值为新数组
    40.         table = newTab;
    41.         if (oldTab != null) { // 如果旧数组不为空，则搬移元素
    42.             // 遍历旧数组
    43.             for (int j = 0; j < oldCap; ++j) {
    44.                 Node<K, V> e;
    45.                 // 如果桶中第一个元素不为空，赋值给e
    46.                 if ((e = oldTab[j]) != null) {
    47.                     // 清空旧桶，便于GC回收
    48.                     oldTab[j] = null;
    49.                     // 如果这个桶中只有一个元素，则计算它在新桶中的位置并把它搬移到新桶中
    50.                     // 因为每次都扩容两倍，所以这里的第一个元素搬移到新桶的时候新桶肯定还没有元素
    51.                     if (e.next == null)
    52.                         newTab[e.hash & (newCap - 1)] = e;
    53.                     else if (e instanceof TreeNode)
    54.                         // 如果第一个元素是树节点，则把这颗树打散成两颗树插入到新桶中去
    55.                         ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
    56.                     else { // preserve order
    57.                         // 如果这个链表不止一个元素且不是一颗树
    58.                         // 则分化成两个链表插入到新的桶中去
    59.                         // 比如，假如原来容量为4，3、7、11、15这四个元素都在三号桶中
    60.                         // 现在扩容到8，则3和11还是在三号桶，7和15要搬移到七号桶中去
    61.                         // 也就是分化成了两个链表
    62.                         Node<K, V> loHead = null, loTail = null;
    63.                         Node<K, V> hiHead = null, hiTail = null;
    64.                         Node<K, V> next;
    65.                         do {
    66.                             next = e.next;
    67.                             // (e.hash & oldCap) == 0的元素放在低位链表中
    68.                             // 比如，3 & 4 == 0
    69.                             if ((e.hash & oldCap) == 0) {
    70.                                 if (loTail == null)
    71.                                     loHead = e;
    72.                                 else
    73.                                     loTail.next = e;
    74.                                 loTail = e;
    75.                             } else {
    76.                                 // (e.hash & oldCap) != 0的元素放在高位链表中
    77.                                 // 比如，7 & 4 != 0
    78.                                 if (hiTail == null)
    79.                                     hiHead = e;
    80.                                 else
    81.                                     hiTail.next = e;
    82.                                 hiTail = e;
    83.                             }
    84.                         } while ((e = next) != null);
    85.                         // 遍历完成分化成两个链表了
    86.                         // 低位链表在新桶中的位置与旧桶一样（即3和11还在三号桶中）
    87.                         if (loTail != null) {
    88.                             loTail.next = null;
    89.                             newTab[j] = loHead;
    90.                         }
    91.                         // 高位链表在新桶中的位置正好是原来的位置加上旧容量（即7和15搬移到七号桶了）
    92.                         if (hiTail != null) {
    93.                             hiTail.next = null;
    94.                             newTab[j + oldCap] = hiHead;
    95.                         }
    96.                     }
    97.                 }
    98.             }
    99.         }
    100.         return newTab;
    101.     } // 初始化或增加表大小