详解HashMap的put方法在JDK 7和JDK 8的实现

JDK 7

1.put(K key, V value)方法

public V put(K key, V value) {
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key.hashCode());
    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;
}

putForNullKey(value)方法

该方法用于处理当key为null的元素，默认将该元素放置在数组的0号位置上，插入时，优先判断当前位置上是否存在key为null的元素，如果存在则进行覆盖并且返回旧值；否则，采用头插法将该元素插入。

private V putForNullKey(V value) {
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        // 遍历0号位置上的元素，因为可能为链表，覆盖第一个元素的key也为null的值，并且返回旧的值
        if (e.key == null) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    // 如果原来的0号位置没有key为null的元素，那么就采用头插法将元素插入
    addEntry(0, null, value, 0);
    return null;
}

hash(key.hashCode())方法

hash值（int型，32位）先进行位移运算再进行异或（^）运算，这样就可以综合hash值得高位和低位特征，减少hash冲突，这个函数也叫扰动函数。

异或（^）：两个位相同为0，相异为1。相异得那位在和length-1进行与操作时结果为1

static int hash(int h) {
    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

indexFor(hash, table.length)

key的hashcode经过hash扰动函数处理后的值再和length-1进行与运算，相当于对length-1取模运算，计算出元素在数组的下标。

static int indexFor(int h, int length) {
    return h & (length-1);
}

判断是否需要进行旧值覆盖

当key不为null，并且根据key计算出元素在数组的下标位置后，开始插入元素

因为当前下标的元素可能时一个链表，所以使用for循环遍历，当元素的key相等（hash和值（基本类型或者引用类型）都相等）那么就对该位置下老元素的值进行覆盖操作，并且返回旧值。

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;
    }
}

addEntry(hash, key, value, i)方法

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 取出该位置上的老entry
    Entry<K,V> e = table[bucketIndex];
    // 新建一个entry并且将新的entry放在指定位置上，新entry的next指针指向该位置的老entry，这就是头插法
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    // 判断是否需要扩容
    if (size++ >= threshold)
        resize(2 * table.length);
}

JDK 8

1.put(K key, V value)方法

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

hash(key)方法

• key为null，返回hash值为0；
• key不为null，key的hashCode通过高16位和低16位进行异或运算，达到一个扰动函数的效果，目的也是为了减少hash冲突。

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

putVal(hash(key), key, value, false, true)方法

/**
 * Implements Map.put and related methods.
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don't change existing value
 * @param evict if false, the table is in creation mode.
 * @return previous value, or null if none
 */
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.如果数组为空，初始化一个长度为16的Node数组
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 2.如果目标位置的元素为null，插入新的node节点，并且新的node节点next指针置为null
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 3.如果目标位置上已经存在元素且元素不为null
    else {
        // 3.1 p为目标位置上的元素，旧值
        
        Node<K,V> e; K k;
        // 3.2 首先判断目标下标位置上的元素的hash值和key值是否完全相等，如果相等，直接进行替换（具体是否需要替换还要看onlyIfAbsent参数）
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 3.3 如果是红黑树，按照树的方法插入（暂不深入讨论）
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 3.4 不是红黑树，那么就是链表
            for (int binCount = 0; ; ++binCount) {
                // 3.4.1 从链表的头部开始往下查找直到找到链表尾部，直接将新的node拼接在链表后面
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 3.4.2 如果链表长度达到指定长度8，进行链表转红黑树的操作
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // 如果在遍历链表的过程中，发现链表中存在key相同的元素，则跳出链表遍历，直接考虑覆盖旧值的操作
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 4.目标位置的旧值不为空，根据onlyIfAbsent判断是否需要进行值覆盖
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 5.超过阈值，进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}