概述
本文会介绍HashMap部分源码和一些常见问题。
HashMap中参数介绍
/**默认初始化容量大小*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**最大容量*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**默认负载因子*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**当桶中的链表的长度大于等于8时转为红黑树*/
static final int TREEIFY_THRESHOLD = 8;
/**当红黑树的节点个数小于等于6时转为链表*/
static final int UNTREEIFY_THRESHOLD = 6;
/**当HashMap中存储的元素个数大于64的时候才会进行红黑树转化*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**数组，也就是常说的桶*/
transient Node<K,V>[] table;
/**元素数量*/
transient int size;
/**当元素数量达到多少时开始扩容*/
int threshold;
/**负载因子*/
final float loadFactor;
HashMap中链表节点介绍
static class Node<K,V> implements Map.Entry<K,V> {
//hash值
final int hash;
final K key;
V value;
//下一个节点
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
HashMap中红黑树节点介绍
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
是一个双向的链表结构。
HashMap插入元素分析
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<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
//如果数组没有初始化，进行初始化
n = (tab = resize()).length;
//如果桶当前位置为null，直接插入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//发生了hash冲突，记录下来，之后会更新value值
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果是红黑树，另一个处理方式
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)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;
}
}
//e不为null，说明桶中存在这个key，更新value值
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;
}
HashMap扩容分析
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;
@SuppressWarnings({"rawtypes","unchecked"})
//初始化扩容之后的数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//如果数组已经初始化，扩容之后重新确定元素在新桶中的位置
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果桶的位置只有一个元素，直接计算该元素在新桶的位置，进行插入
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//红黑树的处理
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//链表的处理
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//这里就是Java8中的优化的地方，将链表分为两个链表，第一部分的链表放入原来的位置
//第二部链表放入原位置 + 原来的容量
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
Java7中采用头插法为什么可能会造成死循环
代码如下
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(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
//遍历旧数组
for (Entry<K,V> e : table) {
//把桶中的链表遍历，放到新数组中
//步骤如下：1.确定元素在新数组中的位置 2.将旧桶中的元素放入新桶相应位置，并且作为新桶链表的第一个元素
while(null != e) {
//记录下当前节点的下一个节点
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//确定元素在新桶的位置
int i = indexFor(e.hash, newCapacity);
//将新桶中的相应位置链表中的第一个元素作为当前元素的下一个节点
e.next = newTable[i];
//将当前元素作为新桶的对应位置的第一个元素
newTable[i] = e;
e = next;
}
}
}
下面的分析主要基于这篇文章
1.假设HashMap的初始容量是4，负载因子是0.75，并且已经插入a,b,c三个元素，而且这三个元素刚好发生了hash冲突，如下图
2.由于负载因子是0.75，再插入一个新的元素就会发生扩容，扩容之后的容量是8，现假设有两个线程在同时插入，假设这两个线程同时发生了扩容，并且假设线程2，执行了如下代码，CPU时间片用完，发生了上下文切换
Entry<K,V> next = e.next;
线程1则正常执行，线程1执行完之后的结果如下：
注意，因为是头插法，所以大家可以发现元素的顺序发生了颠倒，到目前为止一切看起来还是正常的。
3.线程2又开始继续执行了，这时注意，节点a的next为null（因为a.next = newTable[i],新数组刚开始i的位置没有值，所以newTable[i] = null）,因为已经被线程1更改了，不再是节点b。但是由于刚刚线程2执行了如下代码：
Entry<K,V> next = e.next;
这时e 为a节点，next为b节点，经过一轮循环之后，结果如下
这时，再执行一轮循环，结果如下：
因为采用的是头插法，所以a又跑到b的前面了，此时由于next = null，所以循环终止了，最终的结果就变成了这样。变成这样有什么影响呢？首先目前创建了两个数组，最后肯定只能使用其中的一个作为最终的结果数组，如果选择了线程2创建的数组，那节点c就丢失了。
先假设最后选用的是线程1创建的新数组，在上面引用的文章中说，如果这时执行get()方法就会发生死循环，其实不一定，有环不一定就会死循环，比如我要get的值是a,b,c中其中一个，其实是没有问题，可以正常返回，除非get了一个根据hash值确定桶的位置刚刚好就是7，而且又不是a,b,c，这时候就会发生死循环，一直寻找下去。
HashMap的负载因子为什么0.75
如果负载因子设置过大，比如1，空间利用率是很高，但是发生hash冲突的几率会提高很多，一旦发生hash冲突，就需要转化为链表或者红黑树之类的，这就会增加查询和插入的时间。而如果负载因子设置的过低，比如0.5，虽然发生的冲突的概率降低，查询和插入效率变高，但是空间利用率太低，所以0.75是一个空间利用率和查询或者插入效率一个平衡问题。
由于容器中的节点出现的频率遵循泊松分布，当负载因子是0.75时，某个桶发生hash碰撞为8的概率0.00000006，也就是说，需要转化为红黑树的概率是非常低的。
HashMap发生hash冲突为什么先使用链表，之后使用红黑树
链表的查询时间复杂度是O(N)，插入时间复杂度为O(1)。红黑树的查询和插入和删除时间复杂度是O(log(n))。
HashMap中当链表长度大于等于8的时候转化为红黑树，当长度小于等于6的时候转化为链表，这么做的原因是，当链表长度比较短的时候，虽然查询上效率不如红黑树，但是由于元素个数本来就很少，其实影响不大，但是插入却很快，而当长度大于等于8的时候，红黑树的查询就很快了，所以这个数字其实是一个折中的方案，而且红黑树的实现要比链表复杂太多。
这里还有一个问题，为什么搞了一个6，一个8，为什么不直接大于等于8就树化，小于8就链表？原因是为了搞一个缓冲，防止链表和树切换过于频繁。
当链表长度大于8时，一定会树化吗
不一定，如果HashMap的长度小于64，当数组长度大于等于8的时候是不会树化的，而是进行扩容，树化的代码如下：
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//如果长度小于64，直接扩容，并不会树化
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
HashMap默认初始化长度为什么是16，为什么每次扩容2倍
1.首先，如果初始化长度过小，需要经常扩容，很麻烦，如果初始化过大，会浪费空间，所以初始化16。
2.初始化是16，每次扩容两倍，当进行桶的位置确定的时候，采用如下代码
//n为HashMap的容量 (n - 1) & hash
初始容量为16，那n - 1 = 15,其二进制表示为：
0000 1111
在进行&运算的时候，只要key的hash值的二进制的后面4位是均匀的，就可以保证均匀的分布在不同的桶中，下面就举一个反例来说明，如果不为2的幂次方可能会导致什么问题。
I：现假设初始长度位10，那n - 1 = 9，其二进制为如下：
0000 1001
II:现假设有key1,key2,key3...其hash值如下
key1：0000 1111 key2：0000 1101 key3：0000 1011
III：从II中可以看出，这三个key的hash值分布还是ok的，但是当和9进行与运算的时候，就发生了hash冲突，所以这就是为什么容量要是2的幂次方的原因。
Java7采用头插法，Java8为什么采用尾插法
这个就是上面介绍的Java7在多线程并发插入，扩容的之后，再进行get操作会发生死循环的问题，根本原因是采用头插法改变了原来的顺序，而采用尾插法不会更改顺序，所以不会有这个死循环的问题。
HashMap的遍历方法
常用的其实就是通过keySet和entrySet进行遍历，这两个都是HashMap中的内部类，前者会返回HashMap的key的集合，然后有了key，再调用get()方法获取value，而entrySet不同，Map接口中有一个内部接口Entry接口，这个接口可以获取到key,value,因为HashMap中的node节点实现了这个接口，代码如下：
static class Node<K,V> implements Map.Entry<K,V> {
//hash值
final int hash;
final K key;
V value;
//下一个节点
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
所以通过entrySet遍历效率是最高的，遍历的代码参考这篇文章，这里特别说明一点就是EntrySet中的迭代器，这个迭代器会遍历HashMap中的每一个桶，并且把每个桶中的值都遍历一遍。