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

如有不对,请指出!谢谢




评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值