JDK1.8之前(下面以1.7为例)
源码分析
添加元素到HashMap集合中的put()方法源码如下:
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
注释如下:
public class HashMap7<K,V> {
public V put(K key, V value) {
// 判断非空,如果是空则初始化
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
// 判断key是否为null,如果是null则单独处理
if (key == null)
return putForNullKey(value);
// 重头戏来了
// hash(key)方法通过扰动算法计算键(key)的哈希值
// hash(key)更详细了解参考:https://blog.csdn.net/cnds123321/article/details/113745628
int hash = hash(key);
// indexFor()计算该对象在table数组中的位置,即数组下标
// indexFor()更详细了解参考:https://blog.csdn.net/cnds123321/article/details/113742176
int i = indexFor(hash, table.length);
// 从得出的数组下标的位置开始遍历,看看key值是否存在,存在就覆盖值,并返回旧的值
for (HashMap.Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// 比较table[i]元素的hash值是否等于输入的参数key的hash值,并且同时判断table[i]元素的key值是否等于输入的参数key值
// 即判断是否是重复元素
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {// 如果存在重复元素
// 临时变量,保存以前的重复key的旧value值
V oldValue = e.value;
// 然后覆盖为新输入的value值
e.value = value;
// 该方法是留给LinkedHashMap实现的,其功能是设置按访问顺序排序时,每次访问entry就将其移至链表头部。是给LinkedHashMap使用的,暂不关注
e.recordAccess(this);
// 然后将旧值返回
return oldValue;
}
}
// 循环结束后没有执行return,表示HashMap中还没有这对键值对,即不存在重复元素,那么就要添加这对键值对到HashMap中
// 记录修改次数
modCount++;
// 调用addEntry()方法添加该键值对到HashMap中
addEntry(hash, key, value, i);
return null;
}
}
该方法中最值得注意的就是hash()方法和indexFor()方法,这里不做说明,更多详细请参考博客:
说了hash()方法和indexFor()方法后,把最后的addEntry()方法说下:
/**
* 向table链表数组中添加新的键值对(未与已有的键值对产生重复)
*
* @param hash 要被添加元素的hashCode值
* @param key 键值对中的键(key)
* @param value 键值对中的值(value)
* @param bucketIndex 该元素应该放在table链表数组中的哪个位置(即数组的下标)
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
// 如果当前 HashMap 大小已经达到了阈值,并且新值要插入的数组位置已经有元素了,那么要扩容
if ((size >= threshold) && (null != table[bucketIndex])) {
// 扩容,HashMap容量变为原来的2倍
// 注意:HashMap的初始容量为16,而length必须是2^n
resize(2 * table.length);
// 扩容以后,重新计算 hash 值
hash = (null != key) ? hash(key) : 0;
// 扩容以后,也需要重新计算在数组中的存放位置(数组下标)
bucketIndex = indexFor(hash, table.length);
}
// 然后才将元素插入到table链表数组中
createEntry(hash, key, value, bucketIndex);
}
/**
* 创建Entry结点,然后添加到数组对应下标位置
*
* @param hash hashCode值
* @param key 键值对中的键(key)
* @param value 键值对中的值(value)
* @param bucketIndex 该元素应该放在table链表数组中的哪个位置(即数组的下标)
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
// 原链头
HashMap.Entry<K, V> e = table[bucketIndex];
// 使用new HashMap.Entry<>()新建一个元素,然后将新元素插入指定数组下标的链头
table[bucketIndex] = new HashMap.Entry<>(hash, key, value, e);
// 然后HashMap中元素个数加1
size++;
}
执行流程
HashMap的put()方法执行流程如下图:
JDK1.8之后(下面以1.8为例)
源码分析
还是分析put()方法,该方法的源码如下:
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
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
treeifyBin(tab, hash);
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;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
注释如下:
/**
* 添加键值对到HashMap中
*
* @param hash key所对应的哈希值
* @param key 键值对中的键(key)
* @param value 键值对中的值(value)
* @param onlyIfAbsent 如果存在相同的值,是否替换已有的值,true表示替换,false表示不替换
* @param evict 表是否在创建模式,如果为false,则表是在创建模式
* @return 返回旧值或者null
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
HashMap.Node<K, V>[] tab;// 临时变量,用来临时存放链表数组
HashMap.Node<K, V> p;
int n, i;
// 检查链表数组table是否为空,table为null或者table数组的长度为0都表示为空
if ((tab = table) == null || (n = tab.length) == 0)
// 如果为空则初始化,并扩容,然后返回新链表数组的长度,将长度赋值给变量n
// resize()方法就是初始化并扩容,该方法具体请参考:
n = (tab = resize()).length;
// (n-1)&hash这条语句就是JDK1.7中HashMap源码中的indexFor()方法的功能,即得到该对象存放在数组中的具体位置(下标)
// 判断该位置的元素是否为null,即是否存在元素,如果存在则表示已经发生哈希冲突,如果不存在,则添加元素结点
if ((p = tab[i = (n - 1) & hash]) == null)
// 表示不存在元素的情况
// 则新添加一个元素到链表数组的对应下标位置,该结点也是链表的链头
tab[i] = newNode(hash, key, value, null);
else {
// 表示存在元素的情况
// 则发生了哈希冲突,下面的代码则是尝试解决冲突问题
HashMap.Node<K, V> e;
K k;
// 判断待添加元素的hash值和key值是否同已经存在(冲突)的元素的hash值和key值同时相等
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
// 如果相等,则表示两个元素相互重复了,那么使用变量e来临时存储这个重复元素
e = p;
// 如果不相等,表示没有重复,并且判断结点类型是否是红黑树类型
else if (p instanceof HashMap.TreeNode)
// 那么就将该键值对存储到红黑树中
e = ((HashMap.TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
// 如果不相等,且结点类型不是红黑树类型,那么就是链表,即采用拉链法解决冲突
else {
// 遍历链表中所有结点,这是一个死循环,需要通过break跳出循环
for (int binCount = 0; ; ++binCount) {
// 如果p的下一个结点为null,则p是链表中的最后一个结点
if ((e = p.next) == null) {
// 则将键值对添加到最后一个结点的后面
p.next = newNode(hash, key, value, null);
// 同时binCount也是一个计数器,统计该链表已经有几个元素了
// TREEIFY_THRESHOLD是常量,表示阈值,默认值为8
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 但链表中元素个数超过了阈值,则将链表转换成红黑树
treeifyBin(tab, hash);
// 跳出循环
break;
}
// 判断待添加元素的hash值和key值是否同链表中已有元素的hash值和key值同时相等
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
// 如果相等,则表示已经存在相同的键,跳出循环
break;
// 将下一个节点赋值给当前节点,继续往下遍历链表
p = e;
}
}
// 如果e不为空,则表示已经存在重复的值,即存在hash值和key值同时相等的元素
if (e != null) {
// 保存旧值
V oldValue = e.value;
// 然后替换为新值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 此函数会将链表中最近使用的Node节点放到链表末端,因为未使用的节点下次使用的概率较低
afterNodeAccess(e);
// 返回旧值
return oldValue;
}
}
// 记录修改次数
++modCount;
// 如果添加元素后,超过阈值
if (++size > threshold)
// 则对HashMap进行扩容
resize();
// 给LinkedHashMap使用
afterNodeInsertion(evict);
return null;
}
putVal()方法更详细地说明参考:
执行流程
HashMap的put()方法执行流程如下图:
参考博客: