HashMap深度解析

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // 判断数组长度是否小于最小数组长度阈值
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 默认初始大小
static final int MAXIMUM_CAPACITY = 1 << 30; //最大容量 2的30次方
static final float DEFAULT_LOAD_FACTOR = 0.75f; //默认加载因子（负载因子）
static final int TREEIFY_THRESHOLD = 8; //当前链表长度转红黑树的阈值
static final int UNTREEIFY_THRESHOLD = 6; //红黑树转链表的阈值
static final int MIN_TREEIFY_CAPACITY = 64; //链表转红黑树的数组长度阈值

/* EntrySet实体,定义成变量可以保证不被重复创建，是一个Map.Entry集合
* Map.Entry是一个接口，HashMap的内部类Node就实现了该接口
*/
transient Set<Map.Entry<K,V>> entrySet; 

/* 用来存储HashMap中的键值对，是一个Node数组
* Node是一个内部类，实现了Map.Entry接口，就是一个单向链表
*/
transient Node<K,V>[] table;

/* 记录HashMap中键值对的数量，put和remove都会对其造成改变*/
transient int size;

/* 当HashMap内部结构发生变化时才会修改
* 当HashMap内部结构发生改变时时则会++modCount
*/
transient int modCount;

/* threshold表示一个临界值，当HashMap的size大于这个值的时候进行resize */
int threshold;

// 指定初始大小和加载因子
public HashMap(int initialCapacity, float loadFactor) {...}

// 指定初始大小
public HashMap(int initialCapacity) {...}

// 无参构造，全部使用默认常量
public HashMap() {...}

// 使用现有的Map来构造HashMap
public HashMap(Map<? extends K, ? extends V> m) {...}

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) {...}

    public final K getKey()        {...}
    public final V getValue()      {...}
    public final String toString() {...}

    public final int hashCode() {...}

    public final V setValue(V newValue) {...}

    public final boolean equals(Object o) {...}
}

// 调用put方法
public V put(K key, V value) {
    // 这里调用了putVal方法
    return putVal(hash(key), key, value, false, true);
}

// 判断当前表中是否为空（是不是第一次添加元素）
if ((tab = table) == null || (n = tab.length) == 0)
    // 进入resize方法
    n = (tab = resize()).length;

// 以下内容以程序运行流程
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;

newCap = DEFAULT_INITIAL_CAPACITY; //16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //16 * 0.75 
threshold = newThr; //将新的临界值赋值给threshold
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //创建一个16长度的Node数组
table = newTab; //将长度16的数组赋值给变量table
return newTab; //将Node数组返回

if ((tab = table) == null || (n = tab.length) == 0)
    // 刚刚进入如下方法，得到n为初始化的数组长度16
    n = (tab = resize()).length;
// 通过&位运算 得到i=1，判断Node数组索引1的元素是否为空
if ((p = tab[i = (n - 1) & hash]) == null)
    // 进入newNode方法，该方法会根据参数创建一个单向链表
    tab[i] = newNode(hash, key, value, null);
//这里省略不执行的代码
...
// 由于进行了初始化，所以HashMap内部结构发生了变化，所以++modCount
++modCount;
// 这里判断了HashMap的键值对数量是否大于扩容阈值
if (++size > threshold)
    resize();
// 该方法是为了继承HashMap的LinkedHashMap类服务，这里没有实际作用
afterNodeInsertion(evict);
// 到这里第一次调用put就结束了
return null;

Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
    // 返回Node链表
    return new Node<>(hash, key, value, next);
}