hashmap 扩容是元素还是数组_HashMap工作原理和扩容机制

什么是哈希表

数组的特点是：寻址容易，插入和删除困难；而链表的特点是：寻址困难，插入和删除容易。

那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为“链表的数组”。

HashMap工作原理

HashMap内部是通过 数组 + 链表 的结构实现的，每个数组单元中存放着一个单链表的头结点，其中每个结点是一个Node对象，Node对象包含了Key-Value键值对，还有一个Node next指向链表中下一个结点。 HashMap采用拉链法解决哈希冲突。

static class Node implements Map.Entry {

final int hash;

final K key;

V value;

Node next;

Node(int hash, K key, V value, Node next) {

this.hash = hash;

this.key = key;

this.value = value;

this.next = next;

}

}

HashMap是如何通过key来计算索引的呢

首先计算key的hashcode，再对hashcode进行二次hash，然后再对数组的长度进行取模

static final int hash(Object key) {

int h;

return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

}

在getNode方法里 对数组长度取并，作用上相当于取模或取%

first = tab[(n - 1) & hash]

HashMap提供两个重要的基本操作，put(K, V)和get(K)

get(K)

public V get(Object key) {

Node e;

return (e = getNode(hash(key), key)) == null ? null : e.value;

}

final Node getNode(int hash, Object key) {

Node[] tab; Node first, e; int n; K k;

if ((tab = table) != null && (n = tab.length) > 0 &&

(first = tab[(n - 1) & hash]) != null) {

if (first.hash == hash && // always check first node

((k = first.key) == key || (key != null && key.equals(k))))

return first;

if ((e = first.next) != null) {

if (first instanceof TreeNode)

return ((TreeNode)first).getTreeNode(hash, key);

do {

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

return e;

} while ((e = e.next) != null);

}

}

return null;

}

从getNode方法可以看出 如果第一个结点不为null 先判断第一个结点 如果hash值和key相等就返回第一个解点，否则，判断是否是红黑树，是则按照红黑树查询，否则，while循环遍历该数组位置下对应的链表 找到对应的hash值和key相等的结点，如果没有就返回null

put(K, V)

首先通过resize()初始化数组或双培扩容

根据key计算出数组下标索引，定位到数组元素，如果第一个结点为null,则说明没有链表，则直接new一个新Node结点插入数组，如果第一个结点不为null，则判断第一个结点是不是要更新的结点，如果是就更新，否则再判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向下面； 遍历链表，p.next是否为null，是则new一个新结点，p.next指向这个新结点，否则判断是否是要找的结点，是则跳出循环，否则继续遍历

public V put(K key, V value) {

return putVal(hash(key), key, value, false, true);

}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

boolean evict) {

Node[] tab; Node p; int n, i;

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length;

if ((p = tab[i = (n - 1) & hash]) == null)

tab[i] = newNode(hash, key, value, null);

else {

Node e; K k;

if (p.hash == hash &&

((k = p.key) == key || (key != null && key.equals(k))))

e = p;

else if (p instanceof TreeNode)

e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);

else {

for (int binCount = 0; ; ++binCount) {

if ((e = p.next) == null) {

p.next = newNode(hash, key, value, null);

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

treeifyBin(tab, hash);

break;

}

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

break;

p = e;

}

}

if (e != null) { // existing mapping for key

V oldValue = e.value;

if (!onlyIfAbsent || oldValue == null)

e.value = value;

afterNodeAccess(e);

return oldValue;

}

}

++modCount;

if (++size > threshold)

resize();

afterNodeInsertion(evict);

return null;

}

Java8的性能改善

这里存在一个问题，即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响HashMap的性能。于是，在JDK1.8版本中，对数据结构做了进一步的优化，引入了红黑树。而当链表长度太长(默认超过8)时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。

当插入新元素时，对于红黑树的判断如下：

判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向下面；

遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；

HashMap扩容机制

什么时候扩容：当向容器添加元素的时候，会判断当前容器的元素个数，如果大于等于阈值---即当前数组的长度乘以加载因子的值的时候，就要自动扩容啦。

扩容(resize)就是重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。

我们分析下resize的源码，鉴于JDK1.8融入了红黑树，较复杂，为了便于理解我们仍然使用JDK1.7的代码，好理解一些，本质上区别不大。

void resize(int newCapacity) { //传入新的容量

Entry[] oldTable = table; //引用扩容前的Entry数组

int oldCapacity = oldTable.length;

if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了

threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了

return;

}

Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组

transfer(newTable); //！！将数据转移到新的Entry数组里

table = newTable; //HashMap的table属性引用新的Entry数组

threshold = (int) (newCapacity * loadFactor);//修改阈值

}