由浅入深谈HashMap（二）JDK1.8 put方法源码解析

 

此篇博客主要讲述HashMap的put方法。

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

上述是HashMap源码的put方法，入参是键跟值， 然后调用putVal方法

下面就来看看putVal方法的具体实现:

//HashMap的put方法源码
 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;
    }

先来分析一下此方法的入参，入参有5个，分别是：

*  hash： 要放入的键的hash值
*  key： 要放入的键
*  value：要放入的值
*  onlyIfAbsent ：布尔值，如果为true,则不改变已经存在的value值，如果为false,则反之
*  evict ：如果为false,数组为正在创建模式，所以一般默认为true

方法的返回对象是V，返回的是以前的value,如果没有，则返回null.这里来解释下这句话的具体意思。

 Map<String,Integer> map = new HashMap<>();
 System.out.println("返回值:"+map.put("张三",34));

此时的map里，key值为张三的只有一个，所以，返回的结果为null.

下面的代码跟上述一样，也是返回的是null。

Map<String,Integer> map = new HashMap<>();
map.put("李四",27);
System.out.println("put返回值:"+map.put("张三",34));

下面的代码返回值则是上一个key的value值，返回结果为40.

        Map<String,Integer> map = new HashMap<>();
        map.put("张三",27);
        map.put("张三",40);
        System.out.println("put返回值:"+map.put("张三",34));

         好了，回归正题，解析代码之前先画出方法的大致流程图如下，然后根据流程图，再去看代码，会更清楚！

1.

先判断是否hash冲突，如果没有，则直接插入数组中即可。

Node<K,V>[] tab; Node<K,V> p; int n, i;

tab是数组，p是要数组中老的节点，n是数组的长度，i是数组的下标。 

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

 通过（n-1）&hash计算出数组的下标值，如果此时数组的该位置为空，即没有发生冲突时，直接插入数组中即可。

 

当发生冲突时，首先判断要老节点p与要插入节点的key值，如相等，将节点p赋给e。

            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

大概意思就是这样，当数组里已经有key值为张三的对象了，此时，再放入key值为张三的对象时，后面新的张三就会覆盖前者。

 下述代码的结果为40

      
        Map<String,Integer> map = new HashMap<>();
        map.put("张三",27);
        map.put("张三",40);
        Iterator<String> itor = map.keySet().iterator();
        while(itor.hasNext()){
            String key = itor.next();
            System.out.println(map.get(key));
        }

接下来再判断数据结构是链表还是红黑树

2.

此时如若数据结构是红黑树时，则直接插入红黑树中。

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

3.

                for (int binCount = 0; ; ++binCount) {
                  //   3.1
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                 //   3.2
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                //  3.3
                    p = e;
                }

此时如若数据结构是链表时，上述代码可分为三个部分：

3.1部分的代码的意思是指：

1. 当要插入的节点p的下一个节点为空时，则创建一个新的节点，并将p.next指向新的节点，跳出for循环
2. 当要插入的节点p的下一个节点为空的前提下，如果链表的长度>8了，那我就转成红黑树，跳出for循环

3.2部分的代码的意思是指：

  当要插入的节点p的下一个节点e不为空时，e的hash值与key值均与要插入的元素的相等，则直接跳出循环

3.3部分的代码的意思是指：

在上述两种条件均不满足的情况下，将p的指针指向e的位置

为了更加清楚的说明，下面用图来清楚的说明：

1.  如下图，e=p.next!=null 并且e的hash值与key值均与要插入的元素的不相等，

运行3.3部分的代码，p=e后，如下图所示：

 

此时，e=p.next!=null 并且e的hash值与key值均与要插入的元素的不相等，运行3.3部分的代码，p=e后，如下图所示：

 此时，e=p.next!=null 并且e的hash值与key值均与要插入的元素的不相等，运行3.3部分的代码，p=e后，如下图所示：

此时，e=p.next==null,运行3.1部分的代码， 创建一个新的节点，并将p指向新的节点,如下图所示：

由上述的流程，我们可以发现，其实jdk1.8里面采用的是节点从尾部插入的方式，即尾插法。 

 4.

按照上述方式，当链表的长度>8时，转换成红黑树。

接着往下看代码：

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

如果e!=null,即存在与插入的key相等的元素了，将老的元素的值赋值给oldValue，传入的onlyIfAbsent为false，表示改变已经存在的值，或者oldValue为null的时候，将新的value值覆盖掉老的value。

       ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);

modCount表示的是HashMap被结构性修改的次数，结构性修改是指更改了HashMap或以其他方式修改其内部结构（例如：重新Hash）,接下来判断，如果容量已经大于所能容纳的key-value对阈值 ，则需要扩容，扩容部分源代码将在下一篇讲解。

好了，这篇描述put方法的源码解析就到这里啦~~