HashMap介绍
HashMap特点如下：
- 键值对存储 ：
HashMap使用哈希表实现，以键值对的形式存储数据，每个键都是唯一的，而值可以重复。 - 无序性 ：HashMap 不保证元素的顺序，这意味着在遍历 HashMap 时，元素的顺序可能与插入时的顺序不同。从 Java 8 开始，如果指定了使用
LinkedHashMap并设置了访问顺序(accessOrder)为 true，则可以按照访问顺序排序。 - 快速查找、插入和删除 ：平均情况下，HashMap 提供了常数时间复杂度
O(1)的查找、插入和删除操作，这是因为这些操作依赖于哈希函数计算键的哈希值来直接定位到对应的桶(bucket)。 - 允许一个null键和多个null值 ：不同于
Hashtable，HashMap允许单个键为null，并且可以有多个值为null。不过由于 hash 算法的原因，null键只能存在一个。 - 线程不安全 ：HashMap 不是线程安全的。如果在多线程环境下使用，需要采取额外的同步措施，或者直接诸如
ConcurrentHashMap这样的并发集合类。
HashMap的类继承结构如下：
HashMap源码分析
HashMap 在 JDK 1.7 和 JDK 1.8 中的核心实现原理存在显著差异：
- 在 JDK 1.7 中，
HashMap主要使用数组加链表 的形式来存储元素，当发生哈希冲突时，新元素被插入到链表的头部（头插法），这种链表的结构可能导致在高哈希冲突情况下查询效率降低至O(n)。 - 而在 JDK 1.8 中，
HashMap引入了红黑树 以优化高哈希冲突情况下的性能，即当链表长度超过 8 且数组长度大于 64 时，链表会转换为红黑树，将查找时间复杂度降至 O(log n)。此外，JDK 1.8 使用尾插法 而非头插法来添加新元素，并优化了扩容机制，使得元素的新位置要么保持不变，要么移动到原位置加上旧容量的位置。同时，JDK 1.8 简化了哈希算法，减少了扰动处理次数，进一步提高了性能。这些改进使得 JDK 1.8 的HashMap在处理大量数据和高并发场景下表现更加出色。
以 JDK 1.8 为例，对 HashMap 源码实现进行分析：
存储结构
常量与变量：
java
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
/**
* 默认的初始容量为2的4次方，即16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大的容量为2的30次方
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认的加载因子0.75
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* JDK1.8新增：链表转为红黑树的阈值。当链表长度的大于8的时候，才转化为红黑树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* JDK1.8新增：链表还原阈值。HashMap扩容时，会重新计算桶，当红黑树中的数量小于6时，红黑树转化回链表结构
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* JDK1.8新增：当哈希表数组的容量大于64时，才允许链表转化为红黑树。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/* ---------------- Fields -------------- */
/**
* 存储哈希表的数组，总是2的幂次倍
*/
transient Node<K,V>[] table;
/**
* 包含了哈希表中所有键值对的集合视图，主要用于 keySet() 和 values() 方法
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 哈希表中元素的个数。注意这个不等于数组的长度。
*/
transient int size;
/**
* 每次扩容和更改map结构的计数器
*/
transient int modCount;
/**
* 容量阈值threshold = 容量capacity * 负载因子loadFactor
* 当前HashMap中的键值对数量大于该阈值，则需扩容
*/
int threshold;
/**
* 负载因子
*/
final float loadFactor;
}Node数据结构：
java
/**
* Node继承自Map.Entry
**/
static class Node<K,V> implements Map.Entry<K,V> {
/**
* 哈希值
*/
final int hash;
/**
* 键
*/
final K key;
/**
* 值
*/
V value;
/**
* 指向下一个节点
* JDK 1.7 ：链表
* JDK 1.8 ：链表 / 红黑树（当链表长度超过 8 且数组长度大于 64 时）
*/
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 V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
/**
* 根据key和value的值生成hashCode
* 注意：HashMap的哈希槽位计算使用的是HashMap中的hash函数，而非使用此值
*/
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
/**
* 判断相同：需要 key 和 value 同时相同
*/
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;
}
}- 在 JDK 1.7 中，
HashMap使用数组 + 链表的形式来存储元素。 - 在 JDK 1.8 中，
HashMap使用数组 + 链表/红黑树 的形式来存储元素，当链表长度超过 8 且数组长度大于 64 时，链表会转换为红黑树。- 链表中的节点是Node
- 红黑树的节点是TreeNode
TreeNode 是 Node 的子类，因此可以直接替换：
TreeNode其数据结构如下：
java
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
/**
* 父节点
*/
TreeNode<K,V> parent;
/**
* 左节点
*/
TreeNode<K,V> left;
/**
* 右节点
*/
TreeNode<K,V> right;
/**
* 主要在LinkedHashMap的上下文中使用的，用于维护元素插入顺序或访问顺序的双向链表
* 不是直接与HashMap的红黑树机制相关联的核心成员变量
*/
TreeNode<K,V> prev;
/**
* 节点颜色
*/
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
* 返回根节点
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
// 省略其他红黑树操作：增删查改、平衡旋转等...
}HashMap存储结构：
构造方法
java
/**
* 无参构造函数：负载因子默认为0.75
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
* 初始容量使用指定值，负载因子默认为0.75
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 自定义初始容量和负载因子
*/
public HashMap(int initialCapacity, float 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;
// 设置初始容量阈值（threshold），也就是下一次扩容前的容量上限。
// 设置的值是不小于 initialCapacity 的最小 2 的幂次方数。
// 此时还没有初始化内部的数组（table），只是设置了阈值
// 真正的数组初始化是在第一次调用 put() 方法时完成的（延迟初始化）
this.threshold = tableSizeFor(initialCapacity);
}
/**
* 使用指定Map初始化
*/
public HashMap(Map<? extends K, ? extends V> m) {
// 负载因子默认为0.75
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 首先根据需要插入的元素数量来预估和设置适当的容量和阈值，从而避免不必要的扩容操作
// 然后，通过遍历输入 Map 的所有条目并逐一调用 putVal 方法来完成实际的数据插入工作
putMapEntries(m, false);
}
/**
* 找到最接近给定容量值但不小于它的最小2的幂次方数
* 为什么保证哈希表的大小是 2 的幂：为了可以通过位运算快速定位索引位置（如 index = hash & (length - 1)），以保持最佳性能
*/
static final int tableSizeFor(int cap) {
// 对输入的容量cap减1，这是为了避免当输入正好是2的幂时结果不变
int n = cap - 1;
// 通过一系列的无符号右移和按位或操，将所有低位设置为1直到最高位的1为止，实际上是在找到比输入值大的下一个2的幂次方数之前的所有位都置1的过程
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
// 对处理后的值加1，得到的就是最接近输入容量值但不小于它的最小2的幂次方数
// 如果计算的结果超出了HashMap的最大容量限制，则返回最大容量值
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
/**
* 将一个 Map 中的所有键值对添加到当前的 HashMap 中。在构造函数或者 putAll() 方法中被调用
* @param m 要插入的外部 Map。
* @param evict 常用于控制是否允许删除策略（主要用于 LinkedHashMap，在普通 HashMap 中一般无影响）
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
// 判断当前 HashMap 是否已经初始化了内部数组 table
// 如果为 null，表示这是首次插入数据，需要预先计算合适的容量大小以避免频繁调整大小
if (table == null) { // pre-size
// 根据传入 Map 的大小 s 和当前的加载因子 loadFactor 计算出理想的容量 ft
float ft = ((float)s / loadFactor) + 1.0F;
// 将 ft 转换为不超过最大容量 MAXIMUM_CAPACITY 的整数值 t
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
// 如果计算出的理想容量 t 大于当前的阈值 threshold，则更新阈值为最接近 t 的、不小于它的最小2的幂次方数
// 这是为了确保在添加这些新元素时不会立即触发扩容操作
if (t > threshold)
threshold = tableSizeFor(t);
}
// 如果 table 已经初始化，并且要添加的元素数量 s 超过了当前的阈值，则提前进行扩容操作 resize()，可以减少在批量插入过程中多次扩容带来的性能开销
else if (s > threshold)
resize();
// 遍历传入 Map m 的所有键值对，对每个键值对调用 putVal 方法将它们插入到当前的 HashMap 中
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);
}
}
}操作方法
hash方法
java
/**
* 计算键（key）的哈希值（hash），使得数据能够更加均匀地分布在哈希表的各个桶中
*/
static final int hash(Object key) {
int h;
// 1、如果 key == null，则返回 0。HashMap 允许 null 作为 key，所以 null 的哈希值统一为 0
// 2、key非null时的哈希值计算方式：
// 2.1、key.hashCode()：调用对象的 hashCode() 方法获取默认哈希值
// 2.2、h = key.hashCode()：将结果赋值给局部变量 h
// 2.3、h >>> 16：将 h 右移 16 位（无符号右移）
// 2.4、^：按位异或操作
// 通过将 key.hashCode() 的高 16 位与低 16 位进行异或运算，实现对哈希值的扰动，以提升哈希分布的均匀性并减少冲突。
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}put方法
java
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* @param hash key 经过扰动后的 hash 值
* @param key 键
* @param value 值
* @param onlyIfAbsent onlyIfAbsent=false 表示即使 key 已存在也更新值
* @param evict evict=true 表示插入后可能需要扩容
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 一、table 初始化或扩容
Node<K,V>[] tab;
Node<K,V> p;
int n, i;
// table 是 HashMap 内部用于存储数据的数组（Node<K,V>[]）
// 如果 table 为 null 或长度为 0，则调用 resize() 初始化或扩容；resize() 返回新的数组，长度赋给 n
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 二、定位桶位置并插入元素
// 定位数组中的桶号： (n - 1) & hash 等价于 hash % n（效率更高）
if ((p = tab[i = (n - 1) & hash]) == null)
// 如果该索引处没有节点（即为空），则新建一个节点插入
tab[i] = newNode(hash, key, value, null);
else {
// 若索引处已有节点，则进行冲突处理（链表或红黑树）
Node<K,V> e;
K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 如果头节点就是目标节点（key 相同），则记录为 e
e = p;
else if (p instanceof TreeNode)
// 如果是红黑树节点（TreeNode），调用 putTreeVal() 插入树
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 否则遍历链表：
for (int binCount = 0; ; ++binCount) {
// 若没找到相同 key，则插入链表尾部
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 判断是否达到树化阈值（TREEIFY_THRESHOLD = 8），如果达到则调用 treeifyBin() 转换为红黑树存储
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 若找到相同 key （key.equals方法），则跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 如果找到了相同的 key（即 e != null），则更新已有键的值
if (e != null) { // existing mapping for key
// 更新 value
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 调用 afterNodeAccess()（LinkedHashMap 会重写此方法以维护访问顺序）。HashMap 中无用处。
afterNodeAccess(e);
// 返回旧值
return oldValue;
}
}
// 更新modCount
++modCount;
// 如果 size 超过阈值（threshold = 数组容量capacity * 负载因子loadFactor），再次扩容
if (++size > threshold)
resize();
// 在插入后执行回调（如 LinkedHashMap 可用于实现 LRU 缓存）。HashMap 中无用处。
afterNodeInsertion(evict);
return null;
}
/**
* 构造一个新的链表节点（Node）
*/
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
/**
* 将链表转换为红黑树结构：构建红黑树并保持平衡
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
// 数组长度 n、索引 index 、节点引用 e
int n, index; Node<K,V> e;
// 检查是否需要扩容：如果数组为空或者其长度小于 MIN_TREEIFY_CAPACITY（默认值64），则调用 resize() 进行扩容而非直接树化
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
// 定位桶并初始化树节点
// 使用 (n - 1) & hash 计算出桶的位置 index，并获取该位置的第一个节点 e
else if ((e = tab[index = (n - 1) & hash]) != null) {
// 构建树节点链表
TreeNode<K,V> hd = null, tl = null;
do {
// 创建一个新的树节点 p，并通过 replacementTreeNode 方法（通常被子类覆盖）来实现
TreeNode<K,V> p = replacementTreeNode(e, null);
// 将这些树节点按顺序链接起来形成一个双向链表，hd 指向头节点，tl 持有当前尾节点的引用
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
// 执行树化
// 将新构建的树节点链表的头节点设置为当前桶的第一个元素
if ((tab[index] = hd) != null)
// 调用TreeNode的 treeify(tab) 方法将链表转换成红黑树结构
hd.treeify(tab);
}
}
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
return new TreeNode<>(p.hash, p.key, p.value, next);
}逻辑流程总结：
- 计算Hash值 ：通过调用
hash(key)方法来计算传入键的哈希值，确保哈希值分布均匀。 - 确定桶位置 ：基于计算出的哈希值，确定元素应该放置在内部数组中的哪个位置（称为"桶"）。使用
哈希取模法实现：(n - 1) & hash（等价于hash % n），其中n是数组的长度。 - 检查空桶或扩容：如果整个table还未初始化或者当前容量不足以容纳新元素，会先进行扩容操作；如果目标桶为空，则直接将新节点放入该位置。
- 处理哈希冲突 ：如果目标桶非空，说明遇到哈希冲突（即多个键映射到同一个桶），则需要进一步判断该桶内的结构。
- 如果该桶内是一个链表，则遍历链表查找是否已经存在相同的key（
equals方法）。若存在，则更新对应的value；若不存在，则在链表尾部 添加新的节点。- 如果链表长度 ≥ 8 且 table桶数组长度 ≥ 64，则把链表存储转换成红黑树存储，以提高查询效率
- 如果该桶内是一棵红黑树，则调用红黑树的
putTreeVal()方法插入/更新节点
- 如果该桶内是一个链表，则遍历链表查找是否已经存在相同的key（
- 再次检查是否需要扩容 ：完成插入后，检查
size是否超过阈值threshold（阈值threshold = 数组容量capacity * 负载因子loadFactor），如果超过了则执行扩容操作以保证性能。
逻辑流程图：
resize方法
在 Java 的 HashMap 中，当元素数量超过 容量 × 负载因子（默认是 0.75） 时，会触发 扩容 操作。resize() 就是负责扩容操作的核心方法。
java
/**
* 如果当前桶数组为空，则初始化它；否则将其大小翻倍（扩容），并根据 hash & (newCap - 1) 将旧桶中的元素迁移到新桶中。
* 由于HashMap的数组容量保持为2的幂次方，因此扩容后每个桶（bin）中的元素要么保留在原索引位置，要么以2的幂次为偏移量移动到新表中的另一个位置。
*/
final Node<K,V>[] resize() {
// 获取旧表信息
// oldTab: 当前的桶数组
Node<K,V>[] oldTab = table;
// oldCap: 当前桶数组长度（即容量）
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// oldThr: 阈值（threshold），用于判断是否需要扩容
int oldThr = threshold;
// newCap, newThr: 新的容量和阈值，初始为0
int newCap, newThr = 0;
// 判断是否已经初始化过
// 数组已经初始化过
if (oldCap > 0) {
// 如果当前容量已达到最大容量（MAXIMUM_CAPACITY = 2的30次方），就不再扩容，直接返回旧数组
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 否则将容量和阈值都翻倍（<< 1）。这里使用了位移而不是乘法，效率更高
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 数组尚未初始化，但 threshold 不为 0：
// 出现在构造函数传入了初始容量的情况（比如 new HashMap<>(16)），此时 table 还未分配，但是 threshold 被设置为大于 0 的数（作为初始容量使用）
else if (oldThr > 0) // initial capacity was placed in threshold
// 新的容量就是 oldThr
newCap = oldThr;
// 默认构造函数的情况
else { // zero initial threshold signifies using defaults
// 初始化默认容量为 16
newCap = DEFAULT_INITIAL_CAPACITY;
// 阈值为 12（负载因子0.75 × 容量16）
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 如果前面没有设置新阈值 newThr（比如上面用了自定义容量），这里再重新计算一次
if (newThr == 0) {
// 注意类型转换为 float 是为了防止整型溢出
// 阈值 = 容量 * 负载因子
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 指向新数组
table = newTab;
// 迁移数据（核心部分）
if (oldTab != null) {
// 外层循环遍历旧数组每个 bucket
for (int j = 0; j < oldCap; ++j) {
// e 是链表头节点或树节点
Node<K,V> e;
if ((e = oldTab[j]) != null) {
// 清空旧数组引用，以便 GC
oldTab[j] = null;
// 若是单个节点（无冲突）
if (e.next == null)
// 直接插入新数组对应位置
// 哈希取模法：使用 hash & (newCap - 1) 替代 hash % newCap，效率更高
newTab[e.hash & (newCap - 1)] = e;
// 若是红黑树节点（冲突较多，升级为红黑树）
else if (e instanceof TreeNode)
// split内部逻辑：
// 将红黑树拆分为两个链表（low/high）
// 若拆分后的链表长度小于等于 UNTREEIFY_THRESHOLD（默认6），则退化为普通链表
// 否则重新树化（treeify）
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// 若是普通链表节点（冲突较少）
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;
// (e.hash & oldCap) == 0 决定节点是保留在原索引 j，还是移动到 j + oldCap
// 由于新容量是原来的两倍，且是 2 的幂，所以 oldCap 是一个二进制只有一位为 1 的数（如 16 → 0b10000）
// hash & oldCap 的结果决定高位是否为 1
// 示例：假设 oldCap = 16 (0b10000)，那么：如果 hash 的第 5 位是 0，则仍放在 j；如果是 1，则放到 j + 16。
// 这保证了迁移效率，避免重新计算 hash。
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);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
/**
* TreeNode类的split方法
* 用于在 HashMap 扩容时对某个桶中的红黑树进行拆分
* 如果拆分后的子树长度小于阈值（默认6），则退化为链表（untreeify）
*/
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;
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) {
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);
}
}
}流程总结：
- 扩容是将数组大小翻倍（2x），并重新散列所有键值对。
- 什么情况会触发扩容？：当元素数量超过
数组容量 × 负载因子（默认是 0.75）时。 - 什么是负载因子？：控制哈希冲突概率，默认是 0.75，是一个时间与空间的折中值。
- 什么时候会树化？：当 链表长度 ≥ 8 且 桶数组长度 ≥ 64 时，转为红黑树；当链表长度 ≤ 6 时，退化为链表。
- 为什么桶数组容量必须是 2 的幂次方？：因为这样可以用位运算
hash & (capacity - 1)替代模运算hash % capacity，提高效率。 - 在扩容过程中，每个节点要么留在原来的位置，要么移动到
原位置 + 原容量的新位置。
get方法
java
public V get(Object key) {
// 声明一个 Node 类型的变量 e，用于存储查找结果节点
Node<K,V> e;
// 先调用 hash(key) 计算 key 的哈希值
// 然后将哈希值和 key 传给 getNode 方法，查找对应的节点
// 如果找到节点（e != null），则返回该节点的 value；否则返回 null。
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
// tab: 当前哈希表数组（桶）
Node<K,V>[] tab;
// first: 数组中某个桶的第一个节点
// e: 遍历链表时使用的临时节点
Node<K,V> first, e;
// n: 哈希表长度
int n;
// k: 用于保存 key，方便比较
K k;
// (tab = table) != null: 判断哈希表是否已初始化
// (n = tab.length) > 0: 桶数组长度必须大于0
// (first = tab[(n - 1) & hash]) != null: 根据 (n - 1) & hash （）定位到具体桶，并取出第一个节点
// 备注：(n - 1) & hash 是等价于 hash % n 的快速取模操作，前提是 n 是 2 的幂（HashMap 内部容量总是扩展为 2 的幂）
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 检查头节点是否匹配：比较 hash 是否相等（快速失败）；再比较 key 是否是同一个对象或内容相同（使用 equals）
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 如果当前桶中有多个节点（即发生了哈希冲突），进入链表/红黑树查找流程
if ((e = first.next) != null) {
// 如果是红黑树结构，则调用 TreeNode.getTreeNode(hash, key) 查找
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
// 注意：返回 null 并不能判断 key 是否存在，因为 HashMap 支持 key 为 null，也支持 value 为 null。如果需要确认 key 是否存在，需使用 containsKey(key)
return null;
}流程总结：
- 计算哈希值 ：通过
hash(key)方法计算传入键的哈希值 - 定位桶位置 ：使用计算出来的哈希值来确定键值对在哈希表（内部是一个数组，称为桶）中的存储位置。具体是通过
(n - 1) & hash来实现，其中n是桶数组的长度。这是一种高效的哈希取模操作（效果等价于hash % n），前提是桶数组的大小为 2 的幂次方。 - 查找节点 ：
- 如果目标位置上的第一个节点（头节点）就匹配了给定的键（比较哈希值和键本身），则直接返回该节点的值。
- 如果头节点不匹配且存在后续节点，则继续检查这些后续节点：若是链表，则遍历到链表查找；若该位置上的节点形成了红黑树，则按照树的结构进行查找。
- 比较
key是否是同一个对象或内容相同使用equals方法。
- 处理结果 ：如果找到了对应的节点，则返回该节点存储的值；如果没有找到匹配的节点，则返回
null。注意，返回null可能意味着键没有对应的值，也可能是键明确映射到了null值。
get 方法的核心在于利用键的哈希值快速定位到可能包含目标键值对的位置，并通过比较键来精确找到对应的值。这种方法使得查找操作在平均情况下具有常数时间复杂度 O(1)，但在最坏情况下（例如大量哈希冲突）可能会退化到 O(n)（链表存储冲突元素时） 或 O(log n)（红黑树存储冲突元素时）。
核心原理总结
- 哈希机制 ：使用
(key.hashCode()) ^ (h >>> 16)来计算键的哈希值。这种方法通过将高 16 位与低 16 位进行异或操作，能够在一定程度上减少哈希冲突，并使哈希值分布更加均匀。 - 存储结构使用数组 + 链表/红黑树 ：
HashMap底层是一个 table 数组，每个数组元素称为一个桶（bucket）。当多个键通过哈希运算后映射到同一个桶时，就会发生哈希碰撞。JDK 8 中处理哈希碰撞的方式是使用链表来存储这些冲突的元素；如果某个桶中的链表长度超过一定阈值（默认为 8 ），且整个HashMap的容量大于等于 64 ，则会将链表转换为红黑树，以提高查找效率。- 对比 JDK 7，在 JDK 8 中引入了红黑树来优化大量哈希冲突情况下的性能问题，从原来的 O(n) 时间复杂度降低到了 O(log n)，极大地提高了查询效率。
- 数组容量设计 ：数组容量大小总是保持为 2 的幂次方。因为这样可以在确认桶位置时（哈希取模法），用位运算
hash & (capacity - 1)替代模运算hash % capacity，提高效率。 - put 方法：用于插入键值对。首先根据键计算出哈希值并确定放置的位置。若该位置为空，则直接插入；若有冲突，则尝试在对应链表或红黑树中插入。
- get 方法：根据键获取对应的值。首先根据键计算哈希值找到相应的桶，然后遍历桶内的链表或红黑树寻找匹配的键。
- 动态扩容机制 ：
HashMap使用负载因子（默认0.75）来控制扩容时机。当HashMap中的元素数量超过了容量与负载因子的乘积（容量阈值threshold = 容量capacity * 负载因子loadFactor）时，HashMap就会自动扩容（resize方法）。扩容过程中，HashMap会创建一个新的容量为原来 2 倍 的数组，并将所有现存的键值对重新分配到新的数组中。- 什么情况会触发扩容？：当元素数量超过
数组容量 × 负载因子（默认是 0.75）时。 - 什么是负载因子？：控制哈希冲突概率，默认是 0.75，是一个时间与空间的折中值。
- 什么时候会树化？：当 链表长度 ≥ 8 且 桶数组长度 ≥ 64 时，转为红黑树；当链表长度 ≤ 6 时，退化为链表。
- 在扩容过程中，每个节点要么留在原来的位置，要么移动到
原位置 + 原容量的新位置。
- 什么情况会触发扩容？：当元素数量超过
- 允许一个null键和多个null值。
- 线程不安全。
