HashMap的容量大小增长原理(JDK1.6/1.7/1.8)
. 前言
HashMap的容量大小会根据其存储数据的数量多少而自动扩充,即当HashMap存储数据的数量到达一个阈值(threshold)时,再往里面增加数据,便可能会扩充HashMap的容量。
可能?
事实上,由于JDK版本的不同,其阈值(threshold)的默认大小也变得不同(主要是计算公式的改变),甚至连判断条件也变得不一样,所以如果说threshold = capacity * loadFactor(容量 * 负载因子)将不再绝对正确,甚至说超过阈值容量就会增长也不再绝对正确,下面就以JDK1.6、1.7、1.8中的源码说明。
注:本文无图,标题仅是为了与前一篇文字标题符合
2. JDK 1.6
JDK 1.6中HashMap构造函数源码如下(其中以Mark开头注释以及中文注释,非JDK源码中注释,下同):
public HashMap(int initialCapacity, float loadFactor) {
// Mark A Begin
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);
// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
// Mark A End
this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor); // 计算阈值,重点在这句代码
table = new Entry[capacity];
init();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
其中,代码片段A(Mark A Begin - Mark A End,下同)处可以先忽略,主要的是
threshold = (int)(capacity * loadFactor);
- 1
这边是阈值的计算公式,其中capacity(容量) 的缺省值为16,loadFactor(负载因子)缺省值为0.75,那么
threshold = (int)(16 * 0.75) = 12
- 1
再来看addEntry函数(put(K, V)方法最后通过此函数插入数据,具体参见【图解JDK源码】HashMap的基本原理与它的线程安全性):
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold) // 判断是否扩充容量
resize(2 * table.length);
}
- 1
- 2
- 3
- 4
- 5
- 6
可以看见,只要当前数量大于或等于阈值,便会扩充HashMap的容量为其当前容量的2倍。这是在JDK 1.6下的特性。
3. JDK 1.7
JDK1.7中HashMap构造函数源码如下:
public HashMap(int initialCapacity, float loadFactor) {
// Mark A Begin
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);
// Mark A End
this.loadFactor = loadFactor;
threshold = initialCapacity; // 计算阈值,重点在这句代码
init();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
同样的,代码片段A可以先忽略,那么对么上面代码,可以看出,阈值的计算与JDK 1.6中完全不同,它与合约因子无关,而是直接使用了初始大小作为阈值的大小,但是这仅是针对第一次改变大小前,因为在resize函数(改变容量大小的函数,扩充容量便是调用此函数)中,有如下代码:
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
- 1
也即是说,在改变一次大小后,threshold的值仍然跟负载因子相关,与JDK 1.6中的计算方式相差无几(未讨论容量到达最大值1,073,741,824 时的情况)。
而addEntry函数也与JDK 1.6中有所不同,其源码如下:
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) { // 判断语句发生了改变
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
从上面的代码可以看出,在JDK 1.6中,判断是否扩充大小是直接判断当前数量是否大于或等于阈值,而JDK 1.7中可以看出,其判断是否要扩充大小除了判断当前数量是否大于等于阈值,同时也必须保证当前数据要插入的桶不能为空(桶的详细可参见【图解JDK源码】HashMap的基本原理与它的线程安全性)。那么JDK 1.8中又是如何呢?
3. JDK 1.8
说明:JDK 1.8对于HashMap的实现,新增了红黑树的特点,所以其底层实现原理变得不一样,再此不讨论。
JDK 1.8中HashMap构造函数源码如下:
public HashMap(int initialCapacity, float loadFactor) {
// Mark A Begin
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);
// Mark A End
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity); // 计算阈值
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
这里使用到了tableSizeFor方法,其源码如下:
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;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
因为使用了位运算,所以这个方法可能不能明确的知道结果,但是只要知道不管输入什么值,它的最后结果都会是0,1,2,4,8,16,32,68… 这些数字中的一个就对了(其实是有规律的),对于以下输入值有:
tableSizeFor(16) = 16
tableSizeFor(32) = 32
tableSizeFor(48) = 64
tableSizeFor(64) = 64
tableSizeFor(80) = 128
tableSizeFor(96) = 128
tableSizeFor(112) = 128
tableSizeFor(128) = 128
tableSizeFor(144) = 256
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
也即是说,对于容量的初始值16来说,其初始阈值便是16,与JDK 1.7中初始阈值相同,而其resize函数中,threshold的计算源码如下:
final Node<K,V>[] resize() {
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)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
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
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
计算变得更复杂,因为其底层实现原理已经不仅仅是像之前的JDK中数组加链表那样简单,但是仍然可以看见其阈值的计算是与负载因子相关的。
而其判断是否要扩充的语句在putVal函数内(put方法会调用),其源码如下:
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
// 代码太多,省略
++modCount;
if (++size > threshold) // 判断是否扩充语句
resize();
afterNodeInsertion(evict);
return null;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
可以看见,其判断是否达到阈值与JDK 1.6是相同的,而没有像JDK 1.7中那样判断桶是否不为空。
总结
JDK 1.6 当数量大于容量 * 负载因子即会扩充容量。
JDK 1.7 初次扩充为:当数量大于容量时扩充;第二次及以后为:当数量大于容量 * 负载因子时扩充。
JDK 1.8 初次扩充为:与负载因子无关;第二次及以后为:与负载因子有关。其详细计算过程需要具体详解。
注:以上均未考虑最大容量时的情况。