HashMap之put()源码剖析

HashMap是Map集合下的常用子类，出现在JDK1.2，底层使用哈希表+红黑树实现。

之前我们在学习Set接口的时候，并没有深入研究过其代码，但当我们查看Set接口常用子类HashSet的源码时，会发现Set其实就是穿了马甲的Map：

private transient HashMap<E,Object> map;

private static final Object PRESENT = new Object();

public HashSet() {
        map = new HashMap<>();
    }

public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

可见，在HashSet的内部有一个私有的HashMap对象，在调用构造方法时实例化此HashMap对象。再来看看其add(E e)方法：

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

可见，HashSet实际上是通过HashMap来存储元素的，只不过是将元素存储到了HashMap的key而已，而value都是共同的一个空的Object对象。

1.Set与Map的关系：
通过上面的分析我们不难得出，Set接口其实就是穿了马甲的Map接口，Set接口下的常用子类都是使用Map来存储元素的，将元素存储在Map的key中，而value是共同的空Object对象。

可见，学习Map接口下的常用子类，就相当于学习了Set接口下的常用子类。

所以，我们今天来看一看Map接口下的常用子类HashMap的源码：

2.HashMap源码的重要参数：

//初始化容量，即：桶的数量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;

//默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

//树化阈值
static final int TREEIFY_THRESHOLD = 8;

//解树化返回链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;

//树化的最小元素个数
static final int MIN_TREEIFY_CAPACITY = 64;

//真正存储元素的哈希表
transient Node<K,V>[] table;

//扩容阈值：用来判断是否需要扩容
//也可以认为是真正存储元素的桶数量 = 负载因子 * 默认初始化桶数量
int threshold;

3.HashMap的构造方法：

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

可见，HashMap采用懒加载策略，在调用构造方法时并不会初始化哈希表，只会初始化负载因子。

4.HashMap的put(K key,V value)：

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

可见，put方法实际上是先将我们的key值进行hash()，再调用putValue()方法：
hash()实际上是为了找到元素所在的桶的位置，(h>>>16)是无符号右移，相当于保留了高16位。

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        //(h = key.hashCode()) ^ (h >>> 16)其实是为了让高低16位都参与异或运算，从而降低哈希冲突的概率
    }

接下来，看一下putVal()：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //存储元素的哈希表
        Node<K,V>[] tab; 
        //存放数据的节点
        Node<K,V> p; 
        //n为哈希表的长度，i为元素在哈希表中的索引
        int n, i;
        //若当前哈希表为空，则进行哈希表的初始化操作
        //(默认初始化为16个桶，实际上真正存储元素的桶数量threshold为12)
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //根据i=(n-1)&hash计算出元素在哈希表中存储的索引
        //如果当前索引为空，没有元素，即未发生碰撞，则将该节点存放到哈希表中
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //此时说明发生了碰撞
        else {
            Node<K,V> e; K k;
            //若节点处于同一个桶中，并且key值相同，则替换该节点
            //可见，此处就实现了HashMap存储元素时，一个Key值只对应一个元素
            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;
                }
            }
            //若哈希表中存在key值相同的元素，则替换该元素的value值
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //若桶数量>12，则进行扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

总结：

• 首先，判断哈希表是否为空，若为空，则为哈希表进行初始化，默认初始化容量为16。
• 根据hash()计算得到的桶位置，计算元素在哈希表中的索引，若当前索引位置没有元素，则将这个元素添加到索引处即可。
• 若当前位置有元素，并且key值相同，则替换该元素。
• 若此时已经树化，则调用树化的put()方法插入。
• 若此时还未树化，则封装为节点尾插入链表中。判断是否满足树化条件，若满足，树化插入；不满足，则往下走。
• 遍历链表，判断是否有key值相同的元素，若有，替换其value值。
• 插入成功后，判断当前桶数量是否大于12，若满足扩容条件则进行扩容。