HashMap插入源码解析

HashMap在JDK1.7版本头插法实现解析

​ 先解释下何为头插法。大家都知道HashMap在JDK1.7版本的数据结构为数组+链表这样的形式。而头插法说的就是在往HashMap里面put元素时，此时新增在链表上元素的位置为链表头部，也就是数组桶位上的那个位置，故名头插法

​ 直接上源码，看看JDK1.7的元素插入代码实现：

 public V put(K key, V value) {
	    // 步骤1
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        // 步骤2
        if (key == null)
            return putForNullKey(value);
        // 步骤3
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(hash, key, value, i);//头插法的实现开始
        return null;
    }

稍微解释下前面代码流程：
1、如果往HashMap里面put元素的时候，发现还是空的未初始化（HashMap采用懒加载，用到的时候再去初始化），那就调用inflateTable(threshold)先给它初始化了先。
2、如果put元素的时候key为null，则进入putForNullKey(value)方法处理，大概逻辑就是将key为0的key-value放入entry,如果之前已有key为null的key-value键值对，则返回原value,否则返回null。
3、接下来就是取key的hash再做位操作（之所以不直接使用hashCode是为了加大低位信息的随机性，变相让高位数据参与到计算中）、然后获取元素key值运算得到数组的下标，最后再判断是否有相同key存在于entry,有就新value覆盖旧value然后返回旧value。

直到addEntry(hash, key, value, i)才是头插法的实现开始：

   void addEntry(int hash, K key, V value, int bucketIndex) {
            if ((size >= threshold) && (null != table[bucketIndex])) {
                resize(2 * table.length);
                hash = (null != key) ? hash(key) : 0;
                bucketIndex = indexFor(hash, table.length);
            }
    
            createEntry(hash, key, value, bucketIndex);
        }

if里面判断是否需要扩容，可先忽略接着看 createEntry(hash, key, value, bucketIndex)：

   void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

注意这个参数bucketIndex，它是之前用key的哈希值做过位运算之后再去找数组运算得到的下标。如果要讲key-value这个键值对放入hashmap的话，就会放到数组的这个位置或者这个位置的链表上。

Entry<K,V> e = table[bucketIndex]这一句则取到数组上这个下标的元素，然后作为new Entry<>(hash, key, value, e)的参数e：

 Entry(int h, K k, V v, Entry<K,V> n) {
        value = v;
        next = n;
        key = k;
        hash = h;
    }

​ 从代码可以得知，这个构造方法，利用key-value构造了一个entry,然后把它的next属性（类似链表的后继节点）指向原table[bucketIndex]，然后在上一层方法中复制给了table[bucketIndex]，实际效果就是想当于把该下标下的链表整体往下移了一部，再用新构造的entry放在链表头（同时也是数组上该下标的位置）。这就是jdk1.7版本hashmap元素在put时的头插法。

​ 至于为什么会采用头插法，据说是考虑到热点数据的原因，即最近插入的元素也很可能最近会被使用到。所以为了缩短链表查找元素的时间，所以每次都会将新插入的元素放到表头。

知识拓展

​ 这里再稍微拓展下，大家都知道数组查找元素快，而插入或删除元素慢；而链表恰恰相反，查找元素慢，插入或删除快。这是因为两个的数据结构不同而导致的。
​ 数组因为有下标的存在，可以直接根据下标定位到相应元素。而在插入元素或删除元素时，却需要移动该元素后面所有的元素，所以开销会比较大。
​ 而链表没有下标的存在，想要查找元素只能从头结点顺着往下找，若链表非常长且目标元素恰巧在链表尾部，花费的时间相对而言也不短了。同时链表有前继节点与后继节点的存在，当需要插入或删除元素时，只需要修改两个节点的前继节点与后继节点的指向就行了，这也是为什么链表新增或删除元素要比数组快的原因。

HashMap在JDK1.8版本尾插法实现解析

​ 先解释下何为尾插法。大家都知道HashMap在JDK1.8版本经过优化之后，整体的数据结构变成了数组+链表+红黑树这样的形式。而尾插法说的就是在往HashMap里面put元素时，数组桶位上面还是未转化为红黑树的链表，此时新增在链表上元素的位置为链表尾部，故名尾插法。

​ 前面聊了HashMap在JDK1.7版本的头插法实现，现在看看HashMap到了JDK1.8版本升级之后的变化。先上代码：

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

平时java代码都是调的这个方法，实际实现是putVal(hash(key), key, value, false, true)：

  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;
            // key的hash值经过位运算之后再和数组长度-1得到的值运算得到key在数组的下标
            // 若数组的这个位置还没有元素则直接将key-value放进去
            if ((p = tab[i = (n - 1) & hash]) == null)
                tab[i] = newNode(hash, key, value, null);
            else {
	            // 若该下标位置已有元素
                Node<K,V> e; K k;
                // 是否已有元素的key值与新增元素的key判断是同一个
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    // 直接覆盖value
                    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;
                    }
                }
                /**
                * 删除部分代码 
                */
            }
            ++modCount;
            if (++size > threshold)
                resize();
            afterNodeInsertion(evict);
            return null;
        }

接下来看 p.next = newNode(hash, key, value, null)这一句的具体方法实现，这也是HashMap在JDK1.8尾插法的实现了：

    Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
        return new Node<>(hash, key, value, next);
    }

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

​ 在这个方法里面，构造了一个新节点Node(JDK1.8的新实现，继承自Entry<K,V>)，后继节点指向null说明它在链表的位置后面是没有元素的。

​ 而在p.next = newNode(hash, key, value, null)这一句，是将新构造的Node节点指向原来遍历链表查找到的最后一个元素的后继节点。最终的效果其实就是将新元素追加到链表的尾部了，这也就是HashMap在JDK1.8的尾插法。

注意

​ 1、在前面提到链表遍历查找元素是比较慢的，在HashMap中put元素发现数组桶位上已有元素，接着遍历桶位上的链表查找是否有相同key的过程称为hash碰撞，这是比较耗性能的。而为了避免链表过长遍历时间过大的问题，在JDK1.8采用了数据+链表+红黑树的结构。在往链表上新增元素时发现链表长度超过8时，会进入链表转红黑树的方法，然后再判断数组长度是否不小于64，若满足条件则将链表转化为红黑树。

​ 2、至于JDK1.8的链表插入元素为什么改为了尾插法，则是为了避免出现逆序且链表死循环的问题（JDK1.7的HashMap扩容导致死循环）。