新人写手,代码菜鸡;笔下生涩,诚惶诚恐。
初试锋芒,尚显青涩; 望君指点,愿受教诲。
目录
本次将以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。 - ......