一、HashMap基本概念
HashMap 是 Java 集合框架中常用的一个类，主要用于实现哈希映射，基于 AbstractMap 类实现，并且实现了 Map 接口，能够以键值对的形式存储和操作数据。它允许键和值都为 null，键必须唯一，但值可以重复，且不保证映射的顺序。HashMap 是非线程安全的，在多线程环境下使用需要进行外部同步，例如使用 Collections.synchronizedMap(new HashMap())。其性能受初始容量和加载因子两个参数影响，初始容量是哈希表创建时的容量，加载因子是哈希表在自动增加容量之前可以达到多满的尺度，默认值为 0.75。当哈希表中的条目数超出加载因子与当前容量的乘积时，会进行 rehash 操作，重建内部数据结构，哈希表容量通常翻倍。
二、数据结构
1. JDK1.7 及之前
采用数组 + 链表的结构，也称为链表散列。数组是 HashMap 的主体，每个数组元素都是一个桶（bucket），而链表主要用来解决哈希冲突。当发生哈希冲突时，具有相同哈希值的元素会存储在同一个链表中。例如：
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
}2. JDK1.8 及之后
数据结构变为数组 + 链表 + 红黑树。当链表长度超过一定阈值（默认为 8），且数组长度大于等于 64 时，链表会转换为红黑树；当红黑树中的节点数少于一定数量（默认为 6）时，红黑树会退化为链表。例如：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
}红黑树是一种自平衡的二叉搜索树，使得查询的时间复杂度降为 O(logn)，在链表效率变差时提供更好的性能。其特性如下：
- 节点颜色：每个节点要么是红色，要么是黑色。
- 根节点和叶子节点（NIL 节点）：根节点是黑色的，而叶子节点（NIL 节点，通常是空节点）是黑色的。
- 红色节点规则：红色节点的子节点必须是黑色的，即从根到叶子的任意路径上不能有两个连续的红色节点。
- 黑色高度平衡：从任意节点出发，到达其叶子节点的所有路径中，黑色节点的数量必须相同。
三、工作原理
1. 哈希函数
HashMap 的哈希函数用于将键（Key）映射到数组索引，步骤如下：
- 计算哈希码值：对键调用其
hashCode()方法，获得一个 32 位的整数哈希码值。 - 哈希码值的处理：为了提高哈希分布的均匀性和减少哈希冲突，JDK1.7 会进行多次异或和位运算，如
h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4);；JDK1.8 简化为(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16)，通过将哈希值的高 16 位与低 16 位进行异或运算，增加了哈希值的随机性，同时计算开销小。 - 解决哈希冲突：如果不同的键获得了相同的哈希码值，即发生哈希冲突，HashMap 使用链式法（链表）解决冲突，当链表长度超过阈值时会转换为红黑树。
2. 插入操作（put 方法）
- JDK1.7：计算键的哈希值，通过
indexFor方法计算数组下标，将新节点插入到链表头部，原链表连接在新节点后面。例如：
int hash = hash(key);
int i = indexFor(hash, table.length);
table[i] = newNode;- JDK1.8：
- 计算键的哈希值，根据哈希值找到数组下标。
- 如果该位置为空，直接插入新节点。
- 如果该位置已有节点，判断节点类型：如果是红黑树节点，则插入到红黑树中；如果是链表节点，则遍历链表，若找到相同键则更新值，未找到则在链表尾部插入新节点。当链表长度大于等于 8 时，调用
treeifyBin方法判断是否将链表转换为红黑树，若数组长度小于 64 则先进行扩容，否则转换为红黑树。例如：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
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))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}3. 查找操作（get 方法）
- JDK1.7：先根据键的哈希值找到数组下标，再比较键是否和给定的键相同，不同则顺着链表查找下一个节点，直到找到或链表遍历完。
- JDK1.8：如果是红黑树节点，利用红黑树的排序性质进行查找；如果是链表节点，则遍历链表查找。例如：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
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);
}
}
return null;
}4. 删除操作（remove 方法）
先根据键找到对应的节点，然后将该节点从链表或红黑树中移除。如果移除节点后红黑树节点数少于 6 个，红黑树会退化为链表。
三、扩容机制
1. 扩容触发条件
当哈希表中的元素数量超过数组容量乘以加载因子时，会触发扩容。例如，默认初始容量为 16，加载因子为 0.75，当元素数量超过 16 * 0.75 = 12 时，会进行扩容。
2. 扩容操作步骤
- JDK1.7：创建一个新的数组，将原数组中的元素重新计算索引后放入新数组中，使用头插法，先扩容再添加元素，但头插法会使链表发生反转，在多线程环境下可能会死循环。例如：
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}- JDK1.8：扩容时使用尾插法，先插入元素再判断是否扩容。新容量为旧容量的 2 倍，扩展后元素的位置要么在原位置，要么移动到原位置 + 旧容量的位置，通过
(e.hash & oldCap)判断元素新位置，避免了重新计算哈希值。例如：
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
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;
}
}
}
}
}四、常用方法
put(K key, V value)：添加或更新键值对。get(Object key)：根据键获取值。remove(Object key)：根据键删除键值对。containsKey(Object key)：检查是否包含指定的键。size()：返回 HashMap 中键值对的数量。isEmpty()：检查 HashMap 是否为空。clear()：清空 HashMap。
五、注意事项
- 内存占用：HashMap 在存储大量元素时会占用较多内存。
- 键的哈希码：应该合理地覆盖
Object类的hashCode()方法，以避免过多的哈希碰撞。 - 键的等价性：应该正确覆盖
equals()方法，以确保键的唯一性。 - 避免频繁扩容：为了避免频繁的扩容操作，可以通过预估 HashMap 的最大大小并设置初始容量来减少扩容的次数，例如将初始容量设置为
initialCapacity / 0.75F + 1.0F，但会牺牲一些内存。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
