HashMap源码解析之resize方法

resize函数

因为HashMap的构造函数 并不会给内部的表开辟空间
而是在调用put函数时 如果表为空 调用resize方法
换句话说 resize函数不得不 考虑 任何不同形式的构造函数 及带一参 带两参 不带参的构造函数 调用resize方法
并且 当表中的数量 超过临界值时 也会调用resize方法
所以整个 大概思路

1. 旧表保存下来
2. 定义并赋值 旧表的长度 临界值 如果旧表为空则长度为0
3. 定义新表长度 新表临界值
4. 如果旧表中有元素
   • 4.1 判断是否达最大长度 到达则无需再散列
   • 4.2 否则 可以再散列
     • 4.2.1 给新表长度和临界值赋值 分别都是是旧表的2倍
5. 如果旧表中 没有元素 并且 旧表有临界值 那么 就是这种构造函数调用的 new HashMap(50); 所以要将 newCap=oldThr;
6. 否则 在表为空 又没有临界值 指定新表的长度和临界值
7. 如果newThr还没被指定吗 如果没有 则指定 也就是说在旧表有指定临界值时的时候调用
8. 前期值的赋值准备做好了就可以再散列了

如何再散列

大概思路

1. 如果表中的节点是树节点 则直接调用 splite (下篇讲)
2. 如果不是树节点 也就是 普通的节点
   这里有个很有意思的地方 e.hash & oldCap
   这是为什么呢
   根据源码表示的是链表中的每一个元素都要再散列 为什么都要再散列
   首先必须明确的是 键存放在哪个桶中取决于他的hash值
   并且存放在同一个桶中的hash值不一定相等 比如 长度为16 hash为5的元素hash为21的元素
   都会在同一个桶中 通过 e.hash & oldCap就可以为元素分类了

如果e.hash是oldCap的奇数倍 则结果为oldCap 89是16的奇数倍 89/16=5 所以89 & 16 为16 如果e.hssh是oldCap的偶数倍 则结果为0 70/16=4 所以70 & 16 为0 也就是说任何hash值要么为0要么为oldCap即不为0 为0的由low负责不为0的由hight负责
如果为hight则将其分配在tab[j+oldCap]中

以下是具体的源码注释

    final Node<K,V>[] resize() {
        //threshold表示要调整大小的下一个值
        //将之前的table 保存起来
        Node<K,V>[] oldTab = table;
        //旧表长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //旧的临界值  此时threshold已经在构造函数中完成了初始化
        int oldThr = threshold;
        //新表长度 新表的要调整的下一个值
        int newCap, newThr = 0;
        if (oldCap > 0) {
            //如果旧表长度大于最大容量 简而言之 太长了
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                //不能增加长度
                //返回原始表
                return oldTab;
            }
            //如果旧表的长度大于16 才需要计算临界值(threshold)
            //put的
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold 这里是旧的阈值的两倍
        }
        //在oldTab为null的情况下 如果 oldThr>0 说明有指定初始容量
        else if (oldThr > 0) // initial capacity was placed in threshold 将新表容量设为初始值的临界值
            newCap = oldThr;
        //在表为空 又没有临界值 指定新表的长度和临界值
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //newThr还没被指定吗 如果没有 则指定 也就是说在旧表有指定临界值时的时候调用
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            //确定新的临界值
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @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;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //如果这个桶中只有一个元素
                    if (e.next == null)
                        //e.hash & 最大索引 & 只有存在两个一则为一  0 和本身
                        //再散列
                        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;
                        //loHead 为 lowHead
                        //loTail 为 lowTail
                        Node<K,V> hiHead = null, hiTail = null;
                        //hiHead 为 hightHead
                        Node<K,V> next;
                        //遍历每个节点
                        do {
                            next = e.next;

                            if ((e.hash & oldCap) == 0) {
                                //头结点
                                if (loTail == null)
                                    loHead = e;
                                else
                                //尾巴的下一个节点
                                    loTail.next = e;
                                //跟新尾节点
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                //尾巴
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        //链表的最后一个设为null
                        if (loTail != null) {
                            loTail.next = null;
                            //映射链表
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

如有具体错误还需大佬们指正

原文地址：https://www.cnblogs.com/rorchachl/p/12288312.html