HashMap源码解析
在看源码的时候我习惯先看一下类的属性（快速看一下有个印象就可以了），在看类的内部类，然后才看类的方法。这样也就能更好地从上到下去理解，同时也能带着问题去看这个源码。因为每个属性上都会有注释，介绍这个属性是起到什么作用，而且在看方法的时候也不至于疑惑很多。
HashMap的属性
在看一个源码的时候我习惯先看一下
-
DEFAULT_INITIAL_CAPACITY
//默认初始容量 ,必须是2的幂 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; -
MAXIMUM_CAPACITY
//最大容量，如果任一构造函数使用了参数隐式指定了更高的值，则使用该值。必须是2的幂 <= 1 << 30 static final int MAXIMUM_CAPACITY = 1 << 30; -
DEFAULT_LOAD_FACTOR
//在构造函数中未指定任何内容时使用的负载系数 static final float DEFAULT_LOAD_FACTOR = 0.75f; -
TREEIFY_THRESHOLD
//当一个桶（bin）中的节点数量达到一定阈值时，会使用树结构代替链表结构。当向一个已经包含至少该阈值数量节点的桶中添加元素 //时，桶将转换为树结构。这个阈值必须大于2，并且应至少为8，以符合在节点减少时将树结构转换回普通链表的假设。 static final int TREEIFY_THRESHOLD = 8; -
UNTREEIFY_THRESHOLD
//在扩容操作期间，将树形桶（bin）转换回链表结构的节点数量阈值。这个阈值应该小于将链表转换为树形结构的阈值 //（TREEIFY_THRESHOLD），并且最多为6，以便与删除节点时的收缩检测相匹配。 static final int UNTREEIFY_THRESHOLD = 6; -
MIN_TREEIFY_CAPACITY
//最小的表容量，只有达到这个容量，桶中的节点才可能转换为树形结构。（否则，如果一个桶中的节点过多，表将会被扩容。）这个容量 //应该至少是 TREEIFY_THRESHOLD 的4倍，以避免扩容阈值与树化阈值之间发生冲突 static final int MIN_TREEIFY_CAPACITY = 64; -
table
//该表（table）在首次使用时初始化，并根据需要进行扩容。当分配内存时，其长度总是2的幂。（我们在某些操作中也允许长度为零， //以支持目前不需要的引导机制。 transient Node<K,V>[] table; -
entrySet
//用于缓存 entrySet() 的结果。需要注意的是，AbstractMap 类中的字段被用于 keySet() 和 values()。 transient Set<Map.Entry<K,V>> entrySet; -
size
//此映射中包含的键值映射数 transient int size -
modCount
//表示该 HashMap 结构性修改的次数。结构性修改是指那些改变 HashMap 中映射数量或修改其内部结构的操作（例如重新散列）。这 //个字段用于使在 HashMap 的集合视图上创建的迭代器能够快速失败 transient int modCount -
threshold
//下一次需要调整大小的阈值（容量 * 负载因子） int threshold; -
loadFactor
//哈希表的负载因子 final float loadFactor;
HashMap的内部类
Node
它在Java1.8源码的注释是基本的哈希桶节点，用于大多数条目。（有关TreeNode子类的内容，请参见下文；有关 LinkedHashMap 中 Entry 子类的内容，请参见相关部分这也和我们知道HashMap的基本节点类型是链表相对应
我们在这个类结构可以看到它比普通的链表节点多了hash字段，并且提供了一个hashcode方法
^是按位异或相应位不同放回1 否则返回0
TreeNode
它在Java1.8源码的注释是用于树形桶的条目。它继承自 LinkedHashMap.Entry（而 LinkedHashMap.Entry又继承自 Node），因此可以作为常规节点或链式节点的扩展。。
TreeNode是一颗红黑树，在它的方法中很多平衡二叉树的方法
在这里就不介绍红黑树的具体实现了。
目前发现的信息
在了解了HashMap的属性和HashMap的内部类后，可以发现 HashMap底层是由Node<K,V>[] table实现的
而Node<K,V>是HashMap的内部类，它是一个链表。
TreeNode继承于HashMap.Node<K,V>,它是一颗树(红黑树)
所以可以认为HashMap是由数组 + 链表或数组+红黑树实现的。
HashMap的构造方法
HashMap()
HashMap(int)、HashMap(int,float)
public HashMap(int initialCapacity) {
//调用initialCapacity方法
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
//检查initialCapacity范围
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//检查loadfacotr范围，确保是一个有效的浮点数
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
这里又出现了我们之前看到过的threshold属性: 下一次调整大小的阈值
/**
* 对于给定的目标容量，返回 2 大小的幂
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
这里threshold是接近cap的2的幂的值。
HashMap(Map<? extends K, ? extends V> m)
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) {
//m不为空
if (table == null) {// pre-size
//HashMap为空，未初始化 结合之前的threshold注释 阈值(threshold) = 容量 * 负载因子(loadfactor)
//ft(容量) = s(相当于阈值) / 负载因子
float ft = ((float)s / loadFactor) + 1.0F;
//检查范围
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//保证阈值为接近t的 2的幂
if (t > threshold)
threshold = tableSizeFor(t);
}
//已初始化
else if (s > threshold)
//超出阈值 扩容
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);
}
}
}
HashMap的核心方法
hash()
static final int hash(Object key) {
int h;
//hash值无符号右16位，高位补0 再做异或操作
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
resize()
//容量大于阈值 或者是容量小于红黑树的最小容量
final Node<K,V>[] resize() {
//记录旧HashMap的信息
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
//计算旧容量和旧阈值计算新容量和新阈值
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
//如果旧容量已经达到了最大容量了 threshold =Integer.MAX_VALUE 直接返回旧Map 不再扩容
threshold = Integer.MAX_VALUE;
return oldTab;
}
//没有到达最大容量 新容量 为旧容量的2倍 如果新容量小于MAXIMUM_CAPACITY 阈值也加倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // 容量为 0，阈值大于0 表明是首次使用
newCap = oldThr;
else { // 旧阈值为0 表示尚未初始化 使用默认的容量和负载因子
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
//如果为未初始化过 oldThr = 0 && oldCap = 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) {
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;// 将低位组的尾节点的 next 设置为 null，标志链表的结束
newTab[j] = loHead;// 将低位组的链表头放入新哈希表的当前位置
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
为什么要分组(树节点中也存在分组)
提高效率
哈希表的扩容往往是通过将容量加倍来实现的。假设原哈希表的容量为n，那么扩容后的哈希表容量就变为
2n。在这种情况下，哈希表中的元素要么保持在原位置（低位组），要么移动到新的位置（高位组）。这个过程不需要重新计算所有元素的哈希值，只需要检查哈希值的某一位（通常是最低有效位），从而决定元素是留在原位置还是移动到新位置。这种方法大大减少了重新计算哈希值的计算量。并且选择e.hash & oldCap来分组也是有说法的。oldCap是原哈希表的容量，通常是2的幂次方，在这种情况下oldCap的二进制形式只有一个最高位为1，其余为0。
e.hash & oldCap计算实际上就是提取了第log2(oldCap)位，判断它是 0 还是 1。
这样也和哈希表的整体设计契合
减少了冲突
原来位于相同哈希槽中的元素，因为容量的增大和位置的重新分配而分散到不同的哈希槽中，降低了冲突。
均匀分配
putVal()
//onlyIfAbsent 如果为true不该改变现有值
//evict 如果为false 则表处于创建模式
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) // -1 for 1st
//长度大于 TREEIFY_THRESHOLD - 1 尝试树化
treeifyBin(tab, hash);
break;
}
//找到了相同的键 e就指向这个节点
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;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//维护访问
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
treeifyBin()
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null; // 初始化红黑树的根节点为 null
// 从当前节点（this）开始遍历链表，将其转换为红黑树节点
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next; // 保存当前节点的下一个节点
x.left = x.right = null; // 初始化当前节点的左右子节点为 null
// 如果当前根节点为 null，则将当前节点设置为红黑树的根节点
if (root == null) {
x.parent = null; // 根节点没有父节点
x.red = false; // 红黑树的根节点必须为黑色
root = x; // 将当前节点设置为根节点
} else {
K k = x.key; // 获取当前节点的键
int h = x.hash; // 获取当前节点的哈希值
Class<?> kc = null; // 初始化一个变量，用于保存键的类类型
// 开始在红黑树中插入当前节点
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
// 比较当前节点和树中节点的哈希值，决定插入的位置
if ((ph = p.hash) > h)
dir = -1; // 当前节点的哈希值较小，向左子树插入
else if (ph < h)
dir = 1; // 当前节点的哈希值较大，向右子树插入
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
// 如果哈希值相等，且键没有可比性，则使用备用比较策略
dir = tieBreakOrder(k, pk);
// 插入当前节点到树的合适位置
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp; // 设置当前节点的父节点
if (dir <= 0)
xp.left = x; // 插入到左子树
else
xp.right = x; // 插入到右子树
// 平衡红黑树以满足红黑树的性质
root = balanceInsertion(root, x);
break; // 插入完成，跳出循环
}
}
}
}
// 将根节点移到哈希桶数组的前面，以提高访问效率
moveRootToFront(tab, root);
}
get()
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; // 哈希桶数组
Node<K,V> first, e; // first表示桶中的第一个节点，e用于遍历链表或红黑树
int n; // 哈希桶数组的长度
K k; // 当前遍历节点的键
// 检查哈希桶数组是否初始化，以及桶数组是否有元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 检查桶中的第一个节点是否匹配目标节点（根据哈希值和键）
if (first.hash == hash &&
((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; // 如果没有找到匹配的节点，返回 null
}
总结
-
HashMap在Java1.8中是基于数组+链表或数组+红黑树实现的
-
HashMap的默认容量是16，当元素数量达到 阈值(threshold) 时或者是初始化和树化操作时就会出现扩容resize()。
阈值(threshold) = 容量(Capacity) * 负载因子( loadFactor 默认是0.75)
-
HashMap的容量是2的幂次方。当指定初始容量时，会调用tableSizeFor将容量调整为大于等于它的最小2的幂。而在后面的扩容操作中，容量每次都是乘2。
-
HashMap的容量是2的幂次方使得
- 扩容时不用去rehash 通过
容量 & hash来高低位分组 可以快速,确定扩容后的位置 - (容量 - 1) & hash可以快速计算元素在数组中的位置
- 扩容时不用去rehash 通过
1621
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
