JDK1.8源码分析之HashMap
概述
HashMap是一种Map，HashMap仅是一种Map的实现版本，下面的图片展示了java中Map的一些实现版本：
它具有以下特点：
- HashMap将根据key的hashCode值来找到存储value的位置，如果hash函数比较完美的话，因为可以很快的找到key对应的value存储的位置，所以具有很高的效率。
- HashMap因为是基于key的hashCode值来存储value的，所以遍历HashMap不会保证它的顺序和插入时的顺序一致。
- HashMap是基于哈希表实现的，每一个元素是一个key-value对，其内部通过单链表解决冲突问题，容量不足(超过了阀值)时，同样会自动增长。
- HashMap是非线程安全的，只适用于单线程环境下，多线程环境下可以采用concurrent并发包下的concurrentHashMap，或者Collections.synchronizedMap()方法对Map进行同步，或者使用ReentrantLock重入锁对HashMap的读写操作进行同步。
- HashMap 实现了Serializable接口，因此它支持序列化，实现了Cloneable接口，能被克隆。
- HashMap是基于哈希表的Map接口的非同步实现.此实现提供所有可选的映射操作，并允许使用null值和null键.此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
- Java8中对此类底层实现进行了优化，比如引入了红黑树的结构以解决哈希碰撞。
HashMap的数据结构
在java中，最基本的结构就是两种，一个是数组，另外一个是模拟指针(引用)，所有的数据结构都可以用这两个基本结构来构造，HashMap也不例外。HashMap实际上是一个"链表散列"的数据结构，即数组和链表的结合体。
如图，HashMap的主结构类似于一个数组，添加值时通过key确定储存位置，每个位置是一个Node(图中黑点)的数据结构，该结构可组成链表。当发生冲突时，相同hash值的键值对会组成链表。
这种数组+链表的组合形式大部分情况下都能有不错的性能效果，java6、7就是这样设计的。然而，在极端情况下，一组（比如经过精心设计的）键值对都发生了冲突，这时的哈希结构就会退化成一个链表，使HashMap性能急剧下降。
所以在java8中，HashMap的结构实现变为数组+链表+红黑树。如图：
从上图中可以看出，HashMap底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。
三大集合与迭代子
HashMap使用三大集合和三种迭代子来轮询其Key、Value和Entry对象，其使用方法如下所示：
public class HashMapExam {
public static void main(String[] args) {
Map<Integer， String> map = new HashMap<>(16);
for (int i = 0; i < 15; i++) {
map.put(i， new String(new char[]{(char) ('A'+ i)}));
}
System.out.println("======keySet=======");
Set<Integer> set = map.keySet();
Iterator<Integer> iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("======values=======");
Collection<String> values = map.values();
Iterator<String> stringIterator=values.iterator();
while (stringIterator.hasNext()) {
System.out.println(stringIterator.next());
}
System.out.println("======entrySet=======");
for (Map.Entry<Integer， String> entry : map.entrySet()) {
System.out.println(entry);
}
}
}源码分析
下面让我们看看源码：
// 默认的初始容量(容量为表中桶数)是16，且实际容量必须是2的整数次幂.
//aka有時候也會寫做a.k.a.就是Also known as，「也叫…」的意思
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量(必须是2的幂且小于2的30次方，传入容量过大将被这个值替换)
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认加载因子为0.75(只有当表达到3/4满时，才会再散列)，这个因子在时间和空间代价之间达到了平衡.更高的因子可以降低表所需的空间，但是会增加查找代价，而查找是我们使用最频繁使用的操作了.
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表转为红黑树的临界值
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
// 存储数据的Node数组，长度是2的幂.
// HashMap采用链表法解决冲突，每一个Entry本质上是一个单向链表
//HashMap底层存储的数据结构，是一个Node数组.上面得知Node类为元素维护了一个单向链表.至此，HashMap存储的数据结构也就很清晰了:维护了一个数组，每个数组又维护了一个单向链表.之所以这么设计，考虑到遇到哈希冲突的时候，同index的value值就用单向链表来维护
transient Node<K，V>[] table;
// HashMap的底层数组中已用槽的数量
transient int size;
// HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）
int threshold;
// 负载因子实际大小
final float loadFactor;
// HashMap被改变的次数
transient int modCount;
// 指定“容量大小”和“加载因子”的构造函数，是最基础的构造函数
public HashMap(int initialCapacity， float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// HashMap的最大容量只能是MAXIMUM_CAPACITY
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//负载因子须大于0
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// 设置"负载因子"
this.loadFactor = loadFactor;
// 设置"HashMap阈值"，当HashMap中存储数据的数量达到threshold时，就需将HashMap的容量加倍
this.threshold = tableSizeFor(initialCapacity);
}
//上面的tableSizeFor有何用?
//先抛出答案:tableSizeFor方法保证函数返回值是大于等于给定参数initialCapacity最小的2的幂次方的数值
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;
}
//可以看出该方法是一系列的二进制位操作。先说明 |=的作用：a |= b 等同于 a = a|b。逐行分析tableSizeFor方法：
//int n = cap - 1:给定的cap减1，为了避免参数cap本来就是2的幂次方，这样一来，经过后续的未操作的，cap将会变成2 * cap，是不符合我们预期的。
//n |= n >>> 1:n >>> 1，n无符号右移1位，即n二进制最高位的1右移一位;n | (n >>> 1)，导致的结果是n二进制的高2位值为1; 目前n的高1~2位均为1
//n |= n >>> 2:n继续无符号右移2位.n | (n >>> 2)，导致n二进制表示高3~4位经过运算值均为1; 目前n的高1~4位均为1。
//n |= n >>> 4:n继续无符号右移4位.n | (n >>> 4)，导致n二进制表示高5~8位经过运算值均为1; 目前n的高1~8位均为1.
//n |= n >>> 8:n继续无符号右移8位.n | (n >>> 8)，导致n二进制表示高9~16位经过运算值均为1;目前n的高1~16位均为1.
//可以看出，无论给定cap(cap < MAXIMUM_CAPACITY )的值是多少，经过以上运算，其值的二进制所有位都会是1.再将其加1，这时候这个值一定是2的幂次方.当然如果经过运算值大于MAXIMUM_CAPACITY，直接选用MAXIMUM_CAPACITY.为什么cap要保持为2的幂次方？
cap要保持为2的幂次主要与HashMap中数据存储有关。
在Java8中，HashMap中key的Hash值由Hash(key)方法（后面会详细分析）计算得来。
HashMap中存储数据table的index是由key的Hash值决定的。在HashMap存储数据的时候，我们期望数据能够均匀分布，以防止哈希冲突。自然而然我们就会想到去用%取余的操作来实现我们这一构想。
这里要了解到一个知识：取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作。
这也就解释了为什么一定要求cap要为2的幂次方。再来看看table的index的计算规则：
index = e.hash & (newCap - 1)
等价于:
index = e.hash % newCap
采用二进制位操作&，相对于%，能够提高运算效率，这就是cap的值被要求为2幂次的原因。
Node类
Node<K，V> 类是HashMap中的静态内部类，实现Map.Entry<K，V>接口。定义了key键、value值、next节点，也就是说元素之间构成了单向链表。
static class Node<K，V> implements Map.Entry<K，V> {
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;
}
}TreeNode类
红黑树结构包含前、后、左、右节点，以及标志是否为红黑树的字段。此结构是java8新加的。
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) {}
//以下省略其他方法
}hash方法
HashMap中table的index是由Key的哈希值决定的。HashMap并没有直接使用key的hashcode()，而是经过如下的运算：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}而之前我们提到index的运算规则是e.hash & (newCap - 1)。由于newCap是2的幂次，那么newCap - 1的高位应该全部为0。如果e.hash值只用自身的hashcode的话，那么index只会和e.hash的低位做&操作。这样一来，index的值就只有低位参与运算，高位毫无存在感，从而会带来哈希冲突的风险。所以在计算key的哈希值的时候，用其自身hashCode值与其低16位做异或操作。这也就让高位参与到index的计算中来了，即降低了哈希冲突的风险又不会带来太大的性能问题。
put方法
①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；
②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；
③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；
④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤；
⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。
public V put(K key, V value) {
// 对key的hashCode()做hash
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;
// 步骤①:tab为空则调用resize()初始化创建
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 步骤②:计算index,并对null做处理
//tab[i = (n - 1) & hash对应索引的第一个节点
if ((p = tab[i = (n - 1) & hash]) == null)
// 无哈希冲突的情况下,将value直接封装为Node并赋值
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 步骤③:节点key存在,直接覆盖value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 如果key相同,p赋值给e
e = p;
// 步骤④:判断该链为红黑树
else if (p instanceof TreeNode)
// 若p是红黑树类型，则调用putTreeVal方式赋值
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 步骤⑤:该链为链表
else {
// index 相同的情况下
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 如果p的next为空,将新的value值添加至链表后面
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 如果链表长度大于8,链表转化为红黑树,执行插入
treeifyBin(tab, hash);
break;
}
// key相同则跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//就是移动指针方便继续取 p.next
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
//根据规则选择是否覆盖value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 步骤⑥:超过最大容量,就扩容
if (++size > threshold)
// size大于加载因子,扩容
resize();
afterNodeInsertion(evict);
return null;
}在构造函数中最多也只是设置了initialCapacity、loadFactor的值，并没有初始化table，table的初始化工作是在put方法中进行的。
resize方法
扩容(resize)就是重新计算容量。向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。
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) {
// table已存在
if (oldCap >= MAXIMUM_CAPACITY) {
// oldCap大于MAXIMUM_CAPACITY,threshold设置为int的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//newCap设置为oldCap的2倍并小于MAXIMUM_CAPACITY，且大于默认值, 新的threshold增加为原来的2倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
// threshold>0, 将threshold设置为newCap,所以要用tableSizeFor方法保证threshold是2的幂次方
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 默认初始化，cap为16，threshold为12。
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// newThr为0，newThr = newCap * 0.75
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 新生成一个table数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// oldTab 复制到 newTab
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)
// e为红黑树的情况
((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;
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;
}remove方法
remove(key) 方法 和 remove(key,value) 方法都是通过调用removeNode的方法来实现删除元素的。
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// index 元素只有一个元素
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
// index处是一个红黑树
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// index处是一个链表，遍历链表返回node
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
// 分不同情形删除节点
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}在JDK1.7及以前的版本中，HashMap里是没有红黑树的实现的，在JDK1.8中加入了红黑树是为了防止哈希表碰撞攻击，当链表链长度为8时，及时转成红黑树，提高map的效率。
如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。它是如何工作的？前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的那个会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的，不过如果实现了当然最好。如果没有实现这个接口，在出现严重的哈希碰撞的时候，你就并别指望能获得性能提升了。
这个性能提升有什么用处？比方说恶意的程序，如果它知道我们用的是哈希算法，它可能会发送大量的请求，导致产生严重的哈希碰撞。然后不停的访问这些key就能显著的影响服务器的性能，这样就形成了一次拒绝服务攻击（DoS）。JDK 8中从O(n)到O(logn)的飞跃，可以有效地防止类似的攻击，同时也让HashMap性能的可预测性稍微增强了一些。
参考文章：Java 8系列之重新认识HashMap
腾讯云开发者
