hashMap中的重点就是扩容函数，扩容函数承载了java中的hashMap对哈希散列容量的处理方式。
    方法体:

    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.         //初始化新容量与新的阈值
    9.         int newCap, newThr = 0;
    10.         //如果当前容量大于0
    11.         if (oldCap > 0){
    12.             //边界值判断
    13.             if (oldCap >= MAXIMUM_CAPACITY){
    14.                 //设置容量为2的31次方-1然后返回当前表，不再扩容
    15.                 threshold = Integer.MAX_VALUE;
    16.                 return oldTab;
    17.             }else if((newCap = oldCap << 1) < MAXIMUM_CAPACITY  //如果扩容后的容量小于极限值，且当前容量大于16，则扩容两倍
    18.                         && oldCap >= DEFAULT_INITIAL_CAPACITY)
    19.                 newThr = oldThr << 1;
    20.         }else if(oldThr > 0){   //如果表是空的但是有阈值，代表初始化时指定了容量与阈值
    21.             newCap = oldThr;    //则新表的容量等于旧表的阈值
    22.         }
    23.         else {  //如果表为空的阈值也是空的，代表初始化时没有指定任何容量/阈值的参数情况
    24.             newCap = DEFAULT_INITIAL_CAPACITY;
    25.             newThr = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
    26.         }
    28.         if (newThr == 0){   //如果新的阈值时0，处理表为空但是有阈值的情况
    29.             float ft = (float)newCap * loadFactor;  //根据新表容量与加载因子求出新阈值
    30.             //越界修复
    31.             newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
    32.         }
    33.         threshold = newThr;
    34.         Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    35.         table = newTab;
    36.         //如果老的哈希桶有元素
    37.         //开始转移元素
    38.         if (oldTab != null){
    39.             //对老的哈希桶进行遍历
    40.             for (int j = 0; j < oldCap; j++) {
    41.                 Node<K,V> e;
    42.                 if ((e = oldTab[j]) != null){
    43.                     //将原哈希桶元素置为null以便cg
    44.                     oldTab[j] = null;
    45.                     //如果当前链表就一个元素，说明不存在哈希冲突直接取模塞入新的表格
    46.                     if (e.next == null){
    47.                         //使用节点的hash值与上新表长度-1的值确保不越界的同时放入新的哈希桶
    48.                         //这个操作等同模运算但是效率更高
    49.                         newTab[e.hash & (newCap - 1)] = e;
    50.                     }//else 如果发生哈希碰撞且节点大于8转化成了红黑树，则放入红黑树中。这里暂且不讨论
    51.                     else {//如果发生哈希碰撞且节点数小于8，则根据链表上每个节点的哈希值一次放入哈希桶对应的下标位置
    52.                         //因为容量翻倍，所以原链表上每个节点可能在low位，也可能在high位。high位 = low + 原哈希桶容量
    53.                         //低位链表的头尾节点定义
    54.                         Node<K,V> loHead = null, loTail = null;
    55.                         Node<K,V> hiHead = null, hiTail = null;
    56.                         Node<K,V> next;//临时节点，用来存放下一个
    57.                         do{
    58.                             next = e.next;
    59.                             //这里利用为运算代替常规运算；判断放在原位置还是在原位置再移动2次幂的位置
    60.                             //等于0就是小于，应该存放在低位，否则存放在高位
    61.                             //loTail低位指的是新数组的0到oldTap - 1
    62.                             //hiTail高位指的是oldCap到newCap - 1
    63.                             //这一步实际上是遍历节点上链表的值，判断放在原节点还是扩容后的位置，对原链表一拆为二，进行链表重组
    64.                             if ((e.hash & oldCap) == 0){    //原位置
    65.                                 //给头尾结点指针赋值
    66.                                 if (loTail == null)
    67.                                     loHead = e;
    68.                                 else
    69.                                     loTail.next = e;
    70.                                 loTail = e;
    71.                             }else{  //移动位置
    72.                                 if (hiTail == null)
    73.                                     hiHead = e;
    74.                                 else
    75.                                     hiTail.next = e;
    76.                                 hiTail = e;
    77.                             }
    78.                         }while ((e = next) != null);
    79.                         //将低链表放在原index处
    80.                         if (loTail != null){
    81.                             loTail.next = null;
    82.                             newTab[j] = loHead;
    83.                         }
    84.                         //将高链表放在新index出
    85.                         if (hiHead != null){
    86.                             hiTail.next = null;
    87.                             newTab[j + oldCap] = hiHead;
    88.                         }
    89.                     }
    90.                 }
    91.             }
    92.         }
    93.         return newTab;
    94.     }