hello,大家好,博主今天分享一篇关于hashMap源码的文章。OK,废话不多说,直接进入正题。
HashMap是Java中常用的一种集合类型,它的底层实现是基于哈希表。哈希表是一种以键值对形式存储数据的数据结构,通过哈希函数将键映射到数组中,以达到快速查找的目的。在本文中,我们将深入分析JDK1.8中HashMap的源码实现。
一 put方法实现
HashMap中的put方法是向集合中添加元素的核心方法。当我们向HashMap中添加一个键值对时,它会先对键进行哈希函数映射,得到它在数组中的下标索引,然后根据键值对的值创建一个新的节点,将它添加到链表中。 在JDK1.8中,当链表长度达到一定阈值(默认为8)时,不再将其转化为红黑树,而是使用一种新的数据结构——链表和红黑树的混合结构。这种新的结构可以同时解决链表长度过长和红黑树开销过大的问题,从而提高了HashMap在散列分布不均匀的情况下的性能。具体实现可以参考下面的代码:
public V put(K key, V value) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果哈希表为空,或者大小为0,则初始化哈希表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 根据键的哈希值计算在数组中的位置
if ((p = tab[i = (n - 1) & hash(key)]) == null)
// 如果该位置为空,则直接将新节点放在该位置
tab[i] = newNode(hash(key), key, value, null);
else {
Node<K,V> e; K k;
// 如果该位置不为空,则遍历链表找到与该键相同的节点
if (p.hash == hash(key) && ((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), key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 当遍历到链表尾部仍未找到相同的键时,将新节点添加到链表末尾
p.next = newNode(hash(key), key, value, null);
// 如果链表长度达到阈值,则将链表转为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash(key));
break;
}
if (e.hash == hash(key) &&
((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(true);
return null;
}
二 get方法实现
HashMap中的get方法用于根据键获取对应的值。当我们调用get方法时,它会先根据键的哈希值找到该键在数组中的索引位置,然后遍历该位置上的链表,找到与该键对应的节点。 对于包含大量元素的哈希表,链表长度可能会很长,从而影响查询效率。在JDK1.8中,当链表长度达到一定阈值(默认为8)时,如果该位置上的节点是一个红黑树节点,就会调用红黑树的查找方法,以提高查询效率。具体实现可以参考下面的代码:
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n; int hash = hash(key);
// 如果哈希表不为空,则根据键的哈希值找到在数组中的位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[(n - 1) & hash]) != null) {
if (p.hash == hash && ((e = p).key == key || (key != null && key.equals(e.key))))
// 如果该位置上的节点就是要查找的节点,则直接返回该节点的值
return e.value;
else if (p instanceof TreeNode)
// 如果该位置上的节点是红黑树节点,则调用红黑树的查找方法
return ((TreeNode<K,V>)p).getTreeNode(hash, key);
else { // 否则遍历该位置上的链表,查找对应的节点
do {
if (p.hash == hash && ((e = p).key == key || (key != null && key.equals(e.key))))
return e.value;
} while ((p = p.next) != null);
}
}
// 如果未找到对应的节点,则返回null
return null;
}
三 HashMap 的扩容机制
HashMap的扩容机制是为了在桶满时动态增加桶的数量,以保证桶的平均长度不超过一个给定的阈值。在JDK 1.8中,如果一个桶的长度超过该阈值,则在该桶上执行一次树化操作(即将链表转换为红黑树),以减少查找时间。如果一个桶上的红黑树节点数量小于等于6,则会将树转换为链表,以减少节点的空间开销。 在JDK 1.8中,扩容操作的触发条件是当HashMap中的数量达到容量(即桶的数量)的0.75倍时,就会开始扩容。具体来说,扩容操作会翻倍旧的桶的数量,并将原先的所有键值对重新分配到新的桶中,以提高性能和空间利用率。 下面是JDK 1.8中resize方法的代码:
final Node<K,V>[] resize() {
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;
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) {
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 { // preserve order
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;
}
}
}
}
}
return newTab;
}
HashMap 扩容的过程主要分 3 个阶段: 1. 初始化:获取旧桶的大小(oldCap)和阈值(oldThr)并计算新桶的大小(newCap)和新阈值(newThr)。 2. 扩容:根据计算出的 newCap,创建一个新的数组(newTab),并遍历旧数组(oldTab)中的每个节点,将它们移动到新数组中。 3. 收尾:更新 HashMap 的阈值(threshold)和桶(table)以及返回新桶。 其中,第一阶段和第三阶段主要是对阈值和桶进行操作,而第二阶段是对 HashMap 中的各个节点进行搬移的过程。
四 JDK1.8解决了JDK1.7的hashMap哪些缺点
在 JDK 1.8 中,HashMap 的实现进行了优化,主要改进了以下两个方面,以解决 JDK 1.7 中 HashMap 存在的缺点: 1. 数据结构转换 JDK 1.8 在底层实现中,引入了红黑树这种数据结构,当链表中的元素个数达到阈值时,将链表转换为红黑树,以提高查找速度。同时,在红黑树的实现中,也进行了一些细节的优化和改进,如节点的颜色和平衡性维护等。 2. 键值对冲突处理 在 JDK 1.7 中,对于键值对冲突的情况,HashMap 采用的是链式存储。当链表中的元素较多时,会导致查找效率降低,从而影响整个 HashMap 的性能。而在 JDK 1.8 中,通过使用红黑树优化,可以在链表中的元素个数较多时,将链表转换为红黑树,进一步提高查找效率。 下面是一些具体的示例代码:
1. 数据结构转换
public class HashMapDemo {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<>(16);
for (int i = 0; i < 20; i++) {
map.put(i, "value" + i);
}
}
}
当插入的元素个数达到一定阈值(默认为 8),HashMap 会自动将链表转换为红黑树,从而提高查找效率。
2. 键值对冲突处理
public class HashMapDemo {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<>(16);
for (int i = 0; i < 20; i++) {
map.put(i % 10, "value" + i);
}
}
}
在这个示例中,我们故意将多个键映射到相同的哈希值上,这样就会导致键值对冲突。在 JDK 1.7 中,这些键值对会被存储在同一个桶中的链表中,当链表中的元素数量达到一定阈值时,查找效率会受到影响。而在 JDK 1.8 中,当链表中的元素数量达到一定阈值时,HashMap 会自动将链表转换为红黑树,进一步提高查找效率。