HashMap添加元素的内部机制
hashMap新增元素主要是在putVal方法中进行,下面进行源码解析
public V put(K key, V value) {
//获取key的hash指
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
//计算hash值是得到值得hashcode值与上哈希值的高16位,采用与会使得结果不会偏向 0或者1 ,使其指均匀的
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab用了存放临时的map具体数组值,p找到对象下标的节点值,n数组容量,节点下标i
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断当前hashMap是不是为空值,为空进行初始化容量resize()
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//利用hash与上数组长度减一得到下标值,如果当前下标没有值,直接放到数组下标中
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//此判断内不涉及扩容操作,都是在子节点上进行添加,所以可以直接return返回
//e为临时子节点,k为临时子节点的key
Node<K,V> e; K k;
//如果添加元素的hash值与下标的第一个元素hash值相同且key也相等,说明map里面已经存在添加的key值,p赋值给e,返回map的oldValue
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果接到是TreeNode子类,说明是红黑树结构 putTreeVal方法下面解析
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);
//如果binCount表示子节点个数>8转换为树结构,减一是去掉了第一个元素
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//树化转换树节点方法,下面解析
treeifyBin(tab, hash);
break;
}
//如果子节点的元素的hash值等于添加元素的hash且key也相等,
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//e不为空说明添加的元树已经存在,返回oldValue
if (e != null) { // existing mapping for key
V oldValue = e.value;
//onlyIfAbsent 表示如果当前位置已存在一个值,是否替换,false是替换,true是不替换,默认进行替换
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//关于afterNodeAccess()方法,在HashMap中没给具体实现,而在
//LinkedHashMap重写了,目的是保证操作过的Node节点永远在最后,从而
//保证读取的顺序性,在调用put方法和get方法时都会用到
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//记录现场的操作次数,与ArrayList文章中类似
//判断添加元素后的如果大于阈值就进行扩容操作resize
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
//新增节点到树节点上
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
//获取树的根节点,父节点不为空,说明parent不是节点,root方法获取当前对象的根节点
TreeNode<K,V> root = (parent != null) ? root() : this;
//遍历树节点
for (TreeNode<K,V> p = root;;) {
//dir 表示左右节点与父节点的标准,
//ph节点的hash值
//pk当前数据点的Key值
int dir, ph; K pk;
//当前节点的hash值如果大于添加元素的hash,说明添加的元素往left上
if ((ph = p.hash) > h)
dir = -1;
//当前节点的hash值如果小于添加元素的hash,说明添加的元素往right上
else if (ph < h)
dir = 1;
//如果走到下面判断说明hash值一样,key也相同,说明key已经存在,直接返回
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
//到这个判断说明hash值一样,key值不一样,
else if ((kc == null &&
//只有当传入对象key的运行时类型符合class key implements Comparable这个条件时,返回对象的运行时类型,否则返回null
(kc = comparableClassFor(k)) == null) ||
//如果x所属的类是kc,返回k.compareTo(x)的比较结果
//如果x为空,或者其所属的类不是kc,返回0
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) { //第一次循环进入,这里就是在根节点的左右节点树上如果能找到添加的元素,找到说明元素已经存在,直接返回,
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
//用tieBreakOrder方法来比较两个对象,返回值要么大于0,要么小于0,不会为0
// 也就是说这一步一定能确定要插入的节点要么是树的左节点,要么是右节点,不然就无法继续满足二叉树结构了
// 先比较两个对象的类名,类名是字符串对象,就按字符串的比较规则
// 如果两个对象是同一个类型,那么调用本地方法为两个对象生成hashCode值,再进行比较,hashCode相等的话返回-1
dir = tieBreakOrder(k, pk);
}
//下面就是真正的插入节点
TreeNode<K,V> xp = p;
//如果dir小于等于0,看当前节点的左节点是否为空,如果为空,就可以把要添加的元素作为当前节点的左节点,如果不为空,还需要下一轮继续比较
//如果dir大于等于0看当前节点的右节点是否为空,如果为空,就可以把要添加的元素作为当前节点的右节点,如果不为空,还需要下一轮继续比较
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
//dir小于等于0,说明是在左子树上,否则在右子树上
if (dir <= 0)
//左节点指向到这个新的树节点
xp.left = x;
else//右节点指向到这个新的树节点
xp.right = x;
//链表的下一个节点指向新的节点
xp.next = x;
//设置新节点的父节点与前一个节点都为当前遍历的节点
x.parent = x.prev = xp;
//如果原来的next节点不为空
if (xpn != null)
//next节点的前一个节点指向新的节点
((TreeNode<K,V>)xpn).prev = x;
//对红黑树进行重新平衡,以及新的根节点置顶
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
//把链表转化为树结构
final void treeifyBin(Node<K,V>[] tab, int hash) {
//n 数据的容量,index:数组的下标,e当前遍历的节点Node<K,V>
int n, index; Node<K,V> e;
//如果tab为空或数组长度小于树化最小长度64,直接进行扩容,不需要通过树化来解决
//当一个数组位置上集中了多个键值对,那是因为这些key的hash值和数组长度取模之后结果相同。(并不是因为这些key的hash值相同)
//因为hash值相同的概率不高,所以可以通过扩容的方式
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
//通过hash值与数组长度-1取模得到数组的节点下标拿到根节点
else if ((e = tab[index = (n - 1) & hash]) != null) {
//定义头节点与尾节点
TreeNode<K,V> hd = null, tl = null;
do {
//创建节点
TreeNode<K,V> p = replacementTreeNode(e, null);
//如果尾节点为空,说明没有根节点
if (tl == null)
hd = p;//然后首节点指向当前节点
else {
//当前树节点的 前一个节点指向 尾节点
p.prev = tl;
///尾节点的 后一个节点指向 当前节点
tl.next = p;
}
//当前节点设置为尾节点
tl = p;
//e = e.next进入下一次循环,当下一个节点为空,说明节点遍历完了
} while ((e = e.next) != null);
//然后把转化后的双向链表替换原来的单链表
if ((tab[index] = hd) != null)
//真正的树化把对象打头的链表转换为树结构
hd.treeify(tab);
}