先写一个简单的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涉及的源码就讲完了。
但是源码中还有很多种方法没有涉及，以及最重要的关于红黑树的部分。
1763
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
