HashMap (jdk1.8)resize()方法详细注释

   //hashMap初始化兼扩容
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table; //创建node数组oldTab，并将hashMap的成员数组table 赋值给oldTab;
        int oldCap = (oldTab == null) ? 0 : oldTab.length; //获取oldTab数组的长度，如果直接int oldCap = oldTab.length,当table、oldTab为空是会报空指针
        int oldThr = threshold;     //oldTab数组的扩容临界点；
        int newCap, newThr = 0;     //扩容后新数组的长度和扩容临界点；
        if (oldCap > 0) {           // oldCap > 0 ，说明table、oldTab中有数据
          /*
            如果oldTab长度大于2~30,查过map能存储的最大值，不能再扩容了，
            把扩容临界点的值设置位Integer所能表示的最大值：2~31-1=0x7fffffff
             @Native public static final int   MAX_VALUE = 0x7fffffff;
          * */
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            /*
            * oldCap <2~30，把oldCap右移1位，即oldCap*2 = 16*2 = 32，扩容后数组的长度必须在[16,2~30)区间；
            * */
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold，新的扩容临界点也要改变，等于oldThr*2=12*2 =24
        }
        /*
        * oldCap = 0，说明table、oldTab为空，刚new出来一个hashMap,还没put数据，oldThr > 0，
        * */
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr; //newCap=12，不是2的n次幂？这是什么场景？没想明白
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            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;   //把新的扩容临界点赋值给成员变量threshold
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new HashMap.Node[newCap];  //以newCap=32创建新node数组
        table = newTab;   //把newTab赋值给成员变量table;
        if (oldTab != null) {    //oldTab != null 说明有data，需要把这人data移动到newTab中；
            for (int j = 0; j < oldCap; ++j) {   //循环遍历oldTab中的data
                Node<K,V> e;                     //定义一个node,临时存放oldTab中的元素
                if ((e = oldTab[j]) != null) {   //oldTab当前位置有元素
                    oldTab[j] = null;            //清空oldTab当前位置的元素
                    if (e.next == null)          //oldTab当前元素的下一个节点为空，说明当前元素存储在数组中，不是存储在链表上的
                        /*file:/D:/workSpaces/workspaceIdea/shejimoshi/mvnw
                        * 把当前需要移动位置的元素oldTable[j]赋值给e
                        * 如果e.next的下一个节点为空，说明oldTable[j]只是数组中的一个元素，没有链表节点
                        * 下面将计算当前元素需要挪动到newTable中的位置：
                        * 通过debug看到e.hash的值是10进制，转换为二进制，看最后5位
                        * newCap - 1=32-1=31，转换为二进制：11111；
                        * e.hash & 11111 ,不影响e.hash的原有后5为的值，通过计算出当前需要挪动位置的元素在newTable中的位置；

                        * */
                        newTab[e.hash & (newCap - 1)] = e; //通过e.hash & (newCap - 1)计算出当前元素在newTab中的新的下标，把该位置存放oldTab[j]
                    else if (e instanceof HashMap.TreeNode) //处理红黑树的情况
                        ((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                   /*
                   * e.next ！= null，说明元素是链表上的节点，需要把链表上的各个节点也移动到newTable中
                   * */
                    else { // preserve order   如果当前元素不是存储在数组中，不是红黑树，而是存储在链表节点中的
                        /*
                        * 定义4个node,临时存放链表节点中的元素
                        * 定义循环变量next
                        * */
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;   //把当前节点e指向的下一步节点赋值给循环变量next
                            /*
                            * (e.hash & oldCap) == 0，来判断当前节点元素的下标在newTable中是否需要改变？oldCap=16,对应二进制
                            * ：10000,后4为全部为0，e.hash&0000，计算结果，e.hash 后4为也必定是0，0000能存储0~15个元素，
                            * 说明，当前这个节点在newTable中的0~15位能存储，下标就用原有的下标j.
                            * 如果(e.hash & oldCap) ！= 0，说明0~15位存储不了这个元素，oldCap的第五个元素（从右往左）是1，e.hash
                            * 的对应位置也必定是1，这样才能出现e.hash & oldCap) ！= 0，必定e.hash & oldCap =16，此时需要将该
                            * 元素暂时存放到hiHead中，该元素在newTable中的下标位置[j+16]
                             *链表上有3个以上元素时 loTail和loTail.Next都会被覆盖
                            * */
                            if ((e.hash & oldCap) == 0) {  //当前元素的下标在0~15之间，可以直接用原有的下标；
                                if (loTail == null)   //第一次走这个分支，loTail为空
                                    loHead = e;       //把当前节点赋值给loHead
                                else
                                    loTail.next = e;
                                loTail = e;          //把当前节点也赋值给loTail
                            }
                            else {//当前元素的下标在16~31之间，需要重新计算下标；,链表上有3个以上元素时，必定有一个元素要走hiHead分支
                                if (hiTail == null) //第一次走这个分支，hiTail为空
                                    hiHead = e;  //把当前节点赋值给hiHead
                                else
                                    hiTail.next = e;
                                hiTail = e;   //把当前节点也赋值给hiTail
                            }
                        } while ((e = next) != null);   //next赋值给e，现在e指向下一个节点
                        if (loTail != null) {     //loTail里面存储data
                            loTail.next = null;   //清空loTail，还有loHead存储的和loTail一样
                            newTab[j] = loHead;   //把loHead放到newTab中
                        }
                        if (hiTail != null) { //hiTail里面存储data
                            hiTail.next = null;//清空hiTail，还有hiHead存储的和hiTail一样
                            newTab[j + oldCap] = hiHead; //把hiHead放到newTab中
                        }
                    }
                }
            }
        }
        return newTab;   //返回初始化或扩容之后的新数组newTab；
    }