HashMap
HashMap 是一种基于 数组 和 链表 实现的 哈希表。
优点
- 查询效率高：通过哈希函数将
Key映射到数组的下标，可以快速定位到存储的元素。 - 适用性广：
HashMap支持任何类型的键和值，可以存储null键和值。 - 高效的哈希算法：
HashMap提供了自适应的哈希算法，可以根据键的类型和哈希表的大小动态调整哈希函数，减少哈希冲突的发生。
底层实现
HashMap 使用数组和链表实现哈希表，当链表长度超过阈值（默认为 8），会将链表转换成红黑树，提高查询效率。
注意事项：节点增加（第一次大于树化阈值时）其实也只预先完成了Note→TreeNote转变，会变成一个双向链表还并没有进行树化，后续继续添加时才会真正树化。当hash桶树化以后, 是不会在回退到链表结构的。
扩容机制
HashMap扩容会依赖于内部定义负载因子(默认0.75)，举个例子：
HashMap.size是10, 根据
负载因子计算扩容10*0.75→(int)7当添加第8个数据的时候就会触发扩容机制。HashMap.size → 102=20, 新的扩容大小 200.75→15
扩容机制实现：
会得到新的HashMap大小后, 会创建一个新数组, 然后遍历原数组中的每一个元素，将它们的哈希值与新数组通过 “按位与”运算符 添加到新数组中。
思考点
- HashMap底层为什么需要数组+链表/黑红树结构。为什么会转变黑红树。
- 解释: 数组+链表是为了解决Hash冲突问题, 因为不同Hash值通过
“按位与”运算符会指向数组中同一个下标，链表就是为了解决这个问题。 - 解释: 链表→黑红树是为了提高查询Hash桶中的数据查询效率
- 解释: 数组+链表是为了解决Hash冲突问题, 因为不同Hash值通过
- HashMap扩容中，为什么需要负载因子，负载因子为什么是0.75。
- 解释：减少操作的干扰，等HashMap完全满了再扩容，那么扩容时会导致一段时间内插入、查找和删除等操作的性能急剧下降。通过根据负载因子及时扩容，可以在操作的影响较小的情况下进行扩容，减少操作的干扰
- 解释：为什么是0.75，实现性能和内存占用之间取得平衡的一个合理数值（资料说的）
代码分析
执行添加（Put）方法时, 代码流程分析, 包含黑红树转化、扩容等
// 入口方法, 实际上调用了putVal方法
// key为健, value为值
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* 真正执行添加的方法
* hash -> 是key的Hash值
* key -> 健
* value -> 值
* onlyIfAbsent -> 为Ture时, 如果key/value在table已经存在则不会设置
* evict -> false时, 则表处于创建模式
**/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
// tab -> map的节点数组
// p -> hash在tab数组, 存在的节点数据, 为null时课理解为不存在hash冲突
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 判断note数组(tab)是否存在
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// (n - 1) & hash说明 -> “按位与”运算
// 效果: 根据二进制计算, hash值计算在tab数值中的位置
// 如果在数组中, 该hash值还不存在数据, 则执行添加节点信息
tab[i] = newNode(hash, key, value, null);
else {
// hash桶执行流程
// e -> 执行节点信息
// k -> 存储的key值
Node<K,V> e; K k;
// 判断已存在节点和需要添加的节点数据是否一致
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
// 如果是树节点（黑红树）进行另外逻辑
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// hash桶执行流程
for (int binCount = 0; ; ++binCount) {
// 因为hash桶是通过链表实现, 判断是否还存在下一个节点
if ((e = p.next) == null) {
// 如果不存在, 把添加的数据, 设置到后续节点中（note.next）
p.next = newNode(hash, key, value, null);
// 判断当前hash桶的大小, 如果超过树化阈值则进行树化
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 树化
treeifyBin(tab, hash);
break;
}
// 针对p.next判断已存在节点和需要添加的节点数据是否一致
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 把执行节点设置为p, 因为循环中会获取p.next用于链表的遍历
p = e;
}
}
// 当健已经存在的时候, 进行value操作, 没有添加节点也不需要扩容
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 扩容部分流程, 当size > 扩容阈值的时候进行扩容
if (++size > threshold)
resize();
// 在节点添加之后的扩展部分
afterNodeInsertion(evict);
return null;
}
扩容代码
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// ---- 判断新table大小 ----
// table.size * 2扩容
// threshold = 新table.size * 负载因子(默认0.75)
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) {
// 循环旧table数组数据
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
// 当hash桶只有一层时, 直接设置到新的table数组中
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
// 树节点
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 处理hash桶中的链表数据
// 扩容操作完成后，HashMap中的桶数组长度会变为原来的两倍。
// 因此，在新的桶数组中，某个元素在原来的下标i处的情况只有两种，
// 1. 即在下标为i
// 2. i+oldCap的位置上
// 需要注意的是 在添加的时候我们使用的是 tab.size - 1 & e.hash
// 但是在下面我们用的是 tab.size & e.hash 其实计算的结果是不一样的
// 这样的目的是把 hash桶中的数据拆分开, 避免全部堆积在头/尾的位置上
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// 判断上位是否为0
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 判断上位为1
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 上位是0, 补充到新数组的j下标位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 上位为1, 补充到新数组的j + 旧数组长度下标位置
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
树化代码
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
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 {
// 返回一个treeNote节点
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
// 因为是双向链表, 补充当前节点的前节点链表地址, 前一个节点的后节点地址
// 但是只是把hash桶进行了转变, 真实调整黑红树的方法是putTreeVal的时候
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
