对 JDK1.8 HashMap#resize() 中的 oldCap ＞= DEFAULT_INITIAL_CAPACITY 判断的意义分析

先看HashMap#resize() 中的newCap与newThr的计算代码。

        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 当已经初始化过了
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY) //（1）
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0)  // 未初始化但已经有cap的初始值 （2）
            newCap = oldThr;
        else { // 未初始化且无cap的初始值，那么采用默认值
            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;

当时对情况（1）中的oldCap >= DEFAULT_INITIAL_CAPACITY很疑惑，为何要加这个看似多余的限制条件。
即，当 oldCap < DEFAULT_INITIAL_CAPACITY 采用(int) (newCap * loadFactor)作为newThr，而不是直接使用oldThr << 1作为newThr。

但仔细想想其实 newThr = oldThr << 1的计算并不是绝对精确的，因为如果基于threshold = (int) (capacity * loadFactor)的计算规则，(int) (newCapacity * loadFactor) = 2 * ((int) (oldCapacity * loadFactor))并不总是成立的，即newThr并不总是2 * oldThr，会出现newThr = 2 * odlThr + 1 的情况（如 loadFactor = 0.9 时），所以如果想要保证绝对的精确性那就不该采用newThr = oldThr << 1来计算新threshold。

结论

由于 newThr = oldThr << 1 是模糊计算，(int)((float)newCap * loadFactor) 是精确计算。
考虑到精确计算需要一次乘法两次数据类型转换，作者采用先精确计算，等oldThr达到一定精确度时再使用乘2的方式计算，这样就尽可能精确且能省掉计算时间。

一个例子，loadFactor: 0.6，capacity: 2：

capacity, threshold的变化: 2, 1、4,2、8,4、16,9、后面模糊计算32,18、64,36
去掉oldCap >= DEFAULT_INITIAL_CAPACITY时（只有第一次是精确计算）
capacity, threshold的变化: 2,1、后面模糊计算 4,2、8,4、16,8、32,16、64,32