hashmap扩容机制

前言：

• hashmap默认容量大小是16，可以自定义大小。默认为2的幂次方。位运算机制效率远大于求余计算。同时只有为2的幂次才能满足求于和位运算得到的结果一样。
  hashmap默认DEFAULT_LOAD_FACTOR为0.75，根据空间和时间的因数情况下选取的0.75
  hashmap在jdk1.8中转化为红黑树的条件链表长度为8的时候，且数组长度为64（不为64时候进行扩容，扩容可能将链表进行拆分）
  hashmap转化为红黑树采用泊松分布的概率学统计，冲突达到8的时候的概率是很低，因此是选择8

hashmap中的resize()方法为扩充源码：
扩充为旧数组大小*2，所以n 的二进制扩容后就是在原来的基础上向左移动了 1为 也就是说 扩容后的 2n-1 的二进制有效位比原来的多一个1 （如：原来n-1的二进制为1111，扩容后则是11111）。所以与相同的hash与计算后，index要么在原来的位置 或 原来位置+原来的容量值

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table; //当前table
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold; //当前阈值 默认16*0.75 = 12
    int newCap, newThr = 0;
    if (oldCap > 0) {
    	// 超过最大值就不再扩充了
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 计算新的容量和新的临界值    分别左移 1 位
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; //新的边界值= 旧的边界值 * 2
    } else if (oldThr > 0) //map创建后第一次扩容，老阈值赋值给新的数组长度
    	//oldThr = threshold  = this.threshold = tableSizeFor(initialCapacity); 
    	//初始化时计算的这个值就等于容量，并不是容量 * 0.75
        newCap = oldThr; 
    else {  // 直接使用默认值，调用无参构造， oldThr 为0 ，设置默认的容量和阈值
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 计算新的resize最大上限
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    // 根据扩容后的参数，创建新的数组并赋值
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
        	// 遍历hash表中的每一个桶，重新计算桶中元素的新位置
            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)
                	// 红黑处理逻辑，调用split()把树拆分开
                    ((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;
                        //判断扩容后的位置是在原来位置还是需要+旧数组容量
                        // (e.hash & oldCap) = 0 为true ，e这个节点在resize后不需要移动位置
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        // 原索引+oldCap
                        } else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab; //返回新的table
}

split() 方法说明, ((TreeNode<K,V>)e).split(this, newTab, j, oldCap)

 /** 
  * map 需要扩容的hashmap
  * tab 新创建的数组
  * index 旧数组的索引
  * bit 就数组的容量
  */
  final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
            //做个赋值，因为这里是((TreeNode<K,V>)e)这个对象调用split()方法，所以this就是指(TreeNode<K,V>)e对象，所以才能类型对应赋值
            TreeNode<K,V> b = this;
            //设置低位首节点和低位尾节点
            TreeNode<K,V> loHead = null, loTail = null;
            //设置高位首节点和高位尾节点
            TreeNode<K,V> hiHead = null, hiTail = null;
            //定义两个变量lc和hc，初始值为0，后面比较要用，他们的大小决定了红黑树是否要转回链表
            int lc = 0, hc = 0;
            //这个for循环就是对从e节点开始对整个红黑树做遍历
            for (TreeNode<K,V> e = b, next; e != null; e = next) {
                //取e的下一节点赋值给next遍历
                next = (TreeNode<K,V>)e.next;
                //取好e的下一节点后，把它赋值为空，方便GC回收
                e.next = null;
                //以下的操作就是做个按位与运算，按照结果拉出两条链表，具体的操作可以参考这篇博客@2
                if ((e.hash & bit) == 0) {
                    if ((e.prev = loTail) == null)
                        loHead = e;
                    else
                        loTail.next = e;
                    loTail = e;
                    //做个计数，看下拉出低位链表下会有几个元素
                    ++lc;
                }
                else {
                    if ((e.prev = hiTail) == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                    //做个计数，看下拉出高位链表下会有几个元素
                    ++hc;
                }
            }
            //如果低位链表首节点不为null，说明有这个链表存在
            if (loHead != null) {
                //如果链表下的元素小于等于6
                if (lc <= UNTREEIFY_THRESHOLD)
                    //那就从红黑树转链表了，低位链表，迁移到新数组中下标不变，还是等于原数组到下标
                    tab[index] = loHead.untreeify(map);
                else {
                    //低位链表，迁移到新数组中下标不变，还是等于原数组到下标，把低位链表整个拉到这个下标下，做个赋值
                    tab[index] = loHead;
                    //如果高位首节点不为空，说明原来的红黑树已经被拆分成两个链表了
                    if (hiHead != null)
                        //那么就需要构建新的红黑树了
                        loHead.treeify(tab);
                }
            }
            //如果高位链表首节点不为null，说明有这个链表存在
            if (hiHead != null) {
                 //如果链表下的元素小于等于6
                if (hc <= UNTREEIFY_THRESHOLD)
                    //那就从红黑树转链表了，高位链表，迁移到新数组中的下标=【旧数组+旧数组长度】
                    tab[index + bit] = hiHead.untreeify(map);
                else {
                    //高位链表，迁移到新数组中的下标=【旧数组+旧数组长度】，把高位链表整个拉到这个新下标下，做赋值
                    tab[index + bit] = hiHead;
                    如果低位首节点不为空，说明原来的红黑树已经被拆分成两个链表了
                    if (loHead != null)
                        //那么就需要构建新的红黑树了
                        hiHead.treeify(tab);
                }
            }
        }