Hashmap中的扩容操作reisze()方法

一.何时会发生resize()扩容

1.初始化HashMap的默认扩容一个 cap为16 ，threshold（阈值）为12的Node<K, V>[] newTab

2.HashMap中元素数量达到阈值,每次扩容的容量都是之前容量的2倍。。

二.resize()扩容的大致流程

第一步: 确定新数组的 容量 和 阈值（极限值/临界值）

第二步：将旧数组内容 复制到 新数组 当中（扩容的本质是 新数组替代旧数组）

注意：在对链表进行拆分的时候，会分为两个链表，因为数组扩容后长度是原来的二倍，元素在数组中下标的计算方式为：元素的hash值对数组的长度-1做与操作，数组长度发生变化，元素在数组中下标位置也可能发生变化

三.源码分析

    final Node<K,V>[] resize() {
        // 成员变量的table赋值给oldTab，就是将扩容前的table赋值给oldTab
        Node<K,V>[] oldTab = table;
        // 记录Map当前的容量
        // 如果当前数组等于null长度返回0，否则返回当前数组的长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
     	//当前数组阈值
        int oldThr = threshold;
        // 声明两个变量，用来记录新的容量和阈值
        int newCap, newThr = 0;
        // 若当前容量不为0，表示存储数据的数组已经被初始化过
        if (oldCap > 0) {
            // 判断当前容量是否超过了允许的最大容量
            if (oldCap >= MAXIMUM_CAPACITY) {
            // 若超过最大容量，表示无法再进行扩容
            // 则更新当前的阈值为int的最大值，并返回旧数组
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 将旧容量*2得到新容量，若新容量未超过最大容量值，并且旧容量大于默认初始容量（16），才则将旧阈值*2得到新阈值
            // 在以前的扩容阀值的基础上翻倍，假如以前的数组长度16 扩容阀值为 16*0.75=12
            // 扩容新的容量为之前的容量的2倍newCap = oldCap << 1 左移一位 原来的大小为 16 扩容以后位32  以此类推
            // 新的扩容阀值也为原来的2倍 newThr = oldThr << 1; 左移动1位  原来的扩容阀值为12 现在的阀值为24  以此类推
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
            //将数组长度左移一位(翻倍) 新数组阈值变为之前的一倍
                newThr = oldThr << 1; // double threshold
        }
           // 若不满足上面的oldCap > 0，表示数组还未初始化，
           // 若当前阈值不为0，就将数组的新容量记录为当前的阈值；
           // 为什么这里的oldThr在未初始化数组的时候就有值呢？
           // 这是因为HashMap有两个带参构造器，可以指定初始容量，
           // 若你调用了这两个可以指定初始容量的构造器，
           // 这两个构造器就会将阈值记录为第一个大于等于你指定容量，且满足2^n的数（可以看看这两个构造器）
        else if (oldThr > 0) // initial capacity was placed in threshold
            //将老数组的阈值赋值给新数组
            newCap = oldThr;
            // 若上面的条件都不满足，表示你是调用默认构造器创建的HashMap，且还没有初始化table数组
        else {               // zero initial threshold signifies using defaults
              // 则将新容量更新为默认初始容量（16）
              // 阈值即为（容量*负载因子）12
              // 初始化容量会走这个
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
       // 经过上面的步骤后，newCap一定有值，但是若运行的是上面的第二个分支时，newThr还是0
       // 所以若当前newThr还是0，则计算出它的值（容量*负载因子）
        if (newThr == 0) {
             // 再次扩容的阀值
             float ft = (float)newCap * loadFactor;
           // 获取新的阀值，小于最大容量就为上面计算的扩容阀值，否则为Integer.MAX_VALUE
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        // 将计算出的新阈值更新到成员变量threshold上
        // 第一次添加的时候初始化threshold = newThr = 12
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
       // 创建一个记录新数组用来存HashMap中的元素，容量为新的容量newCap
       // 若数组不是第一次初始化，则这里就是创建了一个两倍大小的新数组
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
       // 将新的的数组赋值给成员变量table
        table = newTab;
       // 判断旧数组是否等于空,不等于null开始将原来的数据加入到新数组中
        if (oldTab != null) {
       // 遍历原数组。把每个bucket都移动到新的bucket中，遍历旧的哈希表的每个桶，重新计算桶里元素的新位置
            for (int j = 0; j < oldCap; ++j) {                
                Node<K,V> e;
              // 若原数组的j位置有节点存在，才进一步操作
                if ((e = oldTab[j]) != null) {
                     // 清除旧数组对节点的引用,方便垃圾回收
                    oldTab[j] = null;
                    // 若table数组的j位置只有一个节点，则直接将这个节点放入新数组，位置可能在新的之前的位置也肯能在旧的容量加上旧的位置
                    // 使用 & 替代 % 计算出余数，即下标
                    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
                        // 创建两个头尾节点，表示两条链表
                        // 因为旧链表上的元素放入新数组中，最多将变成两条链表
                        //loHead,loTail分别代表 **不需要移动** 的 **链头** 和 **链尾**
                        Node<K,V> loHead = null, loTail = null;
                        //hiHead ,hiTail 分别代表 **需要移动** 的 **链头** 和 **链尾**
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        //循环确定原链表中每一个元素的去向，分两种情况：
                        //（1）要么是新索引 = 原索引 ;
                        //（2）要么是新索引 = 原索引 + 旧容量 ;
                        //因为newCap-1比oldCap-1只是多了一位1，然后通过和hash算法返回值与运算
                        //返回索引值，将当前元素存入对应的下标(对应的链表中)。
                        //再次与hash返回值与运算的时候，决定元素去留的只是最高位与运算的结果。
                        do {
                            // 记录当前节点的下一个节点
                            next = e.next;
                            // 注意：e.hash & oldCap这一步就是前面说的判断多出的这一位是否为1
                            // 若与原容量做与运算，结果为0，表示将这个节点放入到新数组中，下标不变
                            if ((e.hash & oldCap) == 0) {//jdk1.8 :尾插法                   
                                 // 若这是不变链表的第一个节点，用loHead记录
                                if (loTail == null)//链尾为空==>首次插入，将链尾指向e
                                    loHead = e;
                                 // 否则，将它加入下标不变链表的尾部 
                                else
                                  //链尾有元素，链尾的next指向e，当有多个元素时候，while()完成链表的追加。
                                    loTail.next = e;
                                 // 更新尾部指针指向新加入的节点 
                                loTail = e;
                            }
                              // 若与原容量做与运算，结果为1，表示将这个节点放入到新数组中，下标将改变
                            else {
                                // 若这是改变下标链表的第一个节点，用hiHead记录
                                if (hiTail == null)
                                    hiHead = e;
                                // 否则，将它加入改变下标链表的尾部  
                                else                           
                                    hiTail.next = e;
                                 // 更新尾部指针指向新加入的节点 
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                         //将不需要移动的链表拼接到与旧数组相同的索引（下标）位置
                        if (loTail != null) {
                             // 将这条链表的最后一个节点的next指向null
                            loTail.next = null;
                             // 同时将其放入新数组的相同位置
                            newTab[j] = loHead;
                        }
                         //将需要移动的链表拼接到新索引(旧索引+旧容量oldCap)位置
                        if (hiTail != null) {                          
                            hiTail.next = null;
                              // 这条链表放入的位置要在原来的基础上加上oldCap
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }      
     	//将新数组返回
        return newTab;
    }

四.图解