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

如有不对，请指出！谢谢