HashMap（jdk1.8） 之 resize() 扩容

1、为什么要扩容

        为了减少 hash碰撞，提高hashMap性能

        （1）达到阈（yu）值扩容

        （2）链表长度大于8，数组长度小于64

2、怎么扩容 代码如下：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
		//老的容器长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
		//老的扩容阈值
        int oldThr = threshold;
		//newCap 新的容器长度，newThr 新的扩容阈值
        int newCap, newThr = 0;
		//判断老的容器长度是否大于0
        if (oldCap > 0) {
			//判断老的容器长度是否大于等于扩容值，如果大于等于赋值最大值
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
			//老的容器长度左移1位，获取到两倍oldCap的newCap(新的容器长度)，
            并且要小于最大容器长度，oldCap要大于等于16
            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;     //默认容器长度16
            //默认阈值：0.75*16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); 

        }
        if (newThr == 0) { //如果阈值为空，重新计算赋值
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;  //赋值新阈（yu）值
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //创建数组
        table = newTab;
        if (oldTab != null) { //把老数组数据，移到扩容后数组
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
				//判断是否为null
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null; //赋值为null 
                    if (e.next == null)  //判断下一个节点是否有元素数值，
                    如果没有，说明没有hash冲突，不是链表，新数组长度减1 
                    和hash值做与运算获取数组下标，直接赋值
                        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; //取子节点
							//判断hash和老的数组长度做与运算，为0说明hash值低位，
                            不为0说明hash值在高位
							/** 假设e.hash 为10
							10：0000 1010
							16：0001 0000
							 &：0000 0000
							 结果为0 为低位
							
							假设e.hash 为26
							26：0001 1010
							16：0001 0000 
							 &：0001 0000
							结果不为0 为高位下标在原来的基础上加oldCap(老容器数组长度)
							**/
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)  // 如果没有尾，说明链表为空
                                    loHead = e;  // 链表为空时，头节点指向该元素
                                else
                                    loTail.next = e; // 如果有尾，那么链表不为空，
                                    把该元素挂到链表的最后。
                                loTail = e; // 把尾节点设置为当前元素
                            }
							
							 // 如果与运算结果不为0，说明hash值大于老数组
                                长度（例如hash值为17）
                            // 此时该元素应该放置到新数组的高位位置上
                            // 例：老数组长度16，那么新数组长度为32，hash为17的应该放置在
                            数组的第17个位置上，也就是下标为16，那么下标为16已经属于高位了，
                            低位是[0-15]，高位是[16-31]
                            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;
                        }
						//数组下标+老数组长度，作为新的数组下标
                        if (hiTail != null) { // 高位的元素组成的链表放置的位置只
                                                是在原有位置上偏移了老数组的长度个位置。
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead; // 例：hash为 17 在老数组放置
                            在0下标，在新数组放置在16下标；    
                            hash为 18 在老数组放置在1下标，在新数组放置在17下标；  
                        }
                    }
                }
            }
        }
        return newTab;
    }