深刻理解HashMap的扩容机制

——原创：转载请注明出处 http://www.cnblogs.com/yanzige/p/8392142.html

1、何时扩容：

网上总结的会有不少，但大多都总结的不够完整或者不够准确。大多数可能值说了知足我下面条件一的状况。

扩容必须知足两个条件：

一、 存放新值的时候当前已有元素的个数必须大于等于阈值

二、 存放新值的时候当前存放数据发生hash碰撞（当前key计算的hash值换算出来的数组下标位置已经存在值）

 

2、下面咱们看源码，以下：

首先是put()方法

public V put(K key, V value) {
　　　　//判断当前Hashmap(底层是Entry数组)是否存值（是否为空数组）
　　　　if (table == EMPTY_TABLE) {
　　　　　　inflateTable(threshold);//若是为空，则初始化
　　　　}
　　　　
　　　　//判断key是否为空
　　　　if (key == null)
　　　　　　return putForNullKey(value);//hashmap容许key为空
　　　　
　　　　//计算当前key的哈希值　　　　
　　　　int hash = hash(key);
　　　　//经过哈希值和当前数据长度，算出当前key值对应在数组中的存放位置
　　　　int i = indexFor(hash, table.length);
　　　　for (Entry<K,V> e = table[i]; e != null; e = e.next) {
　　　　　　Object k;
　　　　　　//若是计算的哈希位置有值（及hash冲突），且key值同样，则覆盖原值value，并返回原值value
　　　　　　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;
　　}

　　　

在put()方法中有调用addEntry()方法，这个方法里面是具体的存值，在存值以前还有判断是否须要扩容

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);
　　}

　　

若是须要扩容，调用扩容的方法resize()

void resize(int newCapacity) {
　　　　Entry[] oldTable = table;
　　　　int oldCapacity = oldTable.length;
　　　　//判断是否有超出扩容的最大值，若是达到最大值则不进行扩容操做
　　　　if (oldCapacity == MAXIMUM_CAPACITY) {
　　　　　　threshold = Integer.MAX_VALUE;
　　　　　　return;
　　　　}

　　　　Entry[] newTable = new Entry[newCapacity];
　　　　// transfer()方法把原数组中的值放到新数组中
　　　　transfer(newTable, initHashSeedAsNeeded(newCapacity));
　　　　//设置hashmap扩容后为新的数组引用
　　　　table = newTable;
　　　　//设置hashmap扩容新的阈值
　　　　threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
　　}

 

transfer()在实际扩容时候把原来数组中的元素放入新的数组中

void transfer(Entry[] newTable, boolean rehash) {
　　　　int newCapacity = newTable.length;
　　　　for (Entry<K,V> e : table) {
　　　　　　while(null != e) {
　　　　　　　　Entry<K,V> next = e.next;
　　　　　　　　if (rehash) {
　　　　　　　　　　e.hash = null == e.key ? 0 : hash(e.key);
　　　　　　　　}
　　　　　　　　//经过key值的hash值和新数组的大小算出在当前数组中的存放位置
　　　　　　　　int i = indexFor(e.hash, newCapacity);
　　　　　　　　e.next = newTable[i];
　　　　　　　　newTable[i] = e;
　　　　　　　　e = next;
　　　　　　}
　　　　}
　　}

　　

3、总结：

Hashmap的扩容须要知足两个条件：当前数据存储的数量（即size()）大小必须大于等于阈值；当前加入的数据是否发生了hash冲突。

 

由于上面这两个条件，因此存在下面这些状况

（1）、就是hashmap在存值的时候（默认大小为16，负载因子0.75，阈值12），可能达到最后存满16个值的时候，再存入第17个值才会发生扩容现象，由于前16个值，每一个值在底层数组中分别占据一个位置，并无发生hash碰撞。

（2）、固然也有可能存储更多值（超多16个值，最多能够存26个值）都尚未扩容。原理：前11个值所有hash碰撞，存到数组的同一个位置（这时元素个数小于阈值12，不会扩容），后面全部存入的15个值所有分散到数组剩下的15个位置（这时元素个数大于等于阈值，可是每次存入的元素并无发生hash碰撞，因此不会扩容），前面11+15=26，因此在存入第27个值的时候才同时知足上面两个条件，这时候才会发生扩容现象。

 

注：jdk版本1.7