HashMap put方法源码解析

先上源码

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

这里先调用了hash方法得到key的hash值（并不是直接得到key的hash，具体可以看hash方法）
然后调用了内部putVal方法，hash,key,value参数不需要多说，onlyIfAbsent 参数 if true, don’t change existing value（翻译过来就是 如果为true则不要更改现有值）

if (!onlyIfAbsent || oldValue == null)
					//这里判断了onlyIfAbsent
                    e.value = value;

evict 参数 if false, the table is in creation mode.(如果为假，则该表处于创建模式。不知道是干啥的)

putVal方法源码

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            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)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        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;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

1. 判断当前table是否为null，或者长度===0 如果是就调用resize()方法扩容
2. 根据hash确定需要插入table的位置 （i = (n - 1) & hash） 如果该位置未空 就直接插入

	if ((p = tab[i = (n - 1) & hash]) == null) {
	      tab[i] = newNode(hash, key, value, null);
	}

3. 需要插入位置不为空，找出需要插入或修改的点赋值给Node<K,V> e，最后再修改e
   3-1. hash值相同且(插入元素key与该位置元素key相等或equals为true)，说明该位置的元素需要被新元素替换(在table同一个位置的元素hash值不一定相同)

   if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
   

   3-2. 如果插入位置元素类型为红黑树，则调用TreeNode的putTreeVal方法

   else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
   

   3-3. 不满足3-1和3-2，那么该位置就是链表(可能只有一个元素),对其进行循环

 	for (int binCount = 0; ; ++binCount) {
         if ((e = p.next) == null) {
               //如果到链表尾部就新添加一个元素
               p.next = newNode(hash, key, value, null);resite
                if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        //判断链表长度超过TREEIFY_THRESHOLD
                        //链表尝试转换成红黑树(当table长度小于64时会进行resize扩容)
                        treeifyBin(tab, hash);
                        break;
          }
          if (e.hash == hash &&
                  ((k = e.key) == key || (key != null && key.equals(k))))
                        //如果在该链表中找到需要替换的节点
                        break;
          p = e;
     }

4. 如果找到需要替换的节点(即put的key已存在)，修改该节点的value，然后返回旧的value

			if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }

5. 如果没有执行步骤4就是没有找到需要替换的节点(即put的key在table中不存在)，属于添加新的节点情况

 	++modCount;   
    if (++size > threshold)
         //如果节点数量超过阈值就会扩容
          resize();
    afterNodeInsertion(evict);
    return null;

这是红黑树结点的put方法
首先要知道一点，hashMap中的红黑树还是双向链表结构

1. 找到插入点
2. 插入
3. 平衡调整

/**
         * Tree version of putVal.
         */
        final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                                       int h, K k, V v) {
            Class<?> kc = null;
            boolean searched = false;
             //先找到红黑树的根节点
            TreeNode<K,V> root = (parent != null) ? root() : this;
            //开始遍历红黑树， 找到插入点
            for (TreeNode<K,V> p = root;;) {
                //dir表示查找方向，遍历的当前ph节点hash，pk当前节点的key
                int dir, ph; K pk;
                if ((ph = p.hash) > h)
                    dir = -1;
                else if (ph < h)
                    dir = 1;
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    //当前节点与目标节点hash和key同时相同，返回当前节点
                    return p;
                //comparableClassFor(x)当x的类型为X，且X直接实现了Comparable接口
                //（比较类型必须为X类本身）时，返回x的运行时类型；否则返回null。
                //compareComparables(kc, k, pk) 如果pk的类型是kc，
                //返回k.compareTo(pk)的比较结果 如果x为空，或者类型不是kc，返回0
                else if ((kc == null &&
                          (kc = comparableClassFor(k)) == null) ||
                         (dir = compareComparables(kc, k, pk)) == 0) {
                    // 走到这里说明：指定key没有实现comparable接口
                    // 或者 实现了comparable接口并且和当前节点的键对象比较之后相等
                    if (!searched) {
                    	//如果没有搜索过，搜索其子节点是否有与指定key匹配的节点
                        TreeNode<K,V> q, ch;
                        searched = true;
                        if (((ch = p.left) != null &&
                             (q = ch.find(h, k, kc)) != null) ||
                            ((ch = p.right) != null &&
                             (q = ch.find(h, k, kc)) != null))
                            return q;
                    }
                    //tieBreakOrder方法是比较k与pk的hashcode来赋值给dir
                    dir = tieBreakOrder(k, pk);
                }
				// 没有找到与入参相同的节点，就插入节点
                TreeNode<K,V> xp = p;
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    //不仅要构建红黑树还要构建双向链表
                    Node<K,V> xpn = xp.next;
                    TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
                    if (dir <= 0)
                        xp.left = x;
                    else
                        xp.right = x;
                    xp.next = x;
                    x.parent = x.prev = xp;
                    if (xpn != null)
                        ((TreeNode<K,V>)xpn).prev = x;
                     //插入节点后要平衡红黑树，平衡红黑树有可能使根节点发生变化，确保table根节点在table下的第一个节点
                    moveRootToFront(tab, balanceInsertion(root, x));
                    return null;
                }
            }
        }