HashMap的源码比较复杂，最近也是结合视频以及其余大佬的博客，想着记录一下自己的理解或者当作笔记
JDK1.8后，HashMap底层是数组+链表+红黑树。在这之前都是数组+链表，而改变的原因也就是如果链表过长，查询的效率就会降低，因此引入了红黑树。
这里的链表是一个单向链表
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;
}
}
接下来是类的属性
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16默认的初始容量是16
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量
/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;//负载因子
/**
* The bin count threshold for using a tree rather than list for a
* bin. Bins are converted to trees when adding an element to a
* bin with at least this many nodes. The value must be greater
* than 2 and should be at least 8 to mesh with assumptions in
* tree removal about conversion back to plain bins upon
* shrinkage.
*/
static final int TREEIFY_THRESHOLD = 8;//树化阈值
/**
* The bin count threshold for untreeifying a (split) bin during a
* resize operation. Should be less than TREEIFY_THRESHOLD, and at
* most 6 to mesh with shrinkage detection under removal.
*/
static final int UNTREEIFY_THRESHOLD = 6;//树降级成为链表的阈值
/**
* The smallest table capacity for which bins may be treeified.
* (Otherwise the table is resized if too many nodes in a bin.)
* Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
* between resizing and treeification thresholds.
*/
static final int MIN_TREEIFY_CAPACITY = 64;//桶中的结构转化为红黑树对应的table，也就是桶的最小数量。
transient Node<K,V>[] table;//存放元素的数组，总是2的幂次方
/**
* Holds cached entrySet(). Note that AbstractMap fields are used
* for keySet() and values().
*/
transient Set<Map.Entry<K,V>> entrySet;存放具体元素的集
/**
* The number of key-value mappings contained in this map.
*/
transient int size;存放元素的个数，不是数组的长度
/**
* The number of times this HashMap has been structurally modified
* Structural modifications are those that change the number of mappings in
* the HashMap or otherwise modify its internal structure (e.g.,
* rehash). This field is used to make iterators on Collection-views of
* the HashMap fail-fast. (See ConcurrentModificationException).
*/
transient int modCount;//每次扩容和更改map结构的计数器
/**
* The next size value at which to resize (capacity * load factor).
*
* @serial
*/
// (The javadoc description is true upon serialization.
// Additionally, if the table array has not been allocated, this
// field holds the initial array capacity, or zero signifying
// DEFAULT_INITIAL_CAPACITY.)
int threshold;//临界值，当实际大小（容量*负载因子）超过临界值时，会进行扩容
/**
* The load factor for the hash table.
*
* @serial
*/
final float loadFactor;//负载因子
构造方法中将两个参数的构造方法
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)//初始容量不能小于0，否则报错
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)//初始容量不能大于最大值，否则为最大值
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))//负载因子不能小于或者等于0，不能为非数字
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;//初始化填充因子
this.threshold = tableSizeFor(initialCapacity);//初始化threshold大小
}
tableSizeFor(initialCapacity)这个方法的作用就是返回大于等于initialCapacity的最小的二的次方数。注意是最小
/**
* Returns a power of two size for the given target capacity.
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;//0b1001
n |= n >>> 1;//1001 | 0100 = 1101
n |= n >>> 2;//1101 | 0011 = 1111
n |= n >>> 4;//1111 | 0000 = 1111
n |= n >>> 8;
n |= n >>> 16;//那么后面这两步就得到的结果还是1111。
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;//1111就是15.加1等于16
}
加色cap等于10，那么n = 10-1 = 9。n转化为二进制的话，就是0b1001。那么无符号右移一位，就是0100。
这里cap-1的操作就是为了保证最后得到的n是最小的大于等于initialCapacity的二的次方数。比如这里比10大的2的次方数就是16。如果没有减1.经过上述多次右移和或运算之后，得到的就不是16了。而是32。就不是最小的了。就变成了2倍了。
接下来分析put方法。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
首先研究hash（key）这个方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这个就叫扰动函数，他让hash值得高16位与第16位进行异或处理。这样可以减少碰撞。采用位运算也是因为这样更高效。并且当数组的长度很短时，只有低位数的hashcode值能参与运算。而让高16位参与运算可以更好的均匀散列，减少碰撞，进一步降低hash冲突的几率。并且使得高16位和低16位的信息都被保留了。
然后讲述putVal方法，执行过程可以用下面图来理解：
1.判断数组table是否为空或者位null，否则执行resize()进行扩容；
2.根据键值key计算数组hash值得到插入的数组索引i，如果table[i]==null，那么就可以直接新建节点添加到该处。转向6，如果不为空，转向3
3.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向4，这里的相同指的是hashCode以及equals；
4.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向5；
5.遍历table[i]，判断链表长度是否大于8（且），大于8的话（且Node数组的数量大于64）把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
6.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。
————————————————
版权声明：本文为CSDN博主「钱多多_qdd」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/moneywenxue/article/details/110457302
源码如下：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;//定义了辅助变量tab：引用当前hashMap的散列表；p：表示当前散列表的元素，n：表示散列表数组的长度 i：表示路由寻址结果
//这里是延迟初始化逻辑，第一次调用putVal时会初始化hashMap对象中的最耗内存的散列表
// 步骤1
if ((tab = table) == null || (n = tab.length) == 0)//table就是Hash，table就是HashMap的一个数组，类型是Node[]，这里说明散列表还没创建出来
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)//n在上面已经赋值了。这是步骤2。 tab[i = (n - 1) & hash])这一块就是路由算法，赋予p所在table数组的位置，并把这个位置的对象，赋给p，如果这个位置的节点位null，那么表示这个位置还没存放元素。
tab[i] = newNode(hash, key, value, null);就在该位置创建一个新节点，这个新节点封装了key value
else {//桶中这个位置有元素了
Node<K,V> e; K k;//步骤3
if (p.hash == hash &&//如果当前索引位置对应的元素和准备添加的key的hash值一样
((k = p.key) == key || (key != null && key.equals(k))))并且满足准备加入的key和该位置的key是同一个对象，那么后续就会进行替换操作。
e = p;
else if (p instanceof TreeNode)//步骤4.判断该链是否是红黑树
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);如果是，则放入该树中
else {//步骤5 该链为链表 使用尾插法插入数据
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {//桶的位置的next为e，如果e为null，在for的循环中就说明没有找到一样的key的位置，那么久加入末尾
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st加入后判断是否会树化
treeifyBin(tab, hash);
break;//然后跳出
}
if (e.hash == hash &&//这种情况就是找到了一个key以及hash都一样了，那么久要进行替换。
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;//这是循环用的，与前面的e=p.next组合，可以遍历链表。
}
}
if (e != null) { // existing mapping for key//这里就是替换操作，表示在桶中找到key值，hash值与插入元素相等的节点
V oldValue = e.value;//记录e的value
if (!onlyIfAbsent || oldValue == null)
e.value = value;//用心智替换旧值，
afterNodeAccess(e);//访问后回调
return oldValue;//返回旧值
}
}
++modCount;//结构性修改
if (++size > threshold)//步骤6，如果超过最大容量就扩容。
resize();
afterNodeInsertion(evict);//插入后回调
return null;
}
总结一下流程：1根据key计算得到key.hash = (h = k.hashCode())^(h>>>16);
2.根据key.hash计算得到桶数组中的索引，其路由算法就是index = key.hash &(table.length-1)，就是哈希值与桶的长度-1做与操作，这样就可以找到该key的位置
2.1如果该位置没有数据，那正好，直接生成新节点存入该数据
2.2如果该位置有数据，且是一个红黑树，那么执行相应的插入/更新操作；
2.3如果该位置有数据，且是一个链表，如果该链表有这个数据，那么就找到这个点并且更新这个数据。如果没有，则采用尾插法插入链表中。
接下来讲解最重要的resize()方法。
扩容的目的就是为了解决哈希冲突导致的链化影响查询效率的问题。扩容可以缓解。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//oldTab引用扩容前的哈希表
////oldCap表示扩容之前table数组的长度
//oldTab==null就是第一次new HashMap()的时候，那时候还没有放值，数组就是null。那么初始化的时候
//也要扩容。这句就是如果旧的容量为null的话，那么oldCap是0，否则就是oldTab的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;//表示扩容之前的扩容阈值，也就是触发本次扩容的阈值
//newCap：扩容之后table数组的大小
//newThr：扩容之后，下次再次触发扩容的条件
int newCap, newThr = 0;
if (oldCap > 0) {//条件如果成立，那么就是代表hashMap中的散列表已经初始化过了，这是一次正常的扩容
if (oldCap >= MAXIMUM_CAPACITY) {//扩容之前的table数组大小已经达到最大阈值后，则不扩容，且设置扩容条件为int最大值，这种情况非常少数
threshold = Integer.MAX_VALUE;
return oldTab;
}
//oldCap左移一位实现数值翻倍，并且赋值给newCap，newCap小于数组最大值限制 且 扩容之前的阈值>=16
* //这种情况下，则下一位扩容的阈值等于当前阈值翻倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold这里阈值翻倍也可以理解，如果原先table是16长度，那么oldThr就是16*0.75=12；那么oldCap翻倍的时候，那么新的阈值就是2*16*0.75 = 24；
}
//这是oldCap==0的第一种情况，说明hashMap中的散列表是null
//哪些情况下散列表为null，但是阈值却大于零呢
//1.new HashMap(initCap,loadFactor);
//2.new HashMap(initial);
//3.new HashMap(map);并且这个map有数据，着三种情况下oldThr是有值得
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { 这是oldCap==0,oldThr==0的情况，是new HashMap();的时候// zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;//16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//12
}
if (newThr == 0) {//newThr为0时，通过newCap和loadFactor计算出一个newThr
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
//接下来才是真正扩容，
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//创建一个大小为newCap的新的数组
table = newTab;//把新的数组赋值给table
if (oldTab != null) {//说明hashmap本次扩容之前，table不为null
for (int j = 0; j < oldCap; ++j) {//将旧数组中的所有数据都要处理，所以来个循环
Node<K,V> e;//当前node节点
if ((e = oldTab[j]) != null) {//说明当前桶位中有数据，但是数据具体是单个数据，还是链表还是红黑树并不知道
oldTab[j] = null;//将旧的数组的这个点置空，用于方便VM GC时回收内存
if (e.next == null)//如果当前的下一个不为空，也就是在桶位中是单个数据，
newTab[e.hash & (newCap - 1)] = e;//那么根据路由算法e的hash与上新的table的长度-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;
//假如oldCap = 16，那么就是0b10000
//假如hash为 .....1 1111.前面的不用看，就看着五位
//或者hash为 .....0 1111.
那么与上 000000.. 1 0000.前面都是0。所以与完之后，如果为0，那么就是下面这种.....0 1111，就代表应该在低位链。
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) {//如果原先旧数组中的链表中低位链后面不为null，也就是后面是高位链的。复制到新的数组中就要置为null。
loTail.next = null;
newTab[j] = loHead;//然后把这个低链表的头节点放到新的数组中的索引位置。这样低位链的这个节点，就到了新的数组的地方了
}
if (hiTail != null) {//同理
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
从下图可以看出上面扩容的第三种情况，链表的情况。在第15这个桶位的时候，为啥扩容到32的长度的时候，有的链表节点还在15，而有一些却到31处了。因为旧数组中的索引15是根据路由算法算出来的，
公式为hash&(table.length-1),此时索引为15，那么就是hash&(table.length-1) =15.又因为table.length-1=15，也就是1111，那么hash的低四位肯定就知道了，也是1111，但是第五位就不知道了有可能是1有可能
是0，也就是11111或者01111.那么在新的数组中求索引的时候，根据路由算法，此时新的数组长度为32，那么32-1=31，也就是11111那么旧数组中的数如果是11111，那么算出来就是11111，就是在新数组
31的位置上，如果是01111，那么与之后就是01111。就还是15。别的位置也是这样，如果是原索引为1的地方，那么有可能到新数组的17的位置，就是1+16=17；不是都是加16；而是加这个旧数组的长度。
接下来是get()方法；
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;//这里hash(key)的原因是因为存的时候，hash了一下，那么取的时候，肯定的要取他的hash值一样的。
}
所以主要是getNode方法：
final Node<K,V> getNode(int hash, Object key) {
////tab：引用当前hashMap的散列表
//first：桶位中的头元素
//e：临时node元素
//n：table数组长度
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 && //(tab = table) != null&& (n = tab.length) > 0表示散列表不为空，这样才能取到值，要不然没有水的水池不可能取到水。
(first = tab[(n - 1) & hash]) != null) {//这个代表在这个索引的位置的头节点不为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) {//如果这个桶的索引处不是单个数据，那么就进一步查找，如果是单个元素，那么下面不执行，直接返回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;//如果找到一样的e，那么就返回，否则就一直循环，到结尾的话，就还没找到，那么就返回null
} while ((e = e.next) != null);
}
}
return null;//如果上述条件不满足，也就是桶为null或者在指定位置没有数据，那么就返回null
}
接下来是remove(Object key)方法。
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
其实就是removeNode方法
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//matchValue是用来判断的，因为remove还有一个方法，是两个参数的，remove(Object key, Object value).这个方法也是套娃了removeNode方法，意思是不仅key得一致，value也得一致才能删除。否则删不了。matchValue就是用来做这个判断得
* //tab：引用当前hashMap中的散列表
* //p：当前node元素
* //n：表示散列表数组长度
* //index：表示寻址结果，索引位置。 Node<K,V>[] tab; Node<K,V> p; int n, index; if ((tab = table) != null && (n = tab.length) > 0 &&//这里还是一样，先判断有没有水，不然不需要取水了。 (p = tab[index = (n - 1) & hash]) != null) {//找到对应的桶位是有数据的，要不然为null还删啥 Node<K,V> node = null, e; K k; V v; //node为查找到的结果， e表示当前node的下一个元素 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))//当前定位的桶位的索引处的头节点就是要找的结果 node = p;//那么把p赋值给node else if ((e = p.next) != null) {说明当前桶位的头节点有下一个节点，要么是红黑树，要么是链表 if (p instanceof TreeNode)//如果是红黑树 node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e;//这里条件是说明如果是链表中的某一个，那么就找到了这个节点，并把则会个结果赋值给node。用于返回。并退出循环 break; } p = e;//这里是还没找到继续挨个迭代 } while ((e = e.next) != null); } }//上述是查找过程。下面是删除过程 if (node != null && (!matchValue || (v = node.value) == value ||//!matchValue || (v = node.value) == value就是用来判断值是否需要判断一样再删除，就是两个参数的remove方法的条件。如果不是，那么!matchValue就是对的，后面值得判断就不用判断了 (value != null && value.equals(v)))) {//这里就是判断是否是要删除这个节点。 if (node instanceof TreeNode)//这种情况代表结果是树的节点。就走树的删除逻辑 ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p)//当当前桶位的元素就是要删除的元素，那么node才会等于p，那么就把node之后的头节点放到这个桶位就行 tab[index] = node.next; else p.next = node.next;//链表的情况的时候，node一定是在后面。因为上述查找过程中e一直都是p.next，e又赋值给node。所以node就在p后面。这里删除node节点就行。 ++modCount; --size; afterNodeRemoval(node); return node; } } return null; }
replace方法主要是调用getnode。上文已经讲述过了。这里不赘述。
注意：链表转化为红黑树的条件是当前桶位中的节点数到达8并且散列表的长度大于等于64。
还有table扩容的时候，并不是只是桶位的第一个元素才算。根据添加函数中的size++；size是只要加入一个元素，就加1.也就是加入的元素不是桶位第一个元素，而是加到红黑树或者链表中了。也算。这样只要达到了阈值0.75*长度。散列表table就会扩容。
