HashMap中的putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)解读

在面试中我们会经常遇到关于HashMap的问题，这里我写了我对HashMap里面一个挺重要的方法 putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)的理解，下面就是我对这个方法的理解。

其实putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)方法我们是没有办法直接调用的，其实在我们使用put(K key,V val)时，它里面的内部就调用了putVal方法。

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

先讲讲putVal方法里面的几个参数的作用

 /**
     *
     * @param hash  由key计算出来的 hash值
     * @param key   要存储的key
     * @param value  要存储的value
     * @param onlyIfAbsent  如果当前位置已存在一个值，是否替换，false是替换，true是不替换
     * @param evict  表是否在创建模式，如果为false，则表是在创建模式。
     */

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict)

下面的一张图简单解释了putVal方法的作用

我将这个过程分为了7步，分别是：

1、检查table是否为空，如果为空就初始化

2.检查table中位置为(n -1 ) & hash 是否为空，如果为空，直接放入（这是放在数组里）

3.如果桶中存在的元素的key和hash都相等，直接覆盖旧value

4.判断存放该元素的链表是否转为红黑树，如果为红黑树，直接插入，此时上面3是不成立，hash值不相等，也就是key值不等(hash值是由key算出来的)

5.第3和第4都不成立，将插入元素存放在链表中（也有可能是红黑树）

6.存在key值和hash值相等的，直接覆盖旧value

7.将记录修改次数加1，判断是否需要扩容，如果需要就扩容

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
       Node<K, V>[] tab;
       Node<K, V> p;
        int n, i;
        //1、检查table是否为空，如果为空就初始化
        if ((tab = table) == null || (n = tab.length) == 0)
        //  初始化，也是扩容
            n = (tab = resize()).length;
         //2.检查table中位置为(n -1 ) & hash 是否为空，如果为空，直接放入（这是放在数组里）
        if ((p = tab[i = (n - 1) & hash]) == null)
        //放入
            tab[i] = newNode(hash, key, value, null);
            //桶中已经存在元素了，也就是说 table中( n -1) & hash这个位置不为空(发生碰撞了)
        else {
            Node<K, V> e;
            K k;
            //3.如果桶中存在的元素的key和hash都相等，直接覆盖旧value
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
                //4.判断存放该元素的链表是否转为红黑树，如果为红黑树，直接插入，此时上面3是不成立，hash值不相等，也就是key值不等(hash值是由key算出来的)
            else if (p instanceof TreeNode)
            //存放在红黑树里
                e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
                //5.第3和第4都不成立，将插入元素存放在链表中
            else {
            //循环链表，找到链表末尾插入元素
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //判断当前链表的元素是否超过要转换为红黑树的阈值 (节点数超过8就要转换为红黑树)
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                           //转换为红黑树存储
                            treeifyBin(tab, hash);
                        break;
                    }
                    //遍历链表，看链表中是否存在hash和key与要插入进来的元素相同，如果相同，跳出循环。
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                            //跳出循环
                        break;
                     // 跟 e = p.next 组成用来遍历链表。
                    p = e;
                }
            }
            //6.存在key值和hash值相等的，直接覆盖旧value
            if (e != null) { // existing mapping for key
            //取出e的value
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                //覆盖
                    e.value = value;
                    //访问后回调
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //7.将记录修改次数加1，判断是否需要扩容，如果需要就扩容
        ++modCount;
        if (++size > threshold)
            resize();
            //插入后回调
        afterNodeInsertion(evict);
        return null;
    }

这里借助一张图片更容易理解

图片来自这里，觉得图片更容易看懂这个方法工作的流程。