HashMap底层机制:
-
目录
HashMap底层维护了Node类型的数组table,默认为null - 当创建对象时,将加载因子初始化为0.75
- 当添加key-val时,通过key的哈希值得到在table的索引。然后判断该索引处是否有元素,如果没有元素直接添加。如果该索引处有元素,判断该元素的key和准备加入的key是否相等,如果相等,则直接替换为val;如果不相等需要判断是树结构还是链表结构,做出相应处理。如果添加时发现容量不够,则需要扩容。
- 扩容:第一次添加,则需要扩容table容量为16,临界值(threshold)为12(16*加载因子)。当添加的元素达到12,就会扩容到16*2=32,新的临界值32*0.75=24,依次类推。
- 在Java8中,如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认为8),而且table大小>=MIN_TREEIFY_CAPACITY(默认为64)就会进行树化(红黑树),否则仍然采用数组扩容机制。
源码剖析
测试:首先我们输入以下代码
public class Main {
public static void main(String[] args) {
HashMap map=new HashMap();
map.put("sanguo",45);
map.put("xiyou",30);
map.put("sanguo",40);
System.out.println("map="+map);
}
}
输出结果
map={xiyou=30, sanguo=40}
然后我们debug源码,看看为什么会得到这样的输出
1、执行构造器
执行构造器:new HashMap(),初始化加载因子为0.75
HashMap map=new HashMap();
Step Into进入后:
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
static final float DEFAULT_LOAD_FACTOR = 0.75f;
2、执行put
map.put("sanguo",45);
Step Into:
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
(1)哈希值计算
通过hash(key),来看一下 hash 方法的源码,该方法的作用是:将 key 的 hashCode 值进行处理,得到最终的哈希值。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
对于该方法的具体解释,请看另外一篇文章:HashMap的哈希/扰动函数的设计,为什么能降低hash碰撞?-CSDN博客
(2)putVal方法:
1)代码注释
在方法上添加了注释,先了解一下代码的内容
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;//定义辅助变量
//tab是HashMap的一个数组,类型是Node[]。
//if语句表示如果当前table是null,或者大小=0,就进行第一次扩容。
//扩容到16个空间
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//根据key得到hash,计算该key应该放到table的哪个位置,并把这个位置的对象,赋给p
if ((p = tab[i = (n - 1) & hash]) == null)
如果p为null,表示还没有存放元素,就会创建一个Node,放到table中索引为i的位置
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;//创建的辅助变量
//如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样,
//并且满足以下两个条件之一:
//准备加入的key和p指向的Node节点的key是同一个对象
//p指向的Node节点的key的equals()和准备加入的key比较后相同。就放弃添加对象
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//再判断p是不是一颗红黑树,
//如果是一颗红黑树,就调用putTreeVal添加
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果table对应索引位置,已经是一个链表,就使用for循环比较
for (int binCount = 0; ; ++binCount) {
//依次和该链表每一个元素比较,都不相同,就加入到链表最后
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//在加入元素之后,要进行判断,该链表是否已经达到八个节点,如果达到8个,就进行树化
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//注意:在进行树化时,要进行判断:
// if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
// resize();
//如果上面条件成立,先进行table扩容,条件不成立时,转换成红黑树
treeifyBin(tab, hash);
break;
}
//依次和该链表的每一个元素比较过程中,如果有相同情况,就直接break
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;//替换key对应的value
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//增加修改次数
if (++size > threshold)//增加哈希表的大小,并在达到阈值时进行扩容操作。
resize();
afterNodeInsertion(evict);//在插入节点后可能会执行一些逻辑
return null;//返回null,表示插入操作完成。
}
2)resize()方法
接着看一下这段代码使用的resize()方法:
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; // 将哈希表的旧数组赋值给oldTab变量
int oldCap = (oldTab == null) ? 0 : oldTab.length; // 计算旧数组的长度作为旧容量
int oldThr = threshold; // 将旧的阈值(threshold)赋值给oldThr变量
int newCap, newThr = 0; // 定义新容量和新阈值,初始值为0
if (oldCap > 0) { // 如果旧容量大于0,说明哈希表已经初始化过
if (oldCap >= MAXIMUM_CAPACITY) { // 如果旧容量大于等于最大容量(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) { // 如果旧阈值大于0,说明旧容量是通过阈值设置的
newCap = oldThr; // 将新容量设为旧阈值
} else { // 如果旧容量和旧阈值都为0
newCap = DEFAULT_INITIAL_CAPACITY; // 将新容量设为默认初始容量
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 将新阈值设为默认加载因子乘以默认初始容量的整数值
}
if (newThr == 0) { // 如果新阈值仍然为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]; // 创建新的哈希表数组,将其赋值给newTab变量
table = newTab; // 将哈希表的数组引用指向新创建的数组,完成扩容操作
3)Node
再了解一下Node:可以看到Node 的属性。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
(3)流程图
我们用流程图总结一下HashMap put过程
(4)总结:
- 首先进行哈希值的扰动,获取⼀个新的哈希值。
- 判断tab是否位空或者长度为0,如果是则进行扩容操作。
- 根据哈希值计算下标,如果对应下标正好没有存放数据,则直接插入即可否则需要覆盖。 tab[ i = ( n - 1 ) & hash ] )
- 判断tab[i]是否为树节点,否则向链表中插入数据,是则向树中插入节点。
- 如果链表中插入节点的时候,链表长度大于等于8,则需要把链表转换为红黑树。
- 最后所有元素处理完成后,判断是否超过阈值,超过则扩容。
有兴趣的伙伴可以自己debug一下,追一下put的过程。