先写一个简单的demo,平时我们使用hashmap大概就是这样的流程。
public class MyHashMap {
public static void main(String[] args) {
HashMap<Integer ,Integer > hm = new HashMap<>();
hm.put(1,1);
hm.put(1,2);
hm.put(17,1);
int i = hm.get(1);
}
}
首先是初始化,我们调用了无参的构造函数,源码如下,仅仅对一个变量进行了赋值,这个变量loadFactor是加载因子,用来控制在什么时候来扩容hashtable(也就是底层的数组),后面的常量是默认的加载因子值为0.75f。
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
在创建hashmap对象的时候,并没有同时创建底层的数组。
接下来执行 hm.put(1,1);
,进入源码中的put方法,会再调用putVal方法,
/**
* putVal方法参数
* @param hash 由key计算出来的 hash值
* @param key 要存储的key
* @param value 要存储的value
* @param onlyIfAbsent 如果当前位置已存在一个值,是否替换,false是替换,true是不替换
* @param evict 表是否在创建模式,如果为false,则表是在创建模式。
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
hash方法,用简单的方法来计算出key的hash值
/**
计算key.hashCode()并将哈希的高位扩展(XOR)到低位。因为该表使用了两个掩码的幂,所以仅在当前掩码之上以位为单位变化
的哈希集总是会发生冲突。(已知的例子包括在小表中保存连续整数的浮点键集。)因此,我们应用了一种变换,将高位的影响向下扩
展。比特扩展的速度、效用和质量之间存在权衡。由于许多常见的哈希集已经合理分布(因此不会从扩展中受益),并且因为我们使用
树来处理箱中的大型冲突集,所以我们只需以最便宜的方式对一些移位的比特进行异或,以减少系统损失,并合并最高比特的影响,否
则由于表边界的原因,这些比特将永远不会用于索引计算。
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
putVal方法,这个方法看上去很复杂,其实就是分几种情况,注意源码中的注释。这个方法分了三部分讲,第一部分。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//创建出表tab表示底层的数组,一个节点p,变量n为数组的长度,i用来表示数组下标。
Node<K,V>[] tab; Node<K,V> p; int n, i;
//这个判断语句,用来判断是否是第一次调用hashmap,table是全局的一个变量,如果是第一次调用即为空,满足条件
//后将对tab进行初始化操作即调用resize()方法。
if ((tab = table) == null || (n = tab.length) == 0)
//初始化数组,初始化长度为16,为2的幂次方,n=16
n = (tab = resize()).length;
//这个hash是关于key的hash值,与n-1进行与操作,可以理解为hash%(n-1),即寻找key在数组中位置,
//将这个位置中的数据复制给p,判断p是否为null
if ((p = tab[i = (n - 1) & hash]) == null)
//p为null,这个key在数组中的位置为空,为其创建一个节点,调用newNode方法,next为空
tab[i] = newNode(hash, key, value, null);
//如果key的位置有数据了
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字面意思就是修改次数。
//与Fail-Fast机制有关,有兴趣可以看看https://blog.csdn.net/u012926924/article/details/50452411
++modCount;
//这个size就是全局变量中数组的长度,因为存入了一个新的数据,故先++,再判断是否超过阈值。
if (++size > threshold)
resize();
//后处理方法,是空实现,LinkedHashMap继承了Hashmap,并实现了,此处不用管。
afterNodeInsertion(evict);
//如果添加成功,返回null
return null;
}
resize方法,方法依然看起来和很复杂,不过也是分情况来考虑的,注意源码中的注释
final Node<K,V>[] resize() {
//创建一个数组oldTab表示原来的旧的数组即全局变量中的数组
Node<K,V>[] oldTab = table;
//如果是第一次调用hashmap方法,oldCap会为0,之后就都是旧的数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//oldThr也为全局变量中的threshold,表示元素阈值,当数组中的元素个数超过这个值时,就触法扩容,值为容量*加载因子
int oldThr = threshold;
//设置新数组的容量和阈值
int newCap, newThr = 0;
//判断旧的数组的长度是否大于0
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//判断数组中旧的阈值是否大于0,
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//其他情况下,也就是旧的数组的长度和阈值都是0的情况下,即第一次调用hashmap的方法时
else { // zero initial threshold signifies using defaults
//设置新的数组的长度为默认的初始化长度,即16,
newCap = DEFAULT_INITIAL_CAPACITY;
//设置新的数组的长度为默认长度*默认的加载因子。即12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//设置全局变量中的元素阈值为刚刚算出来的新的数组的元素阈值
threshold = newThr;
//@SuppressWarnings注解为抑制编译器警告,不需要关心,后面是参数,有兴趣可以看看https://blog.csdn.net/lovequanquqn/article/details/125166785
@SuppressWarnings({"rawtypes","unchecked"})
//创建一个新的数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//将全局变量中的数组赋值一下
table = newTab;
//如果旧的数组不为null,即说明旧的数组中有数据,需要进行数据迁移。如果是第一次调用,那旧的数组将会是空。
if (oldTab != null) {
//挨个遍历数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//先将j的数据赋值给e,再判断e是否为空
if ((e = oldTab[j]) != null) {
//将旧的数组置空
oldTab[j] = null;
//如果e的next为空,说明当前hash表位置只有一个,没有链表
if (e.next == null)
//直接在新的数组中找到其位置。
newTab[e.hash & (newCap - 1)] = e;
//如果节点是树节点
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//这里就是将链表中数据整体转移到新的数组中。
else { // preserve order
Node<K,V> loHead = null, loTail = null;//一个指向头,一个指向尾,将链表一串一起转移到新的数值中
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
//next指向e的下一个
next = e.next;
//这里可能要手算一下,扩容是直接扩容一倍,比如16就变成32,32就变成64.
//因为oldCap肯定是2的幂次方,所以二进制表示中只会有一个1,如果e的hash值和oldCap相与为0,
//说明e是低的那一半中。
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//为1说明是在高的一半中。
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);//这个while将一个链表分成了两个,分别在不同的一半中。
//将高和低两种链表分别放在不同的地方,相差oldCap个位置。0
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//返回一个新的数组
return newTab;
}
newNode方法,创建一个新的节点的方法,使用了Node内部类
// Create a regular (non-tree) node 创建常规(非树)节点
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
Node内部类,重写了hashcode和equals方法,继承于Map中的Entry类,只需要知道有四个参数,hash,key,value,以及一个指向下个节点的指针next(用在链表中)
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
接下来就该执行hm.put(1,2)
语句了,还是调用put方法,再进入putVal方法中。这个和上面的一样,就是注释发生了改变,因为情况不一样进入了不同分支了。第二部分。
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;
//因为这次的key和上次的key都是1,所以他们的hash也是一样的,故p不是null
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//这次会进入到else分支中去。
else {
//创建一个节点引用e,和一个变量k
Node<K,V> e; K k;
//如果p的hash和当前添加节点的hash是一样的。并且key的值也是一样的
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//就将p赋值给e。
e = p;
//判断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;
}
}
//e是不为空的
if (e != null) { // existing mapping for key
//用oldValue记录旧的value值
V oldValue = e.value;
//如果原来是null或者onlyIfAbsent字段为false则直接用新的value值覆盖掉旧的值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//此方法也是空实现,不用管
afterNodeAccess(e);
//返回旧的值
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
接着执行hm.put(17,1)
语句,还是调用put方法,再进入putVal方法中。第三部分。
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;
//这里17和1的hash值是一样,所以p不是null
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//进入else中
else {
Node<K,V> e; K k;
//这里17和1的hash值是一样,但key的值是不一样的
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//p不是树节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//最终进入这个分支中
else {
//这是一个死循环
for (int binCount = 0; ; ++binCount) {
//先将p的小一个节点赋值给e,如果为空的话,就表示这是最后一个节点了
if ((e = p.next) == null) {
//在最后一个节点之后再创建一个新的节点。
p.next = newNode(hash, key, value, null);
//这里就涉及到了将链表转换为红黑树了,如果满足条件就进入转换为红黑树的treeifyBin方法(进入方法也可能不转换),
//默认的条件是链表长度大于等于8,并且总共节点要大于64个.
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
//从这里出去,e会是null
break;
}
//这个判断和上面一个一样,判断hash和值是否都一样。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//结合上面if里的语句,相当于p=p->next
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;
}
最后执行int i = hm.get(1)
语句。get方法中用三目运算符判断了一下。核心还是调用了getNode方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
getNode方法
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//tab不为空,并且get的key的hash所在位置也不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//找到了那个节点,直接返回。
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//没有找到,如果有链表,接着在链表里找
if ((e = first.next) != null) {
//如果是树节点,则调用相应的方法
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//顺着链表挨个找,找到了就返回。
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
//不存在这样的节点就返回null
return null;
}
到这里简单的一个demo涉及的源码就讲完了。
但是源码中还有很多种方法没有涉及,以及最重要的关于红黑树的部分。