HashMap的初始化创建长度

new HashMap(10) 实际的初始化容量是多少呢?

在业务场景中我们经常写到以下代码

Map<String, String> map = new HashMap<>(10);

点击HashMap 进入源码发现调用的是如下构造器

  public HashMap(int initialCapacity) {
  //	DEFAULT_LOAD_FACTOR 默认负载系数 0.75
  // initialCapacity 初始化容量大小
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

点击源码中的this 方法 发现调用了如下方法

     public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
        // 小于0 报错
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
            //大于最大长度 则将值设置 1 << 30   将1的二进制向左移动30位 经过换算的到的10进制值是 1073741824 二进制 值是 1000000000000000000000000000000
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
            // 小于0或者不是一个float数字报错
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
         // 当前hashMap的加载因子等于传递过来的默认值
        this.loadFactor = loadFactor;
        // 最重要的一步,算出临界点的值
        this.threshold = tableSizeFor(initialCapacity);
    }

点击进入 tableSizeFor(initialCapacity) 方法发现源码如下
将 cap - 1 为了防止数据本来就是2的次方,比如 如果注释 cap-1 那么当传入的参数是2的时候下面代码的执行结果就是 4 那么就会造成容量浪费

 static final int tableSizeFor(int cap) {

        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

“>>>” 无符号向右位移操作 即如 100 >>> 2 直接将数字的二进制转换向右移动2位
1100100 -> 11001 直接舍弃移动后的两位 得到的数据为 25 的到的结果是正数
<< 向左位移操作 同上 如 100 << 2 1100100 向左移动两位在最尾的地方添加2位补0 得到的数据是 0001 1001 0000
如 int num = -100 << 2;得到的结果二进制是
11111111111111111111111001110000 10进制是 -400
“>>” 向右移动 包含负数的结果,二进制的结果包括了补码与反码
具体详见其他博主的文章
‘&’ 10&2 运算则是比较两个数的二进制则 相同位数上都为1 则 保留当前位数值 如下代码所示

    int result=10&3;
        // 1010 10的二进制
        // 0011 3的二进制
        
        // 0010 2的二进制
        String binaryStr = NumberUtil.getBinaryStr(10);
        String binaryStr5 = NumberUtil.getBinaryStr(3);
        System.out.println("10----"+binaryStr);
        System.out.println("5----"+binaryStr5);
        System.out.println("-result--->"+ NumberUtil.getBinaryStr(result));
        System.out.println("---->"+result);

//打印结果
10----1010
3----11
-result--->10
---->2

‘|’ 异或运算符号 比较二进制种相同位的数据,只要有1 就进行保留

 int result=10|3;
        // 1010
        // 0011

        // 1011
        String binaryStr = NumberUtil.getBinaryStr(10);
        String binaryStr3 = NumberUtil.getBinaryStr(3);
        System.out.println("10----"+binaryStr);
        System.out.println("3----"+binaryStr3);
        System.out.println("-result--->"+ NumberUtil.getBinaryStr(result));
        System.out.println("---->"+result);
// 打印结果
10----1010
3----11
-result--->1011
---->11

回顾这些基础知识之后,再回头看源码中的tableSizeFor方法,可以看见
代码中经过多个计算之后,最后的逻辑是,初始化的时候或者存放第一个数据的时候,数组的长度不可能大于 默认的MAXIMUM_CAPACITY 只会得到2的幂次方的一个数据,那么当经过多个 | 运算 且 初始化值大于16 最后的时候,容量扩张数据值都为16 小于该数的时候,则是的到大于初始化值的2的幂次方 如 初始化值为3 ,则返回4 ,5则返回6 等.