HashMap高频面试题，让你掌握青铜回答与王者级回答，你值得拥有

public V put(K key, V value) {
    // 如果哈希表为空，则对其进行申请数组空间
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }

    // 如果 key 为 null，则将其放入 null 键的特殊位置
    if (key == null) {
        return putForNullKey(value);
    }

    // 计算 key 的哈希值
    int hash = hash(key);

    // 根据哈希值和哈希表的长度计算索引位置
    int i = indexFor(hash, table.length);

    // 遍历索引位置上的链表，寻找 key
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        // 如果 key 相同，则更新 value 并返回旧值
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    // 如果 key 不存在，则添加一个新的链表成员
    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

static class Entry<K, V> implements Map.Entry<K, V> {

    final int hash;
    final K key;
    V value;
    Entry<K, V> next;

    Entry(int hash, K key, V value) {
        this.hash = hash;
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Entry<?, ?> entry = (Entry<?, ?>) o;
        return hash == entry.hash &&
        Objects.equals(key, entry.key) &&
        Objects.equals(value, entry.value);
    }

    @Override
    public int hashCode() {
        return Objects.hash(hash, key, value);
    }

    @Override
    public String toString() {
        return key + "=" + value;
    }
}

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    // 获取哈希表
    Node<K,V>[] tab = table;
    // 如果哈希表为空或长度为0，则进行扩容
    if (tab == null || tab.length == 0) {
        tab = resize();
    }
    // 计算索引位置
    int n = tab.length;
    int i = (n - 1) & hash;

    // 如果索引位置上的节点为空，则添加一个新的节点
    Node<K,V> p = tab[i];
    if (p == null) {
        tab[i] = newNode(hash, key, value, null);
    } else {
        // 如果索引位置上的节点存在，则遍历链表，寻找 key 相同的节点
        Node<K,V> e; K k;
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) {
            e = p;
        } else if (p instanceof TreeNode) {
            // 如果索引位置上的节点是红黑树节点，则调用红黑树的 putTreeVal() 方法添加新的节点
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        } else {
            // 如果索引位置上的节点是链表节点，则遍历链表，寻找 key 相同的节点
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    // 如果没有找到 key 相同的节点，则在链表尾部添加一个新的节点
                    p.next = newNode(hash, key, value, null);
                    // 如果链表长度超过阈值，则将链表转换为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) {
                        treeifyBin(tab, hash);
                    }
                    break;
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                    // 如果找到 key 相同的节点，则停止遍历
                    break;
                }
                p = e;
            }
        }

        if (e != null) { // 找到 key 相同的节点
            // 获取旧值
            V oldValue = e.value;
            // 如果只有 key 不存在才添加新的节点，则仅当旧值为 null 时才更新值
            if (!onlyIfAbsent || oldValue == null) {
                e.value = value;
            }
            // 调用 afterNodeAccess() 方法更新节点的访问时间
            afterNodeAccess(e);
            return oldValue;
        }
    }

    // 添加新的节点后，更新 HashMap 的大小和修改次数
    ++modCount;
    if (++size > threshold) {
        resize();
    }
    // 调用 afterNodeInsertion() 方法更新节点的插入状态
    afterNodeInsertion(evict);
    return null;
}

final void treeifyBin(Node<K,V>[] tab, int hash) {
    // 如果哈希表为空或长度小于 MIN_TREEIFY_CAPACITY，则进行扩容
    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);
        }
    }
}