HashMap 在日常开发中使用频率很高，是Java程序员经常使用的用于映射(键值对)处理的数据类型。本文结合源码，深入分析HashMap的底层原理。
属性解析
存储结构(基于JDK1.8)
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;
static final int TREEIFY_THRESHOLD = 8;
transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
transient int size;
transient int modCount;
int threshold;
final float loadFactor;
-
DEFAULT_INITIAL_CAPACITY：初始化桶大小，即数组table的默认大小为16
1 << 4：是位运算，即将1转换为二级制数后向左移动4位，后面补上0，得16 -
MAXIMUM_CAPACITY：桶的最大值，即数组table的最大值为1073741824
1 << 30：即 2^30 = 1073741824 -
DEFAULT_LOAD_FACTOR：默认的负载因子(0.75)
给定的默认容量为 16，负载因子为 0.75。Map在使用过程中不断往里面存放数据，当数量达到 16 * 0.75 = 12 时就需要对当前容量进行扩容，扩容过程涉及到 rehash，复制数据等操作(后面会讲到)，非常消耗性能。因此通常建议提前预估 HashMap 的大小，尽量减少扩容带来的性能损耗。
-
TREEIFY_THRESHOLD：用于判断是否需要将链表转换为红黑树的阈值(默认为8)
默认大小为8，即当链表中 Node 的长度超过8时，将会把链表转换为红黑树 -
Node<K,V>[] table：哈希桶数组，Node是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)。上图中的每个黑色圆点就是一个Node对象。下面是Node源码的解析：
//该类是HashMap的一个静态内部类 static class Node<K,V> implements Map.Entry<K,V> { final int hash; //定位数组的索引位置 final K key; //Map中的key值 V value; //Map中的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; } } -
size：HashMap中实际存在的键值对数量。
-
threshold：桶的大小，即所能容纳的键值对的最大数量，可在初始化时显示指定。
threshold就是在此Load factor和length(数组长度)对应下允许的最大元素数目，超过这个数目就重新resize(扩容)，扩容后的HashMap容量是之前容量的两倍。默认的负载因子0.75是对空间和时间效率的一个平衡选择，建议大家不要修改，除非在时间和空间比较特殊的情况下，如果内存空间很多而又对时间效率要求很高，可以降低负载因子Load factor的值；相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子loadFactor的值，这个值可以大于1。
-
modCount：用来记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败。强调一点，内部结构发生变化指的是结构发生变化，例如put新键值对，但是某个key对应的value值被覆盖不属于结构变化。
-
loadFactor：可在初始化时显示指定的负载因子
几点说明
-
HashMap是使用哈希表来存储的，哈希表为了解决冲突，采用开放地址法，再哈希法，链地址法，建立公共溢出区等方法。Java中的HashMap采用链地址法。链地址法就是数组和链表的结合，在每个数组元素上都有一个链表结构，当数据被hash后，得到数组下标，把数据放在对应下标元素的链表上。
-
在HashMap中，哈希桶数组table的长度length大小必须为2的n次方(一定是合数)，这是一种非常规的设计，常规的设计是把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数，具体证明可以参考http://blog.csdn.net/liuqiyao_01/article/details/14475159，Hashtable初始化桶大小为11，就是桶大小设计为素数的应用（Hashtable扩容后不能保证还是素数）。HashMap采用这种非常规设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。
-
这里存在一个问题，即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响HashMap的性能。于是，在JDK1.8版本中，对数据结构做了进一步的优化，引入了红黑树。而当链表长度太长（默认超过8）时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。
方法解析
1. 计算哈希桶数组索引位置
- 源码实现如下：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
- 哈希算法的本质：取key的hashCode值、高位运算、取模运算
下图为hash值具体计算过程，n为table的长度：
2. put方法的深入分析
- put方法的源码实现如下：
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;
//判断数组tab是否为空，不为空继续执行；为空的话需要进行扩容处理。
if ((tab = table) == null || (n = tab.length) == 0)
//扩容处理，resize() 会返回一个Node数组
n = (tab = resize()).length;
//根据键值key计算hash值得到插入的数组索引i，并判断tab[i]是否为空，如果为空，新建节点添加
if ((p = tab[i = (n - 1) & hash]) == null)
//在当前(tab[i])桶中新建节点添加
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//如果当前桶有值(hash冲突)，比较当前桶中的key, key的hashcode与写入的key是否相等，相等就复制给 e，在后面会统一进行赋值并返回。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果当前的桶为红黑树(TreeNode)，则直接在树中插入键值对
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//如果是一个链表，就需要将当前的 key, value 封装成一个新节点写入到当前桶的后面，形成链表
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//遍历tab[i], 判断链表的长度是否大于8(TREEIFY_THRESHOLD)，大于的话把链表转换为红黑树，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果在遍历过程中找到key相同时直接退出遍历
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果 e != null 相当于存在相同的key，需要将值覆盖
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//判断是否需要扩容，当size大于 threshold = loadFactor * length 时，扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- 下图为put方法的理解图，可以对照源码参考：
3. get方法深入分析
直接走源码：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//根据 key和hash取得所定位的桶
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//判断桶的第一个位置的key是否为查询的key,如果是直接返回value
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<K,V>)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);
}
}
//如果桶为空直接返回null
return null;
}
4. 扩容机制
在前面的介绍中说过 threshold 这个属性，当kv对的数量达到 threshold 的大小时，就会扩大数组的长度，以便能够装入更多的元素。但是Java里面的数组是无法自动扩容的，需要新建一个容量更大的数组来代替已有的容量更小的数组。
还是结合源码分析：
final Node<K,V>[] resize() {
//把原表的引用赋给oldTab
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
//新容量，新的阈值都为0，需要重新计算
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)
//计算hash值
newTab[e.hash & (newCap - 1)] = e;
//如果为红黑树，则按照红黑树法则切割
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//使用链表优化重hash的代码块
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;
}
//新索引=原索引+oldCap
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;
}
简单说明一下扩容过程(jdk1.7)。我们使用的hash算法是：key mod table.length。其中哈希桶数组table的size=2，所以key=3，7，5，put的顺序依次为5，7，3。在 key mod 2 之后，在table[1]这里发生了hash冲突。如下图，假设负载因子为1，即当键值对的实际大小大于table的实际大小时进行扩容。如下几个步骤是哈希桶数组resize成4，然后所有的Node进行rehash的过程：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f34e6qkO-1583931999844)(http://pctdkjiuv.bkt.clouddn.com/jdk1.7%E6%89%A9%E5%AE%B9%E4%BE%8B%E5%9B%BE.png)]
注意：DK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，JDK1.8不会倒置。
现在说说jdk1.8做的优化。经过观测可以发现，我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。看下图可以明白这句话的意思，n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。
元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：
这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。
补充
-
在JDK1.7中，多线程使用场景下，应该尽量避免使用线程不安全的HashMap，而使用线程安全的ConcurrentHashMap。因为多线程场景中put()数据时可能造成死循环。具体请参考：https://blog.csdn.net/xuefeng0707/article/details/40797085
-
JDK1.8引入红黑树大程度优化了HashMap的性能。已经不存在死循环问题，但还是会出现数据丢失等问题，所以最好还是使用线程安全的并发框架，比如：ConcurrentHashMap。
-
关于HashMap的遍历，建议采用 EntrySet 进行遍历(我个人习惯使用jdk1.8的lambda表达式)，使用 EntrySet 可以将key和value同时取出来。而使用 keySet 遍历需要先取出key，再通过key找到对应的value，降低了效率
public Set<K> keySet() {
Set<K> ks = keySet;
if (ks == null) {
ks = new KeySet();
keySet = ks;
}
return ks;
}
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}
说在后面
本文在很多地方参考了技术博文——Java 8系列之重新认识HashMap，其中很多令人印象深刻的图片和流畅的思路给了我很大的启发，是一篇很好的文章，在这里对作者表达由衷感谢与敬意。
630
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
