新人写手，代码菜鸡；笔下生涩，诚惶诚恐。
初试锋芒，尚显青涩； 望君指点，愿受教诲。
目录
本次将以JDK17为例，探究HashMap的实现原理
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("姓名", "张三");
map.put("年龄", "18");
String name = map.get("姓名");
System.out.println(name);
}一、构造函数
1.1 无参构造函数
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
// 哈希表的负载因子
final float loadFactor;
// 负载因子默认为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
1.2 指定HashMap初始容量、负载因子
// 若不指定负载因子，则为默认的0.75
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
// 参数校验，保证容量initialCapacity和负载因子loadFactor的合法性
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);
this.loadFactor = loadFactor;
// HashMap容量
this.threshold = tableSizeFor(initialCapacity);
}
static final int MAXIMUM_CAPACITY = 1 << 30;this.threshold为HashMap的容量，tableSizeFor(initialCapacity);会将传入的容量向上扩大为2的幂（如11会扩成16，18会扩成32）；如果传入的initialCapacity为0，threshold为1。
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
@IntrinsicCandidate
public static int numberOfTrailingZeros(int i) {
// HD, Count trailing 0's
i = ~i & (i - 1);
if (i <= 0) return i & 32;
int n = 1;
if (i > 1 << 16) { n += 16; i >>>= 16; }
if (i > 1 << 8) { n += 8; i >>>= 8; }
if (i > 1 << 4) { n += 4; i >>>= 4; }
if (i > 1 << 2) { n += 2; i >>>= 2; }
return n + (i >>> 1);
}1.3 传入Map
// 复制了给定映射的内容到一个新的哈希映射实例中
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) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
} else {
// Because of linked-list bucket constraints, we cannot
// expand all at once, but can reduce total resize
// effort by repeated doubling now vs later
while (s > threshold && table.length < MAXIMUM_CAPACITY)
resize();
}
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);
}
}
}二、成员变量
// 默认初始容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 树化阈值，当链表长度达到这个值，并且HashMap的容量size >= MIN_TREEIFY_CAPACITY时，
// 会将链表转化为红黑树
static final int TREEIFY_THRESHOLD = 8;
static final int MIN_TREEIFY_CAPACITY = 64;
// 树退化阈值，当红黑树的大小小于等于这个值时，会退化成链表
static final int UNTREEIFY_THRESHOLD = 6;
// 节点数组
transient Node<K,V>[] table;
// 键值对数量
transient int size;
// 变化次数
transient int modCount;
// 扩容阈值，当size达到这个值时，会触发扩容
int threshold;
// 负载因子，扩容阈值 = 容量 * 负载因子，默认为0.75
final float loadFactor;三、添加元素及扩容原理
拿最常用的 put(key, value)方法举例
public V put(K key, V value) {
// put方法计算key的hash值，并调用putVal方法
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
/*
如果key为null，返回0；
否则计算key的哈希值，将其与该哈希值右移16位的结果进行异或操作后返回。目的是增加哈希值的随机性，减少碰撞。
*/
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}hash方法中，(key == null) ? 0，也说明了HashMap中，可以存放一个key为null的键值对
ps: ConcurrentHashMap则不能指定key为null
public V put(K key, V value) {
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
// ConcurrentHashMap的putVal方法中，若key为null，会抛出异常
if (key == null || value == null) throw new NullPointerException();
// 其他代码
}3.1 HashMap 存储结构
先简单看一下HashMap的存储方式：
HashMap是由一个Node<K, V>[] table数组构成，put时，根据key的hashcode计算出当前键值对在table中的位置。Hash碰撞时，新节点会以链表或红黑树的形式挂载在Node数组元素下面。
3.2 putVal 添加键值对方法
常用的put方法实际上内部调用的就是putVal方法，本次源码探究重点就在于此
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
/*
tab: table
p: 当前节点
n: table的长度
i: 当前节点在table中的索引
*/
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果当前的散列表table为null，或者table的长度为0，则进行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 根据key的hash值，判断当前节点在table中的位置
if ((p = tab[i = (n - 1) & hash]) == null)
// 如果当前位置没有节点，则直接插入
tab[i] = newNode(hash, key, value, null);
else {
// 如果当前位置已有节点
/*
e: tab[i = (n - 1) & hash]位置的节点
k: tab[i = (n - 1) & hash]位置节点的键
*/
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// tab[i = (n - 1) & hash]位置节点与当前节点p的key-hash值以及key值相同
e = p;
else if (p instanceof TreeNode)
// 如果tab[i = (n - 1) & hash]位置节点为树节点-TreeNode，则将当前节点p插入到TreeNode中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
/*
如果tab[i = (n - 1) & hash]位置节点为链表节点-Node，则遍历链表，
找到key相同的节点，如果找到则覆盖value，否则插入到链表末尾(链地址法解决hash冲突)
*/
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;
}
// 找到hash相同的节点，再判断key是否相同，如果相同，表示找到了目标节点，退出循环
// （hash相同，key不一定相同；key相同，hash一定相同）
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;
// 更新节点的值
// 当onlyIfAbsent为true，则表示只有当map中不存在该key时，才插入该键值对，否则不插入
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
// 返回更新前的值，如果key为新增，则返回null
return oldValue;
}
}
++modCount;
// 如果插入的节点数量超过阈值，则进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;代码绘制成流程图：
HashMap的putVal方法是线程不安全的， 如上图所示：在“获取table[i = (n - 1) & hash]节点p”中，线程A此时判断p节点为null，而线程b此时正好插入了一个hash相同，而key不同的键值对（此时应当以链表方式插入两个值）。由于A线程已经进入了“键值对添加至p处”，所以A直接覆盖了B的键值对，导致B数据丢失。
注意点说明：
- 在找到待添加节点在table数组中的位置后，不仅要判断hash相同，还要使用equals方法判断key是否相同，因为hash相同时，key不一定相同。只有二者均相同才认为是同一个节点；
- 若在table中找到对应的p节点，发现key不相同时，意味着产生了hash碰撞（不同的key落在同一个Node上），此时HashMap采用链地址法解决冲突，即将待插入节点链接到p节点的后面（链表遍历效率为O(n)）；
- 当链表长度过长时（默认长度为8），会转化为红黑树从而提高检索效率（红黑树遍历效率为O(log(n))）；
- 如果添加的键不存在时，添加后返回null，若存在，则返回值为更新前的value值；
- putVal的入参onlyIfAbsent为true时，只有当前key在HashMap中不存在时，才会插入该键值对，否则不会更新原来的值。
3.3 treeifyBin 链表转化为红黑树
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 当链表长度达到树化阈值时，不一定会立刻进行转化
// 若此时的HashMap容量小于MIN_TREEIFY_CAPACITY（64）时，会对
// HashMap进行扩容，不会转化为红黑树
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的容量大于等于64时，才会将链表转化为红黑树，否则对HashMap进行扩容，防止key分布过于集中等极端情况导致查询效率降低。
3.4 resize 扩容方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
// 旧table容量上限
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 旧扩容阈值，达到扩容条件时的元素数量
int oldThr = threshold;
int newCap, newThr = 0;
// 旧table容量 > 0时
if (oldCap > 0) {
// HashMap的容量上限为Integer.MAX_VALUE：2^31 - 1
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 每次扩容后容量以及扩容阈值均为扩容前的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 旧table容量为0，且旧扩容阈值 > 0时
// 初始化时，threshold被设置为指定的容量向上扩大为2的幂
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 旧table容量为0，且旧扩容阈值也为0时
else { // zero initial threshold signifies using defaults
// 使用默认容量16
newCap = DEFAULT_INITIAL_CAPACITY;
// 使用默认扩容阈值0.75 * 16 = 12
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;
// 创建一个容量为newCap（初始容量或旧容量的两倍）的Node数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// 遍历旧table
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
// 如果Node节点未挂载链表，则移到新数组中
// 在新数组中的下标取决于newCap - 1最高位处的hash值
// 若最高位为0，则新数组下标等于原数组下标
// 否则新数组下标等于原数组下标 + oldCap
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
// 如果Node节点为树节点，则拆分为两部分放到新数组中
//（拆分后根据长度决定是否需要红黑树链表化）
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 处理带链表的Node节点，JDK8开始，链表的复制改为了尾插法（顺序与旧链表保持一致）
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
// 遍历Node节点及其链表节点
next = e.next;
// 根据节点的hash值与oldCap进行按位与运算，将Node及其链表节点拆分成
// 两个链表，低位链表和高位链表
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);
// 低位链表放到新数组中同一下标位置j
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 高位链表放到新数组中j + oldCap位置
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}- 当向HashMap首次添加元素，或是元素数量 > HashMap容量 * 负载因子时，会进行扩容；
- resize分为初始化table和扩容table：初始化时，容量为指定的HashMap大小（默认为16），向上扩展为2的幂；扩容时，在最大允许范围内会扩大为原来的两倍；
- 扩容时会新建一个Node数组，并将原数组元素转移到新数组中：
- 当下标 j 处的Node节点不含链表时，根据原节点hash值与newCap - 1按位与结果，复制到新数组的 j 或者 j + oldCap 下标处
- 若下标 j 处的Node节点是一颗树，则会将这颗树拆分成两部分（链表或者树），挂载到新数组 j 与 j + oldCap 下标处（拆分逻辑见1.2.4）
- 当下标 j 处的Node节点包含链表时，根据链表节点hash值与oldCap按位与结果，以尾插法方式拆成两个链表，挂载到新数组 j 与 j + oldCap 下标处
3.5 split 树的拆分方法
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this;
// Relink into lo and hi lists, preserving order
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
// 同样根据节点hash值与oldCap按位与的结果，将树拆分成低位树和高位树
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
if (loHead != null) {
// 如果拆分后的树节点数小于UNTREEIFY_THRESHOLD（默认为6），则将低位树节点转化为普通链表
if (lc <= UNTREEIFY_THRESHOLD)
// 转化后的链表放到原数组下标处
tab[index] = loHead.untreeify(map);
else {
// 低位树
tab[index] = loHead;
// 如果此时高位树不为空，意味着树被拆分
// 需要平衡低位树保持高性能
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
// 高位树同理
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}相比链表的转移，多了两步操作：
- 如果拆分后的树的长度小于树退化阈值（默认为6），则将树转化为链表插入到新数组 j 或 j + oldCap 下标处；
- 如果树被拆分成两部分，则需要重新平衡红黑树，以保持高性能
四、常见面试题
读源码前，是背八股文。但阅读完源码后，就需要加入一些自己的思考。（面试题答案仅供参考）
-
HashMap 的内部存储结构是什么？
数组 + 链表 + 红黑树 -
HashMap 的扩容机制是什么？
当元素数量超过capacity * loadFactor时，或链表超过树化阈值且此时容量小于64时，HashMap会进行扩容。扩容时会创建一个新的数组，新数组的容量通常是原数组的两倍，并重新哈希所有元素到新的数组中。链表和红黑树会拆分成两部门，分别加入到新数组的 j 下标和 j + oldCap 下标处 -
为什么 HashMap 的容量总是 2 的幂次方？
简化散列函数的实现，提高效率；使用2的幂次方作为容量有助于使散列值在数组中的分布更加均匀，从而减少碰撞的发生；方便扩容。 -
HashMap 的 put 操作是如何工作的？
put操作首先计算键的哈希值，然后使用该值定位到数组中的位置。如果该位置为空，则直接插入；如果有元素存在，则根据键值对是否相等决定替换或新增。若是在链表尾部添加元素，长度超过树化阈值，会将链表转化为红黑树提高查询效率。 -
HashMap 是否是线程安全的？
不是。HashMap不是线程安全的。如果多个线程同时进行写操作，可能会导致数据不一致等问题。 -
HashMap 如何解决哈希冲突？
使用链地址法，将冲突节点链接到Node节点之后。若链表长度超过树化阈值，会将链表转化为红黑树提高查询效率。 -
HashMap 的 key 和 value 可以为 null 吗？
key可以有一个为null的键，value可以有多个为null的值，而ConcurrentHashMap的key则不能为null。 - ......
11万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
