HashMap----源码解读

源码分析：

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 1sttreeifyBin(tab, hash);//插入超过即breakbreak;}
//在遍历链表的过程中，如果找到了一个具有相同哈希值和键的节点，这意味着找到了一个已经存在的键。
//如果键相等（通过==比较或者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 keyV 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);//正常插入返回nullreturn null;
}

在resize方法中，由于我们的容量等于零，所以他会执行其中的：

{               newCap = DEFAULT_INITIAL_CAPACITY;//给我们的容量赋值默认容量16newThr = (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 thresholdnewCap = 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 orderNode<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;elseloTail.next = e;loTail = e;}else {if (hiTail == null)hiHead = e;elsehiTail.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;