HashMap(源码级JDK1.8)
首先看HashMap的构造方法,有四种
//第一种无参的
public HashMap() {
//单纯的将负载因子赋值为默认值
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
//第二种 就是传个默认大小,附带了默认因子,第三种手动传一个因子,第四种就是传一个map进来就不都列了
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//MAXIMUM_CAPACITY = 1 << 30;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//位运算,感兴趣的百度吧
this.threshold = tableSizeFor(initialCapacity);
}
然后看put方法,这里是第一次put的流程,涉及初始化
public V put(K key, V value) {
//对key进行hash
return putVal(hash(key), key, value, false, true);
}
看内部方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//Node是一个对象,内部有 hash,key ,value,next下一个node对象
//定义了node数组,和一个node对象,两个int类型
Node<K,V>[] tab; Node<K,V> p; int n, i;
//第一次进来table是null,直接往下走
if ((tab = table) == null || (n = tab.length) == 0)
//进来之后调用reszie返回一个node数组,并把数组长度给n,下面进入看resize方法
n = (tab = resize()).length;
//回来了发现 n = 16 ,这里做了个操作 15&传入key的hash的值赋值给i,并且将i下标的元素给p,最后判断是否为null
if ((p = tab[i = (n - 1) & hash]) == null)
//这里肯定是空咯,第一次进都还没放呢,直接调用newNode方法,并将返回值给tab[i]
//这里其实就是调用了Node对象的构造方法,把值传进去,next为null
tab[i] = newNode(hash, key, value, null);
else {
//如果不是空,这坑里有人
Node<K,V> e; K k;
//看看坑里的人hash和刚传入的hash是否一样
//再对比key是否一样
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//一样的话就先取出,后面进行覆盖
e = p;
else if (p instanceof TreeNode)
/*
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
*/
//如果是treeNode,就调用putTreeVal
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//注意看这里,如果还不是treenode的话,put第12次 也就是达到默认扩容大小会进来
for (int binCount = 0; ; ++binCount) {
//每次进来binCount 都是0 怎么能让binCount >= 7进入treeifyBin 方法呢?
//只要每个节点下一个节点都不是空循环6
if ((e = p.next) == null) {
//子节点为空,就直接new一个node放到子节点上面(看起来是不是像单向链表了)
p.next = newNode(hash, key, value, null);
//TREEIFY_THRESHOLD = 8 ,连续8个子节点都不是空(很难达到)
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) {
//新插入的和旧的一样 把新的赋给旧的
V oldValue = e.value;
//onlyIfAbsent false
if (!onlyIfAbsent || oldValue == null)
//赋值给value
e.value = value;
//这里啥也没干
afterNodeAccess(e);
//直接返回
return oldValue;
}
}
//如果这个坑没人
++modCount;
//当大小大于下次需要扩容的大小时进行resize,第一次进入是大于12
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
resize方法(比较重要)
final Node<K,V>[] resize() {
//这里的table第一次进来是null
Node<K,V>[] oldTab = table;
//这里为0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//threshold由于第一次进来默认是0,无参构造,第一次put之后就是0.75 * 16 = 12
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//如果旧的容量大于 1 << 30 设置为integer.maxvalue
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//否则旧容量x2 小于1 << 30 并且 旧容量大于16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//直接扩2倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else {
//这里小于等于0的情况,会把初始值1 << 4 给newCap
newCap = DEFAULT_INITIAL_CAPACITY;
//终于遇到扩容因子 0.75 * 16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// **ok 到这里 newThr = 12 newCap = 16**
if (newThr == 0) {
//第一次没有走这里,没有想到什么情况下newThr会为0
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// threshold = 12,下次达到该值就需要扩容
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//直接new了一个Node数组 大小为 newCap 也就是16
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//将引用赋给table
table = newTab;
//第一次进不来 为null
if (oldTab != null) {
//第二次进来oldCap = 16
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 把16大小的数组 遍历一次看看元素是不是空
if ((e = oldTab[j]) != null) {
//不是空,就把值给e 然后清空这里
oldTab[j] = null;
if (e.next == null)
//如果e的下一个节点空,就把计算之后的新node数组下标位置给e
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//你咋就突然变成Treenode了?
//调用treenode内部的方法不进去看了太多了
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
//e的下一个节点不是空
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;
}
}
}
}
}
//也就是说resize仅仅做了扩容和初始化大小的操作,不仅仅扩容哦还有初始化大小
//第一次put结束 返回一个 16大小的Node数组
return newTab;
}
转树这里debug一直没进去,等之后有机会单独写一下