1. // 参数onlyIfAbsent表示是否替换原值
    2. // 参数evict我们可以忽略它，它主要用来区别通过put添加还是创建时初始化数据的
    3. final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
    4.                 boolean evict) {
    5.     Node<K,V>[] tab; Node<K,V> p; int n, i;
    6.     // 空表，需要初始化
    7.     if ((tab = table) == null || (n = tab.length) == 0)
    8.         // resize()不仅用来调整大小，还用来进行初始化配置
    9.         n = (tab = resize()).length;
    10.     // (n - 1) & hash这种方式也熟悉了吧？都在分析ArrayDeque中有体现
    11.     //这里就是看下在hash位置有没有元素，实际位置是hash % (length-1) 求余运算10%3=1
    12.     if ((p = tab[i = (n - 1) & hash]) == null)
    13.         // 将元素直接插进去
    14.         tab[i] = newNode(hash, key, value, null);
    15.     else {
    16.         //这时就需要链表或红黑树了
    17.         // e是用来查看是不是待插入的元素已经有了，有就替换
    18.         Node<K,V> e; K k;
    19.         // p是存储在当前位置的元素
    20.         if (p.hash == hash &&
    21.             ((k = p.key) == key || (key != null && key.equals(k))))
    22.             e = p; //要插入的元素就是p，这说明目的是修改值
    23.         // p是一个树节点
    24.         else if (p instanceof TreeNode)
    25.             // 把节点添加到树中
    26.             e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
    27.         else {
    28.             // 这时候就是链表结构了，要把待插入元素挂在链尾
    29.             for (int binCount = 0; ; ++binCount) {
    30.                 //向后循环
    31.                 if ((e = p.next) == null) {
    32.                     p.next = newNode(hash, key, value, null);
    33.                     // 链表比较长，需要树化，
    34.                     // 由于初始即为p.next，所以当插入第8个元素才会树化
    35.                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    36.                         treeifyBin(tab, hash);
    37.                     break;
    38.                 }
    39.                 // 找到了对应元素，就可以停止了
    40.                 if (e.hash == hash &&
    41.                     ((k = e.key) == key || (key != null && key.equals(k))))
    42.                     break;
    43.                 // 继续向后
    44.                 p = e;
    45.             }
    46.         }
    47.         // e就是被替换出来的元素，这时候就是修改元素值
    48.         if (e != null) { // existing mapping for key
    49.             V oldValue = e.value;
    50.             if (!onlyIfAbsent || oldValue == null)
    51.                 e.value = value;
    52.             // 默认为空实现，允许我们修改完成后做一些操作
    53.             //这里其实是插入成功后执行的，获得的效果就是将e放到了链表结尾。
    54.             //所以afterNodeInsertion方法就算什么都不做也可以。
    55.             //如果accessOrder为false，那么我们新插入的节点，都不会进入链表了，那LinkedHashMap是在什么时候将元素插入到链表尾部呢？原因在
    56.             //如果LinkedHashMap
    57.             afterNodeAccess(e);
    58.             return oldValue;
    59.         }
    60.     }
    61.     ++modCount;
    62.     // size太大，达到了capacity的0.75，需要扩容
    63.     if (++size > threshold)
    64.         resize();
    65.     // 默认也是空实现，允许我们插入完成后做一些操作
    66.     afterNodeInsertion(evict);
    67.     return null;
    68. }

    简要流程如下：

    • 首先根据 key 的值计算 hash 值，找到该元素在数组中存储的下标；
    • 如果数组是空的，则调用 resize 进行初始化；
    • 如果没有哈希冲突直接放在对应的数组下标里；
    • 如果冲突了，且 key 已经存在，就覆盖掉 value；
    • 如果冲突后，发现该节点是红黑树，就将这个节点挂在树上；
    • 如果冲突后是链表，判断该链表是否大于 8 ，如果大于 8 并且数组容量小于 64，就进行扩容；
    • 如果链表长度大于 8 并且数组的容量大于等于 64，则将这个结构转换为红黑树；
    • 否则，链表插入键值对，若 key 存在，就覆盖掉 value。