HashMap的get()和put()的底层实现原理

概述

HashMap基于Map接口实现，以键值对（Key-Value）的形式存储数据，允许null值和null键；HashMap不是线程安全的，同时也不保证元素有序。HashMap的底层是以 数组 + 链表 + 红黑树来实现的。

get()的实现

public V get(Object key) {
    Node<K,V> e;	// 哈希表是由一个个Node组成的
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

重点在getNode()方法，把getNode()的源码贴出来：

final Node<K,V> getNode(int hash, Object key) {
    //tab：引用当前hashMap的散列表
    //first：桶位中的头元素
    //e：临时node元素
    //n：table数组长度
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
        //第一种情况：定位出来的桶位元素 即为咱们要get的数据
        if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
            return first;

        //说明当前桶位不止一个元素，可能 是链表 也可能是 红黑树
        if ((e = first.next) != null) {
            //第二种情况：桶位升级成了 红黑树
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            //第三种情况：桶位形成链表
            do {
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;

            } while ((e = e.next) != null);
        }
    }
    return null;
}

流程总结：

1. 通过key的hash值找到该key映射到的桶

2. 如果该桶上首个元素first的key就是要查找的key，即直接命中，则直接返回

3. 如果该桶上的首个元素first的key不是要查找的key，则需要查看后续节点：

   （1）. 如果first属于树节点，则该桶位已经升级成了红黑树，将从红黑树中找我们需要的key

   （2）.否则，后续节点就是链表形式，通过遍历链表来寻找该key

put()的实现

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

重点的是putVal方法，贴出putVal方法的源码：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    //tab：引用当前hashMap的散列表
    //p：表示当前散列表的元素
    //n：表示散列表数组的长度
    //i：表示路由寻址结果（计算出应该放在哈希表的哪个位置）
    Node<K,V>[] tab; Node<K,V> p; int n, i;

    //延迟初始化逻辑，第一次调用putVal时会初始化hashMap对象中的最耗费内存的散列表
    //实际中，如果只创建了HashMap对象但不用，就不会那么耗内存了，只有添加数据的时候才会创建出散列表
    //table是哈希表
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;

    //最简单的一种情况：寻址找到的桶位 刚好是 null，这个时候，直接将当前k-v=>node 扔进去就可以了
    //(n - 1) & hash 是路由算法 ，也即  (table.length - 1) & hash，计算该key应该存放在哈希表的哪个位置
    // 根据键值key计算hash值得到可以插入的数组索引i，判断 tab[i] 是否为null
    if ((p = tab[i = (n - 1) & hash]) == null)
        // tab[i] 为null，表示哈希表的索引i位置没有元素，直接插入
        tab[i] = newNode(hash, key, value, null);
    else {  // 走这里，代表tab[i] 不为null
        //e：不为null的话，找到了一个与当前要插入的key-value一致的key的元素
        //k：表示临时的一个key
        Node<K,V> e; K k;

        //表示桶位中的该元素，与你当前插入的元素的key完全一致，表示后续需要进行替换操作
        // p 是tab[i] ，也就是判断当前插入的元素的key和p的key是否完全一致
        if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
            // 完全一致，把p的引用复制给临时元素 e
            e = p;

        // p 是否是红黑树的节点
        else if (p instanceof TreeNode)//红黑树，下期讲。进QQ群:865-373-238
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 链表的情况，而且链表的头元素与我们要插入的key不一致。（如果一致的话，在第一次判断的时候就找到了）
            for (int binCount = 0; ; ++binCount) {
                //条件成立的话，说明迭代到最后一个元素了，也没找到一个与你要插入的key一致的node
                //说明需要加入到当前链表的末尾仍然没有找到与当前要插入的一致的元素，就在尾部插入    尾插  jdk1.7是头插
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //条件成立的话，说明当前链表的长度，达到树化标准了，需要进行树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        //树化操作
                        treeifyBin(tab, hash);
                    break;
                }
                //条件成立的话，说明在链表中找到了相同key的node元素，需要进行替换操作
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }

        //e不等于null，条件成立说明，找到了一个与你插入元素key完全一致的数据，需要进行替换
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    
    //modCount：表示散列表结构被修改的次数，替换Node元素的value不计数
    ++modCount;
    //插入新元素，size自增，如果自增后的值大于扩容阈值，则触发扩容。
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

put过程总结：

1. 先通过hash值计算出来key应该放在哪个桶

2. 如果该桶没有元素，即没有出现哈希冲突，则直接把元素插入到该桶位上

3. 如果出现了哈希冲突，则有两种情况：

   （1）如果该桶使用红黑树处理哈希冲突，则调用红黑树的方法插入

   （2）否则就使用链表的方法插入；同时，如果链表的长度超过8（到达9）并且哈希表的大小>=64，就将链表转换成红黑树

4. 第三步插入的时候如果找到和要插入的key、key的hash值都一致的元素，则将其替换掉

5. 如果哈希表中占用的桶位数超过了扩容阈值，则进行扩容