Java集合之HashMap源码分析（面试总结）

梳理HahsMap知识，文章结构及思路如下：

一、主要特点

二、继承关系

三、数据结构

数组+链表+红黑树（JDK1.8增加了红黑树部分）

谈一下1.7和1.8中hashMap的优化

HashMap是线程安全的吗？有什么办法线程安全吗

讲一下几个主要函数的逻辑思路吧 get(),put(),resize(),replace(),remove()

六、参考资料

一、主要特点

底层实现是链表数组+红黑树，拉链法
key 用 Set 存放，不允许重复，key 如果用对象则需要重写 hashCode 和 equals 方法
允许空键和空值，但空键只有一个
元素是无序的，而且顺序会不定时改变
插入、获取的时间复杂度基本是 O(1)（前提是有适当的哈希函数，让元素分布在均匀的位置）
两个关键因子：初始容量、加载因子

二、继承关系

public class HashMap<K,V> extends AbstractMap<K,V>
        implements Map<K,V>, Cloneable, Serializable {

三、数据结构

数组+链表+红黑树（JDK1.8增加了红黑树部分）

preview

主要元素

    /**
     * 默认初始容量16——必须是2的幂
     * 01向左补四位，2的四次方
     * hashCode & (length-1); 15位与14位相比，与hashcode相与会有更多的结果，且不浪费空间
     * 所以将length定位二次幂，在进行hash运算时，不同的key算得index相同的几率较小，那么数据在数组上分布就比较均匀，
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * 最大容量,必须是2的幂 2的30次方
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 载荷因子
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * treeify_threshold由链表转化为红黑书的阀值
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * 红黑树节点转换链表节点的阈值
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * 转红黑树时数组应该满足的长度
     * 至少是 4 * TREEIFY_THRESHOLD ，节省效率
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

    /**
     * 基本的哈希节点,链表节点, 继承自Entry
     * k，v是Map<k,v>传入的数据类型
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
        @Override
        public final K getKey()        { return key; }
        @Override
        public final V getValue()      { return value; }
        @Override
        public final String toString() { return key + "=" + value; }
        @Override
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }
        @Override
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
        @Override
        public final boolean equals(Object o) {
            //存储位置相同
            if (o == this) {
                return true;
            }
            //instanceof是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                return Objects.equals(key, e.getKey()) && Objects.equals(value, 
    e.getValue());
            }
            return false;
        }
    }
    //将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会被序列化。
    //table数组
    transient Node<K,V>[] table;

    /**
     * Holds cached entrySet(). Note that AbstractMap fields are used
     * for keySet() and values().
     */
    transient Set<Map.Entry<K,V>> entrySet;

    // 大小
    transient int size;

    transient int modCount;

    /**
     * 转化为红黑树的阀值
     */
    int threshold;
    /**
     * 哈希表的负载系数。
     */
    final float loadFactor;

好的Hash算法和扩容机制，可以使Hash碰撞的概率又小，哈希桶数组（Node[] table）占用空间又少

四、核心方法解析

hash()

第一步，拿到key.hashCode()

第二步高16位异或运算
（>>> 表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0）

Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。

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

这里借用一个图来表示整个key.hashcode()变化到下标的处理过程

通过这个计算过程可以看出，生成的数组下标会因为‘扰动’的增加而减少碰撞的机率。

comparableClassFor()

 /**
     * Returns x's Class if it is of the form "class C implements
     * Comparable<C>", else null.
     */
    static Class<?> comparableClassFor(Object x) {
        if (x instanceof Comparable) {
            Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
            if ((c = x.getClass()) == String.class) // bypass checks
                return c;
            if ((ts = c.getGenericInterfaces()) != null) {
                for (int i = 0; i < ts.length; ++i) {
                    if (((t = ts[i]) instanceof ParameterizedType) &&
                            ((p = (ParameterizedType)t).getRawType() ==
                                    Comparable.class) &&
                            (as = p.getActualTypeArguments()) != null &&
                            as.length == 1 && as[0] == c) // type arg is c
                        return c;
                }
            }
        }
        return null;
    }

    /**
     * Returns k.compareTo(x) if x matches kc (k's screened comparable
     * class), else 0.
     */
    @SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
    static int compareComparables(Class<?> kc, Object k, Object x) {
        return (x == null || x.getClass() != kc ? 0 :
                ((Comparable)k).compareTo(x));
    }

tableSizeFor()

【作用】返回给定目标容量的2倍幂。将我们传入的容量设置为大于并最接近的2^N

【解读】

详见：求一个数字大于并最接近的2^N

   //补位，将原本为0的空位填补为1，最后加1时，最高有效位进1，其余变为0,如此就可以取到最近的2的幂
    static final int tableSizeFor(int cap) {
        //减一后，最右一位肯定和cap的最右一位不同，即一个为0，一个为1
        int n = cap - 1;
        //（>>>）无符号右移一位，（|）按位或
        n |= n >>> 1;
        //（>>>）无符号右移两位，（|）按位或
        n |= n >>> 2;
        //（>>>）无符号右移四位，（|）按位或
        n |= n >>> 4;
        //（>>>）无符号右移八位，（|）按位或
        n |= n >>> 8;
        //（>>>）无符号右移十六位，（|）按位或，为何到16呢，存疑
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

HashMap()

指定了初始容量和加载因子，会对参数进行校验
初始容量不能为负数，不能大于最大容量 1 << 30 （2^30）


    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Illegal initial capacity: " + 
    initialCapacity);
        }
        if (initialCapacity > MAXIMUM_CAPACITY) {
            initialCapacity = MAXIMUM_CAPACITY;
        }
        if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
        }
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
    }

    /**
     *
     * @param   m the map whose mappings are to be placed in this map
     * @throws  NullPointerException if the specified map is null
     */
    public HashMap1(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

get()

public V get(Object key) {
    Node<K,V> e;
    //还是先计算 哈希值
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    //tab 指向哈希表，n 为哈希表的长度，first 为 (n - 1) & hash 位置处的桶中的头一个节点
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        //如果桶里第一个元素就相等，直接返回
        if (first.hash == hash &&
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        //否则就得慢慢遍历找
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                //如果是树形节点，就调用树形节点的 get 方法
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                //do-while 遍历链表的所有节点
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

put()

这里看到知乎一个大神的相关回答，图片描述非常形象，引用如下：

（大神回答链接如下：https://zhuanlan.zhihu.com/p/21673805）

preview

如果定位到的数组位置没有元素就直接插入；
如果定位到的数组位置有元素就要与插入的key比较，
如果key相同就直接覆盖，
如果key不相同，就判断p是否是一个树节点，
如果是就调用e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value)将元素添加进入；
如果不是就遍历链表尾部插入。

public V put(K key, V value) {
    return 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;
    // 1.校验table是否为空或者length等于0，如果是则调用resize方法进行初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 2.通过hash值计算索引位置，将该索引位置的头节点赋值给p，如果p为空则直接在该索引位置新增一个节点即可
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        // table表该索引位置不为空，则进行查找
        Node<K,V> e; K k;
        // 3.判断p节点的key和hash值是否跟传入的相等，如果相等, 则p节点即为要查找的目标节点，将p节点赋值给e节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 4.判断p节点是否为TreeNode, 如果是则调用红黑树的putTreeVal方法查找目标节点
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 5.走到这代表p节点为普通链表节点，则调用普通的链表方法进行查找，使用binCount统计链表的节点数
            for (int binCount = 0; ; ++binCount) {
                // 6.如果p的next节点为空时，则代表找不到目标节点，则新增一个节点并插入链表尾部
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 7.校验节点数是否超过8个，如果超过则调用treeifyBin方法将链表节点转为红黑树节点，
                    // 减一是因为循环是从p节点的下一个节点开始的
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                // 8.如果e节点存在hash值和key值都与传入的相同，则e节点即为目标节点，跳出循环
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;  // 将p指向下一个节点
            }
        }
        // 9.如果e节点不为空，则代表目标节点存在，使用传入的value覆盖该节点的value，并返回oldValue
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e); // 用于LinkedHashMap
            return oldValue;
        }
    }
    ++modCount;
    // 10.如果插入节点后节点数超过阈值，则调用resize方法进行扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);  // 用于LinkedHashMap
    return null;
}