. 前言
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 初次扩充为：与负载因子无关；第二次及以后为：与负载因子有关。其详细计算过程需要具体详解。
注：以上均未考虑最大容量时的情况。