HashMap putVal 源码解析-JDK1.8

HashMap put 方法解析

jdk1.8中，put方法的源码如下

 /**
     * Associates the specified value with the specified key in this map.
     * If the map previously contained a mapping for the key, the old
     * value is replaced.
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @return the previous value associated with key, or
     *         null if there was no mapping for key.
     *         (A null return can also indicate that the map
     *         previously associated null with key.)
     */
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
复制代码

putVal方法传入参数
hash(key)：将要存放的key进行hash运算

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
复制代码

• ​ key: 存放的key
• ​ value：存放的值
• onlyIfAbsent：如果为true，不改变已存在的value值，就是当将要存的key与map中的key相同时，不用新值替换久值
• ​ evict：如果为false，表示处于创建模式

putVal 源码

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node[] tab; Node p; int n, i;
    // table 定义  transient Node[] table;
    // tab = table 将table 赋值给tab 并判断是否为空，tab.length赋值给n，判断长度
    if ((tab = table) == null || (n = tab.length) == 0)
        // 调用resize方法，重新计算容量，并把长度给n
        n = (tab = resize()).length;
    // 判断在  tab在  (n - 1) & hash   有不有值，没有值就直接将要存放的数据放进去
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
     // 否则，可能是有hash冲突了，需要判定了 
        Node e; K k;
        // 这里通过旧数据的 hash值与将要存入的hash值，以及key值对比，如果是一样的，将map里面这个元素赋值给e
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果不冲突，在判断当前是否为树结构，是树将要存入的元素加入到树节点中去
        else if (p instanceof TreeNode)
            e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
        else {
        // 如果又不冲突，又不是树结构，则开始遍历，这是一个死循环，必须通过break退出
            for (int binCount = 0; ; ++binCount) {
                // 找到链表的尾部，将数据直接插入链表尾部（尾插法）
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 请注意，当数组的大小>=7的时候，hashmap会转换为红黑树结构，但是不是一定会转，treeifyBin方法会判断
                    // if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize();
                    // 当传入的 tab 为空或者 hash tab的长度小于 （MIN_TREEIFY_CAPACITY=64）时，它其实只会扩容，并不会转换为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 这里表示 有重复的key值，通过判断 是否需要用新值去替换久值，并且返回久值
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    // modCount 表示这个hashmap结构修改的次数，用于迭代器使用
    ++modCount;
    //  size map中的key-value 个数
    // threshold 表示下一次进行扩容的大小，它是由  (capacity *  load factor) 计算出来的
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

参考：《2020最新Java基础精讲视频教程和学习路线！》
链接：https://juejin.cn/post/693869...