HashMap基本介绍
文章主要基于B站小刘老师讲解 以及 一些博客对HashMap的重要执行逻辑和流程进行分析（红黑树的细节部分并不包括）。
源码基于JDK11。如有错误欢迎指正
继承体系
底层存储结构
红黑树是jdk8引入的，防止链化严重的情况下，查询的复杂度降为O(n)。
树化需要同时满足两个条件：
- 链表长度大于8，并不是大于等于8，参考文章：HashMap链表树化时机
- 数组长度达到64。如果数组长度不够64，会优先进行resize()扩容。
Node
Node是HashMap的静态内部类，实现了Map.Entry<K,V>接口。我们存储的键值对都是以Node的形式存储在map中的。其重要属性如下：
static class Node<K,V> implements Map.Entry<K,V> {
//基于key的hashValue经过hash扰动后得到的，是hash分布更均匀。
final int hash;
//key的原始值
final K key;
//对应的value
V value;
//指向的下一个Node
Node<K,V> next;
....
}
构造方法源码分析
构造方法有四个：
- 无参构造方法：什么参数也不传入，该构造方法内部只有一句话，
this.loadFactor = DEFAULT_LOAD_FACTOR;，也就是指定负载因子为默认的0.75f。 - 指定
initialCapacity的构造方法：方法内部套娃调用了第三个构造方法：this(initialCapacity, DEFAULT_LOAD_FACTOR); - 指定
initialCapacity和loadFactor的构造方法：最关键的构造方法，看下面的源码分析 - 参数为另外一个map实例的构造方法：会将map的值复制到当前map，具体参考后续源码分析
构造方法3源码分析：
public HashMap(int initialCapacity, float loadFactor) {
//异常值校验，initialCapacity不会越界或者小于0
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//以上部分都是对initialCapacity和loadFactor的异常值校验
this.loadFactor = loadFactor;
//这里使用tableSizeFor得到initialCapacity最接近的2的n次幂
//注意这里没有乘负载因子，是因为在put时会调用resize重新计算（懒加载）
this.threshold = tableSizeFor(initialCapacity);
}
构造方法4源码分析：
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//传入map的大小
int s = m.size();
if (s > 0) {
//情况1：如果当前table为null，说明还没有初始化
if (table == null) { // pre-size
//根据m的元素个数和负载因子估算HashMap的大小
float ft = ((float)s / loadFactor) + 1.0F;
//判断ft是否大于map的最大capacity，限制容量大小不超过MAXIMUM_CAPACITY
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//如果表的元素大于当前的threshold，说明当前表太小，要重新计算表大小
if (t > threshold)
threshold = tableSizeFor(t);
}
//情况2：如果当前table不为null，即已被初始化过，且s>threshold，那么说明当前表需要扩容
else if (s > threshold)
resize();
//遍历开始执行put，将传入的map插入当前的map中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
注意点：
- 初始化时的threshold并没有用
capacity * loadFactor计算，是因为懒加载处理，后续put时会调用resize()计算 - 调用
tableSizeFor(t)会计算得到t向上最接近的2^n整数。因为寻址算法用到了位运算求余的方式，所以数组长度必须是2^n。
tableSizeFor源码分析
再看看tableSizeFor函数的源码：
static final int tableSizeFor(int cap) {
//这里如果不cap-1直接进行运算，那么容量会大一倍
//Integer.numberOfLeadingZeros 返回的是cap-1前面有多少个0，再对-1进行相应的右移
//对于非2的幂次数来说，为了让最高位的1后面所有0全变成1，这样一来再+1就变成了最接近2的幂次数
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
上面的源码是JDK11的实现，和JDK1.8的不同。但是目的都一样，取最接近的那个2^n整数。
put方法源码分析
public V put(K key, V value) {
//实际调用的是putVal方法
//这里要注意的是扰动函数hash(),后面会细说
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// tab：当前hash散列表； p：当前散列表的元素；n：表示散列表数组的长度；i：表示路由寻址结果
Node<K,V>[] tab; Node<K,V> p; int n, i;
//懒加载。tab为空时，也就是第一次插入数据时，才初始化最耗费内存的hash表；
if ((tab = table) == null || (n = tab.length) == 0)
//执行resize()，初始化表
n = (tab = resize()).length;
//情况1：路由寻址算法找到的桶为null，那么直接把node放进去
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//情况2：找到的桶已经有数据了
else {
//e是一个临时的node元素（表示一个已存在的key相同的node），k表示一个临时的key
Node<K,V> e; K k;
//情况2.1：桶的头元素的key就是要put的key，hash相等还要判断值是否相等，如果完全一致，后续则进行替换操作
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//情况2.2：如果树化了
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//情况2.3：链化的情况，且链表的头元素与要插入的key不一致，遍历整个链表
for (int binCount = 0; ; ++binCount) {
//情况2.3.1 ：e == null说明遍历结束，仍然没有相同的，那么直接加入链表（jdk1.8之前是头插入，1.8之后是尾插，为了防止出现死链）
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//插入后，如果达到树化标准
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//情况2.3.2：如果当前key已经存在map中了，跳出for循环，进行替换
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//e!=null，说明当前key已经存在map中了，进行替换并且返回旧值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//当元素新增或者减少才会++modCount，修改旧值不会
++modCount;
// size如果大于阈值，扩容一次
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
扰动函数hash()分析
在putVal方法中，hash值是通过hash()扰动计算后得到的，先看看源码：
static final int hash(Object key) {
int h;
//为null的key，值存放在数组第0个
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
首先可以看到，如果key为null的话，会被放在第0个桶。其次，就是扰动计算的逻辑：(h = key.hashCode()) ^ (h >>> 16)
让key原本的hash码与自己右移十六位后，进行异或运算。这么做的原因是，在table数组长度不够长时，让高位也能参与运算。
前面的源码我们已经看到了，路由寻址算法的计算方式是table.length - 1 & hash。 当table的长度比较小时，比如table=16时，table.length - 1 = 1111 （二进制），它的高位都为0，因此无论hash的高位值是多少，都是不会参与计算的，举个例子：
// Hash 碰撞示例：
00000000 00000000 00000000 00000101 & 1111 = 0101
00000000 11111111 00000000 00000101 & 1111 = 0101
而通过右移16位再进行异或计算后，低位上的值也会收到高位的影响，大大减少了Hash冲突的概率。还是上面的两个数，在经过扰动后，就不会再冲突了：
00000000 00000000 00000000 00000101 // H1
00000000 00000000 00000000 00000000 // H1 >>> 16
00000000 00000000 00000000 00000101 // hash1 = H1 ^ (H1 >>> 16) = 5
00000000 11111111 00000000 00000101 // H2
00000000 00000000 00000000 11111111 // H2 >>> 16
00000000 00000000 00000000 11111010 // hash2 = H2 ^ (H2 >>> 16) = 250
// 没有 Hash 碰撞
(n - 1) & hash1 = (16 - 1) & 5 = 5
(n - 1) & hash2 = (16 - 1) & 250 = 10
参考文章：
详解 HashMap 中的 Hash 算法（扰动函数）
resize方法源码分析
先看源码：
final Node<K,V>[] resize() {
//扩容前的哈希表
Node<K,V>[] oldTab = table;
//oldCap：扩容之前table数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//扩容前的扩容阈值
int oldThr = threshold;
//newCap:扩容后的数组大小；newThr：下次触发扩容阈值
int newCap, newThr = 0;
//情况1：当hashMap已经初始化过时，正常扩容
if (oldCap > 0) {
//情况1.1：如果oldCap大于MAXIMUM_CAPACITY，不再扩充，设置扩容阈值为int最大值（很难触发）
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//情况1.2：newCap值设为oldCap长度*2。如果newCap不大于MAXIMUM_CAPACITY，并且oldCap的值是大于16的，那么扩容阈值也翻倍
//对oldCap>=16的判断是因为精度问题
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//情况2：oldCap==0，说明hashMap还没有初始化
//情况2.1 ：构造函数为这3种时，OldThr>0 1. new HashMap(initCap,LoadFactor) 2. new HashMap(initCap) 3.new HashMap(map)
//此时newCap就是初始化的threshold
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//情况2.2 ：调用new HashMap()构造方法时，OldThr为空; 此时newCap和newThr都取默认值计算
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//情况1.2中oldCap <= 16 或者 情况2.1时，通过newCap和loadFactor计算出一个newThr
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
//当newCap和计算出来的ft都小于MAXIMUM_CAPACITY时，将ft赋值给新的扩容阈值，否则将Int最大值赋值给新的扩容阈值
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
//上面的代码的目的就是计算出新的数组大小newCap和新的扩容阈值newThr
//创建resize后的新数组
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//说明扩容之前已经存在table
if (oldTab != null) {
//遍历oldtable，找到所有已经存在的数据进行处理，也就是放入新数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//不为null时，e为单个数据或者链表或者树的头结点
if ((e = oldTab[j]) != null) {
//置于null，便于Gc回收
oldTab[j] = null;
//情况1：next为null，说明此处还未发生碰撞，当前bin只有单个数据，此时直接计算当前元素在新数组的位置
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//情况2：如果当前位置已经树化
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//情况3：如果当前位置是链表
else { // preserve order
//低位链表（也就是参与路由计算位的首位为0）：存放在扩容之后数组的下标位置与当前一致
Node<K,V> loHead = null, loTail = null;
//高位链表（也就是参与路由计算位的首位为1）：存放在扩容之后的数组的下标位置为：当前下标位+扩容前的数组长度
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// hash -> .... 1 1111
// hash -> .... 0 1111
// oldCap-> ... 1 0000(16)
// 计算结果等于0，说明高位为0，放入低位链
if ((e.hash & oldCap) == 0) {
//说明此时低位链为空，直接将e设为链表的head
if (loTail == null)
loHead = e;
//否则将链表的尾部指向e
else
loTail.next = e;
//再把e重新设为当前的tail
loTail = e;
}
//高位为1，放入高位链
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//低位链的元素在新tab中index不变
if (loTail != null) {
//切断与旧tab中高位链的处理
loTail.next = null;
newTab[j] = loHead;
}
//高位链的元素在新tab中被放入新的index
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
整个扩容的流程代码中注释写的非常情况，基本就是各种条件判断。在链化的情况进行扩容时，Java选择将原本的链表拆分成两条链表，根据判断节点的高位hash值来决定是高位链表还是低位链表。高位链表在新tab中的index为oldIndex + oldCap，低位链表在新tab中的index仍然为oldIndex。
详解高低位链表的计算方式，假设oldCap为16，源码中计算方式为(e.hash & oldCap) == 0：
hash1 = .... 1 1111
hash2 = .... 0 1111
oldCap = .... 1 0000
我们知道HashMap的路由寻址算法是hash & oldCap - 1 ，所以hash1 和 hash2 会被放入同一个桶位。而使用 hash & oldCap计算时，计算的结果只看他们的最高位，也就是oldCap为1的位。通过区分最高位，就划出了两条链表。
get方法源码分析
public V get(Object key) {
Node<K,V> e;
//存的时候做了一次hash扰动，取的时候同理也要做一次hash扰动再匹配
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
//引用当前hashTab的散列表
//first：桶列表的头元素；e：临时node元素；n：table数组长度
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//判断table非空 并且 定位到的桶不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//情况1：定位到的桶，首个元素刚好就是要找的元素
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//情况2：定位到bin，bin内不止一个元素，可能链化或者树化
if ((e = first.next) != null) {
//情况2.1：树化
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//情况2.2：链化
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
get方法逻辑比较简单，唯一要注意的点判断元素相等的逻辑：e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))。首先要判断hash值是否相等，然后还要判断key的值是否相等（用==和equals判断值，==对于基本类型的判断更快，小优化），因为存在hash冲突的情况。
remove方法源码分析
public V remove(Object key) {
Node<K,V> e;
//真正执行删除逻辑的代码是removeNode，如果删除成功会返回删除的值，否则返回null
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
//真正执行删除的逻辑
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//p：当前Node n：当前table长度 index：寻址结果
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：查找到的结果；e：当前Node的next元素；
Node<K,V> node = null, e; K k; V v;
//情况1：当前桶的头元素就是要删除的元素
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//情况2：当前bin中存在链表或者树
else if ((e = p.next) != null) {
//树的情况
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
//链表的情况
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
//p是node的前一个元素，方便后面通过p.next=node.next来remove，
p = e;
} while ((e = e.next) != null);
}
}
//判断node不为空的话，说明找到了需要删除的数据，下面为删除逻辑
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//情况1：如果是树结构，走树的删除逻辑
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//情况2：桶的头元素就是要删除元素，那么将头元素的下一个元素放到第一位，就等于把旧的头元素删除了
else if (node == p)
tab[index] = node.next;
else
//情况3：链化且要删除元素非头元素的情况，删除node，p->node>nextNode => p->nextNode
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
1691
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
