源码分析：
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable在类的开头声明了几个常量，以下是较为重要的：
/**
* 定义初始容量大小为16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 定义最大容量为2^30
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 定义加载因子，与数组实时容量相乘会得到一个扩容阈值（threshold），当到达这个阈值时，将会进行扩容。
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 当链表元素增加到8时，转化为红黑树提升查找效率
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 当红黑树元素减少到6时，退化为链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 只有当哈希表的总容量至少为64时，才可能将链表转换为红黑树。
*/
static final int MIN_TREEIFY_CAPACITY = 64;以下是定义的一些成员变量：
/**
* 这是HashMap存储数据的哈希表，它是一个数组，每个元素是一个链表的头节点或者红黑树的
*/
transient Node<K,V>[] table;
/**
* 这是一个缓存，用于存储HashMap中所有键值对（Entry）的集合视图。
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 这个字段表示HashMap中键值对的总数。
*/
transient int size;
/**
* 这个字段记录了HashMap结构上被修改的次数，包括添加、删除操作，或者重新哈希（rehash）等。
* 它用于实现快速失败（fail-fast）机制，当HashMap在迭代过程中被修改时，会抛出
*/
transient int modCount;
/**
这个字段表示HashMap能够容纳的最大元素数量，达到这个数量时，HashMap会进行扩容（resize）。它等于数组的容量乘以加载因子（load factor）。如果哈希表还没有被分配，这个字段可以表示初始数组容量或0，0代表使用默认的初始容量。
*/
int threshold;
/**
这个字段是HashMap的加载因子，它决定了HashMap何时进行扩容操作。加载因子是HashMap中元素数量与数组长度的比例。当HashMap中的元素数量超过了capacity * loadFactor时，HashMap会进行扩容。默认的加载因子是0.75，这是一个空间和时间成本之间的折中。
*/
final float loadFactor;对于链表元素，会将其存储在一个叫Node的内部类中，对于红黑树元素，会被存储与TreeNode内部类中：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;//hash值
final K key;//键
V value;//值
Node<K,V> next;//指向下一个元素
...
}
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent;// 父节点
TreeNode<K,V> left;//左子树
TreeNode<K,V> right;//右子树
TreeNode<K,V> prev;// 这是一个指向当前节点的前一个节点的引用。这个字段主要用于在删除节点时，能够从双向链表中移除当前节点。由于HashMap中的红黑树节点也是双向链表的一部分，所以这个字段是必要的。
boolean red;//是否转为红色
...
}在初始化的时候，我们查看其中的一个无参构造：
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // 在调用无参构造，只对加载因子做了初始化，其他都没有初始化。
}当我们进行插入元素时，我们会调用put方法进行添加元素，传入键值对：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);//依次参数是
// 1.对键进行hash（计算键的哈希值以确定它应该存储在哪个桶中）
// 2.键
// 3.值
// 4.是否保留（false时重复会进行覆盖）
// 5.这个布尔值参数用于LinkedHashMap，它指示在插入后是否需要执行额外的操作。在HashMap中，这个参数通常被忽略，因为它不是用来控制标准HashMap行为的。在LinkedHashMap中，这个参数用于确定是否在插入后移除最旧的条目
}接着我们进入putVal方法查看：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//由于table是成员变量放在堆中，而方法在栈中，所以定义一个局部变量（同样存在于栈中）提高效率
Node<K,V>[] tab;
//指向当前数组位置
Node<K,V> p;
//n为数组容量，i为以hash值与数组长度运算得到的插入位置索引（桶索引）
int n, i;
//对tab进行赋值并且判断是否为空，其实就是对我们的数组判断是否为空（还没初始化），调用resize函数进行初始化：
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//判断在数组中，该位置是否为空，为空直接插入
if ((p = tab[i = (n - 1) & hash]) == null)
//将我们的元素插入到数组中。
tab[i] = newNode(hash, key, value, null);
//不为空
else {
Node<K,V> e; K k;
//判断是否重复
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//重复则将存在的元素赋值给e，后续可以用来更新该节点的值。
e = p;
//如果存在的元素的类型是红黑树节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//在原来元素的基础上进行链表插入的操作
else {
//这里开始了一个无限循环，binCount用于记录当前桶中的节点数量。循环将遍历链表中的节点，直到找到合适的插入位置。
for (int binCount = 0; ; ++binCount) {
//在循环内部，首先检查当前节点p的下一个节点e是否为null。如果是null，说明已经到达链表的末尾，可以在这里插入新的节点。
if ((e = p.next) == null) {
//在存在元素上使用尾插法进行插入新元素
p.next = newNode(hash, key, value, null);
//达到树化阈值，对当前哈希桶转换为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
//插入超过即break
break;
}
//在遍历链表的过程中，如果找到了一个具有相同哈希值和键的节点，这意味着找到了一个已经存在的键。
//如果键相等（通过==比较或者equals方法），循环会通过break终止。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//如果没有找到相等的键，或者还没有到达链表末尾，p会更新为下一个节点e，继续循环。
p = e;
}
}
//经过上诉操作之后，如果e不为null则说明已经找到了重复元素
if (e != null) { // existing mapping for key
V oldValue = e.value;
//判断是否要进行覆盖，因为重复时e指向的是重复元素，此时进行重复元素value的覆盖
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//这个方法在HashMap类中是空的，用于LinkedHashMap的位置调整，因为有重复元素覆盖则涉及一个插入顺序打乱
afterNodeAccess(e);
//返回旧值
return oldValue;
}
}
++modCount;
//大于阈值则调用resize准备扩容
if (++size > threshold)
resize();
//它在节点被插入后调用。这个方法在HashMap类中是空的，但在LinkedHashMap中会被覆盖以维护节点的插入顺序。
afterNodeInsertion(evict);
//正常插入返回null
return null;
}在resize方法中，由于我们的容量等于零，所以他会执行其中的：
{
newCap = DEFAULT_INITIAL_CAPACITY;//给我们的容量赋值默认容量16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//给我们的阈值赋值为容量乘以加载因子
}
threshold = newThr;//赋值给成员变量
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//此时才开始初始化存放链表或者红黑树的数组
table = newTab;//将其赋值给成员变量table
...
return newTab;最后将我们的新数组进行返回。以上是其中的一种情况，在resize中有三种情况，以下是其他两种：
//当旧容量大于0，此时调用到resize则说明需要进行扩容操作
if (oldCap > 0) {
//判断旧容量有没有超过最大，超过则设置阈值为Int最大，表示再也不会扩容了。
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//开始扩容，让新容量左移一位即为2倍操作，并进行判断新容量有没有超过阈值。
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//如果以上判断通过则将新阈值变为旧阈值的两倍
newThr = oldThr << 1; // double threshold
}
//当旧阈值大于零且不满足旧容量大于零（以上情况），则说明在创建hashMap时进行了初始化容量，当插入元素时会调用resize来到这个if
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;当扩容之后我们会对对应的成员变量进行赋值，并且让旧数组的元素拷贝到新数组中去：
//阈值更新，即下一次扩容时机
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//创建新数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//将成员变量table赋值新数组
table = newTab;
//这里判断，只要不是初始化就要快开始数组拷贝
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//只有一个元素
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;
//低位：落在新容量的（0，旧容量大小）区域
//高位：落在新容量的（旧容量大小，两倍旧容量）区域
//先使用其hash值判断它在高位区还是低位区，hash与旧容量相与等于零则说明其在低位。
//判断后，就可以把j索引下的一整条链表进行复制
//复制过程就是自己造一条新链表，如落在低位时：
//先使用lohead将头节点保存，其次用lotail.next在循环中将整条链表进行连接
//整条链表复制好了，即走完了dowhile，此时再一次判断是高位还是低位（判断高或低有没有为空）不为空则为高或低位。
//如果是低位直接将头节点插入到新容量数组的j索引处，如果是高位则将头节点插入在新容量（j+旧容量大小）索引处
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;
}
}
}
}
}
return newTab;
