环境介绍
jdk1.8
idea
HashMap本质上就是一个数组,根据Hash值来确定一个key在哪个hash桶(哪个数组元素)
而数组元素可能为空,可能为一个单元素,可能为一个元素(后面带链表的那种),可能为一个红黑树
先来看看put方法吧
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
//获得key的hash值,其值为hashcode高16位与低16位进行异或运算求得
}
进入下一步
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)
//若hashMap的table为空或者长度为0,进行resize
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//根据hash值求得key所在hash桶,将数组对应位置的元素赋予p
//若p为空,则直接利用key,value创建一个新的Node,将之赋给数组对应位置
tab[i] = newNode(hash, key, value, null);
else {
//p不为空
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//这里就是比较一下,如果新插入的key与p的key如果是同一个对象或者相等,则将之赋予e
e = p;
else if (p instanceof TreeNode)
//如果不同,则如果p是红黑树结点,就执行将新插入的key,value插入红黑树的操作
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//不是红黑树,而且key不同,那么就是一个链表了
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;
}
//如果下个元素为空,则说明链表已经到了尽头,key并没有在map中(多线程不适用),这个时候直接利用key,value创建一个新的Node,将之附在链表结尾,跳出链表循环,e = null.这个时候如果链表长度大于了红黑树化的阈值,就进行链表转换为红黑树.
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//找到了一个元素,其key与key是同一个对象或者相等,则不插入
p = e;
}
}
if (e != null) { // existing mapping for key
// e!= null ,说明这个key已经被存储过了
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//如果指定了onlyIfAbsent(值不存在的时候才插入)为false 或者旧值为null,则将新值赋给旧Node(e)
e.value = value;
afterNodeAccess(e);
//linkedHashMap重写了这个方法,则可以进行一些自定义的操作
return oldValue;
}
}
++modCount;
//增加hashMap更改次数.用处为:比如foreach循环的时候,modcount修改了,则会报出ConcurrentModificationException
if (++size > threshold)
//增加hashMap大小,如果超过阈值,则进行resize,变大
resize();
afterNodeInsertion(evict);
//linkedHashMap重写了这个方法,则可以进行一些自定义的操作
return null;
//插入成功了,啥也不返回hh
}
觉得有趣,那就看看putTreeVal方法吧
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;
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
if ((ph = p.hash) > h)
dir = -1;
//赋值ph为p的hash值,如果其大于插入的key的hash值,则dir=-1
else if (ph < h)
dir = 1;
//如果ph小于插入的key的hash值,则dir=1
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
//如果p的key与插入的key为同一对象或者相等,则直接返回p,方法结束
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
//kc其实是缓存的comparableClassFor(k),其意思为如果k实现了Comparable,则返回其类,否则返回null.当kc与k的类相同则返回k与pk的大小值并赋予dir. 否则无法比较,dir为0,进入if条件句内部
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;
//在左子树以及右子树寻找与k相同的,如果找到,直接返回.只找一次.
}
dir = tieBreakOrder(k, pk);
//因为无法比较,所以采用了system默认的hashCode值比较得出dir值,这个时候一定是不可能为0的,
//k小于pk返回-1.大于返回1
}
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
//根据dir确定要插入的方向,左子树或者右子树,如果其为空则进入代码块,否则将对应的孩子赋予给p引用.然后进入下一轮循环
//为空,则直接利用k,v创建一个新的Node,然后将之插在对应的位置.进行一些红黑树的孩子父亲赋值操作~~~~
Node<K,V> xpn = xp.next;
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
moveRootToFront(tab, balanceInsertion(root, x));
//balanceInsertion指的是红黑树的插入平衡算法，当树结构中新插入了一个节点后，要对树进行重新的结构化，以保证该树始终维持红黑树的特性。
return null;
//插入完成,返回null
}
}
}