Map<String, String> m3 = new HashMap<>(3); 申请了多大的数组空间

1、先看结果

        Map<String, String> m0 = new HashMap<>(0);// 不创建内部存储数组
        m0.put("k","v");// 内部空间开辟了 1 （数组长度=1）
        Map<String, String> m1 = new HashMap<>(1);// 不创建内部存储数组
        m1.put("k","v");// 内部空间开辟了 1 （数组长度=1）
        Map<String, String> m2 = new HashMap<>(2);// 不创建内部存储数组
        m2.put("k","v");// 内部空间开辟了 2 （数组长度=2）
        Map<String, String> m3 = new HashMap<>(3);// 不创建内部存储数组
        m3.put("k","v");// 内部空间开辟了 4 （数组长度=4）

首先，我们应该知道HashMap内部是用数组存储数据的。

没错，下面这句话，是不创建数组的，所以结论是 0

 Map<String, String> m3 = new HashMap<>(3); 

2、为什么是0？

new HashMap<>(3) 只是设置了threshold（扩容阈值）和loadFactor 加载因子，请看代码

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        this.loadFactor = loadFactor;
        threshold = initialCapacity;
        init();
    }

3、什么时候创建数组？

只有调用put的方法的时候才真正的创建数组，具体创建多大的数组呢？从上面的代码可以看出m3 创建了 长度=4的数组

    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold); // 这句话会去创建数组
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

4、数组的长度为什么不是3？

k=数组长度-1，因为要保证k这个值的二进制全是1，所以new HashMap(3)，实际数组长度=4，这样k=3，k的二进制值：11

如果new HashMap(5)，内部数组长度=8， k=7,k的二进制：111

    private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
        int capacity = roundUpToPowerOf2(toSize); // 这句话保证了k（k=数组长度capacity-1）的二进制值全是1

        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

5、分析roundUpToPowerOf2方法

    private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

p = number-1 ,然后左移一位p<<1, Integer.highestOneBit(p)，获取最高位，其他位都是0

例子：number=3,p=（二级制0010），p左移一位等于4（二级制0100），然后获取最高位的结果是4（二级制100）

 number=6,p=5（二级制0101），p左移一位等于10（二级制1010），然后获取最高位的结果是8（二级制1000）

这样就可以的结果就可以保证k的二级制都是1了

6、为什么要保证k的二进制全是1？

    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }

因为要根据hash 值来索引，当前数据存放在哪个下标数组里，同时还不能越界，如上代码，把hash和length-1 进行一下与操作，就能找到该数据存放的下标，同时还不越界。

 

分析的jdk版本jdk7_75

如有不对，请指出！谢谢