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 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;