【Java入门提高篇】Day22 Java容器类详解（五）HashMap源码分析（上）

原创

弗兰克的猫

修改于 2018-06-17 22:05:41

5630

修改于 2018-06-17 22:05:41

文章被收录于专栏：Java爬坑系列

准备了很长时间，终于理清了思路，鼓起勇气，开始介绍本篇的主角——HashMap。说实话，这家伙能说的内容太多了，要是像前面ArrayList那样翻译一下源码，稍微说说重点，肯定会让很多人摸不着头脑，不能把复杂的东西用尽量简单的方式说明白，那就说明讲的挺失败的（面壁中

）。所以这次决定把内容分四篇进行讲解，

　　第一篇主要讲解HashMap中的结构，重要参数和重要方法，以及使用中需要注意的地方和应用场景。

　　第二篇主要讲解HashMap中的散列算法，扰动函数以及扩容函数。普通节点的较深入的解析其中算法的妙处。

　　第三篇主要讲解HashMap中的EntrySet，KeySet和Values。

　　第四篇主要讲解HashMap中的TreeNode结构以及元素增减时的结构调整方式。（以JDK8中的红黑树进行讲解）。

　　因为HashMap中可以说说的点实在太多了，这里选取了比较重要的几点进行说明，四篇的角度和深度各不一样，这样不同阶段的同学也可以选取不同的部分进行阅读，第一篇属于简单易懂的初级部分，第二、第三篇和第四篇属于HashMap的高级部分，如果阅读有难度，可以先跳过，以后再来进行阅读。

　　好了，话不多说，接下来就进入我们的主题了。

　　本篇将摈弃之前的讲法，直接摆几百行源码实在是太干了，我们得弄湿一点才好消化（滑稽），接下来将用图文并茂的方式进行说明。

　　通过本篇，你将了解以下问题：

　　1.HashMap的结构是什么？

　　2.HashMap的优点和缺点是什么？

　　3.什么时候该使用HashMap？

　　4.HashMap中的常用方法有哪些？

　　5.HashMap的get()方法和put()方法的工作原理是什么？

　　6.HashMap中的碰撞探测(collision detection)以及碰撞的解决方法是什么？

　　7.如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？

　　8.在设置HashMap的键是需要注意什么？可以使用自定义的对象作为键吗？

　　嗯，所以内容还是挺多的，干货也不少。我们先来看一个HashMap的小栗子：

public class Test {
    public static void main(String[] args){
        Map<String, Integer> map = new HashMap();
        map.put("小明", 66);
        map.put("小李", 77);
        map.put("小红", 88);
        map.put("小刚", 89);
        map.put("小力", 90);
        map.put("小王", 91);
        map.put("小黄", 92);
        map.put("小青", 93);
        map.put("小绿", 94);
        map.put("小黑", 95);
        map.put("小蓝", 96);
        map.put("小紫", 97);
        map.put("小橙", 98);
        map.put("小赤", 99);
        map.put("Frank", 100);
        for(Map.Entry<String, Integer> entry : map.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }
}

　　输出也很简单：

小刚:89
小橙:98
小蓝:96
小力:90
小青:93
小黑:95
小明:66
小李:77
小王:91
小紫:97
小红:88
小绿:94
Frank:100
小黄:92
小赤:99

　　可以看到，HashMap中存储的顺序跟我们放入的顺序有些不太一样，但是每次运行的结果都是一样的，以一种神奇的顺序输出着，为什么会这样呢？不要着急，让我们先来打个断点看看。

　　可以看到，这个HashMap对象里，有一个table字段，可以看出，它是一个数组，我们put的成绩信息，就在这个家伙里面了，你看看，这个顺序跟上面的输出顺序是不是很像？

　　不过，等一下，你有没有发现，小李，小紫，小赤失踪了。。这个问题，不要着急，待会我们就一起去找他们。

HashMap里的数据结构是数组+链表的形式来存储节点的，每个节点以键值对（Node<K,V>）的形式存储，上面看到的table，就是HashMap中存放值的地方，它的数据结构是这样的：Node<K,V>[] table；那这个Node到底是什么东西呢？我们来看看它的代码：

    /**
     * 用于大多数键值对的普通节点
     */
    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;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            //返回key和value的哈希值的异或运算结果
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                        Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

　　Node类继承于Map.Entry接口，如果对这个接口没有印象了可以回过头翻一下Map接口的内容，Node中的内容很简单，hash，键值信息和下一个节点的引用，Node之间正是通过这样的引用来连接起来形成一条链。再想想table的结构，Node<K,V>[]，现在是不是理解了什么是数组+链表的存储方式了？

　　什么？这样说的还不够形象？好吧，一图胜千言，之前说要用图文并茂的方式来进行讲解，所以还是一起来看几张图片：

　　嗯，我们存储的数据在内存里就是这样的，我们再来看一下断点里的数据：　　　　

　　对比两幅图应该就能比较清楚的了解了，可以看出里面数组并不是顺序往里存的，中间有很多空的桶（每个格子称为一个bin，这里蹩脚翻译成桶

），那为什么会是这样的顺序呢？我们来看看它的put方法：

　　　/**
     * 将map中指定key和value进行关联，如果map中已经存在该key的映射，则旧的值将会被替换。
     * 返回该key映射的旧值，如果该key的映射不存在的话则返回null。
     */
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    /**
     *  实现 Map.put 和相关方法
     *
     * @param hash key的哈希值
     * @param key key
     * @param value key将要映射的value
     * @param onlyIfAbsent 如果是true的话，将不会改变已存在的值
     * @param evict 这个参数如果为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;
        //如果当前table未初始化，则先重新调整大小至初始容量
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //（n-1）& hash 这个地方即根据hash求序号，想了解更多散列相关内容可以查看下一篇
        if ((p = tab[i = (n - 1) & hash]) == null)
            //不存在，则新建节点
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //先找到对应的node
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                //如果是树节点，则调用相应的putVal方法
                //todo putTreeVal
                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
                            //如果链表长度达到树化的最大长度，则进行树化
                            //todo treeifyBin
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //如果已存在该key的映射，则将值进行替换
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //修改次数加一
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

　　从这里可以看出往HashMap添加元素时的逻辑：

对key的hashCode()做一次散列（hash函数，具体内容下一篇讲解），然后根据这个散列值计算index（i = (n - 1) & hash）；
如果没有发生碰撞（哈希冲突），则直接放到桶里；
如果碰撞了，以链表的形式挂在桶后；
如果因为碰撞导致链表过长(大于等于TREEIFY_THRESHOLD)，就把链表转换成红黑树；
如果节点已经存在就替换old value(保证key的唯一性)
如果桶满了(超过负载因子*当前容量)，就要resize（重新调整大小并重新散列）。

　　也许你想知道这个table是什么东西，那我们顺便一起看看那几个重要的成员变量吧：

/* ---------------- 字段 -------------- */

    /**
     * 哈希表，该表在初次使用时初始化，并根据需要调整大小。 分配时，长度总是2的幂
     *
     * todo hashMap的结构
     * todo transient
     */
    transient Node<K,V>[] table;

    /**
     * 保存缓存的entrySet，注意AbstractMap中的字段是用于keySet() 和 values().
     */
    transient Set<Map.Entry<K,V>> entrySet;

    /**
     * map中的键值对个数
     */
    transient int size;

    /**
     * hashmap 结构性修改的次数，结构性修改是指改变hashmap中映射数量或者修改内部结构。
     * 该字段用于在HashMap中创建基于集合视图的可失败快速的（fail-fast）迭代器。
     */
    transient int modCount;

    /**
     * 下一个调整大小的值（容量*加载因子）。
     */
    int threshold;

    /**
     * hashmap的装载因子
     */
    final float loadFactor;

　　table字段是中保存了我们的数据，类型是Node数组，Node的结构也很简单，只是简单的存放key和value，以及key的hash和指向下一个节点的引用。

    /**
     * 用于大多数键值对的普通节点
     */
    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;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            //返回key和value的哈希值的异或运算结果
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                        Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

　　在成员变量entrySet中缓存了Entry的集合（其实你仔细找找的话，会发现entrySet的存储元素逻辑并不简单，这将在第三篇里讲解）。threshold表示进行下一次重新调整的阈值（容量*装载因子），转载因子表示table最大装满程度，默认是0.75，即当容量被用掉75%后将会触发扩容，因为当table中的元素足够多时，发生冲突的概率就会大大增加，冲突的增多会导致每个桶中的元素个数变多，这样的话会使得查找元素效率变得低下，当同一个桶中元素个数达到8时，桶中的元素结构将转换为红黑树。

　　那么，问题来了，为什么是8，而不是6或者7,10呢？？？这个话题如果要深入探讨的话，又要说上一篇了。。。

这里我就引用一下JDK8中的HashMap的中注解：

　　　* Ideally, under random hashCodes, the frequency of
     * nodes in bins follows a Poisson distribution
     * (http://en.wikipedia.org/wiki/Poisson_distribution) with a
     * parameter of about 0.5 on average for the default resizing
     * threshold of 0.75, although with a large variance because of
     * resizing granularity. Ignoring variance, the expected
     * occurrences of list size k are (exp(-0.5) * pow(0.5, k) /
     * factorial(k)). The first values are:
     *
     * 0:    0.60653066
     * 1:    0.30326533
     * 2:    0.07581633
     * 3:    0.01263606
     * 4:    0.00157952
     * 5:    0.00015795
     * 6:    0.00001316
     * 7:    0.00000094
     * 8:    0.00000006
     * more: less than 1 in ten million
     *

　　大致意思是，理想情况下，HashCode随机分布，当负载因子设置成0.75时，那么在桶中元素个数的概率大致符合0.5的泊松分布，桶中元素个数达到8的概率小于千万分之一，因为转化为红黑树还是比较耗时耗力的操作，自然不希望经常进行，但如果设置得过大，将失去设置该值的意义。

　　那么，问题又来了。。为什么是0.75，而不是0.5,0.8？？？

这是一个经验值，在空间和时间成本中的折中，跟默认初始容量设置为16一样。看看JDK8中HashMap最开头的注释即可找到答案：（说实话，JDK中的注解真是太多太详细了，教科书式的代码人一般人写的还是不一样的）

 * <p>As a general rule, the default load factor (.75) offers a good
 * tradeoff between time and space costs.  Higher values decrease the
 * space overhead but increase the lookup cost (reflected in most of
 * the operations of the <tt>HashMap</tt> class, including
 * <tt>get</tt> and <tt>put</tt>).  The expected number of entries in
 * the map and its load factor should be taken into account when
 * setting its initial capacity, so as to minimize the number of
 * rehash operations.  If the initial capacity is greater than the
 * maximum number of entries divided by the load factor, no rehash
 * operations will ever occur.

　　再蹩脚的翻译一次：

 * 通常，默认的负载因子（0.75）是在时间和空间成本上比较好的折中选择。如果设置成更高的值，虽然会
 * 减少空间开销，但是会增加查找的成本（反应在HashMap的大部分操作中，包括get和put方法）。
 * 在设置初始容量时，应该考虑映射中的条目数量以及负载因子，以尽量减少重新散列的次数。
 * 如果初始容量大于最大词条数量除以负载因子，那么就不会发生重新散列操作。

　　而且，装载因子和容量都是可以在构造函数中指定的：

    /**
     * 用指定初始容量和装载因子构造一个空的hashmap，
     */
    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);
    }

    /**
     * 用指定初始容量和默认的装载因子（0.75）构造一个空的hashmap
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * 用指定默认容量（16）和默认的装载因子（0.75）构造一个空的hashmap
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    /**
     * 用另一个map来构造一个新的hashmap，并保留相同的映射。新的HashMap使用默认加载因子（0.75）和适合装下指定map中所有映射关系的
     * 初始容量。
     */
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

　　如果不指定初始大小和加载因子，将使用默认的加载因子和默认的容量，而且HashMap中是使用懒加载的方式进行的，只有真正往里添加元素时才会初始化table。上面我们已经看过了put方法的实现，那我们再来看看get方法是怎样实现的：

    /**
     * 返回指定键映射的值，当该key不存在的时候返回null
     */
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    /**
     * 实现了Map.get 和相关方法
     */
    final Node<K,V> getNode(int hash, Object key) {
        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) {
            //判断是否是第一个节点
            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)
                    //如果是树节点，则用TreeNode的getTreeNode方法来查找相应的key
                    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;
    }

　　get的思路很简单。大致思路如下：

先匹配bucket里的第一个节点，直接命中则返回；
如果有冲突，则通过key.equals(k)去查找对应的entry 若为树节点，则在树中通过key.equals(k)查找，时间复杂度为O(logn)；若为链表节点，则在链表中通过key.equals(k)查找，时间复杂度为O(n)。

　　好了，最重要的方法都介绍完了，是时候去救爷爷了

，说错了，是时候来回答最开头提出的问题了：

　　1.HashMap的结构是什么？

　　HashMap是数组+链表的存储形式，默认的初始容量是16，默认的加载因子是0.75，当链表长度达到8时将会转化为红黑树来提高查找效率。

　　2.HashMap的优点和缺点是什么？

　　HashMap的优点是查找速度很快，我们可以在常数时间内迅速定位到某个桶以及要找的对象。缺点嘛，就是它的拿手好戏——散列算法是依赖key的hashcode，所以如果key的hashcode设计的很烂，将会严重影响性能。　　极端情况下，如果每次计算hash值都是同一个值，那么会造成链表中长度过长然后转化成树，扩容时再散列的效果也很差的问题。另一个极端情况. 每次计算hash值都是不同的值，那么就是HashMap中的数组会不断的扩容，造成HashMap的容量不断增大。

　　另一方面，HashMap是线程不安全的，如果想在并发编程中使用到HashMap，就需要使用它的同步类，Collections.synchronizedMap()方法将普通的HashMap转化成线程安全的，或者使用Concurrent包下的ConcurrentHashMap进行替换。

　　3.什么时候该使用HashMap？

　　因为HashMap查找速度很快，所以应用在经常需要存取元素的场景，比如要将一个List B中的元素根据另一个List A的元素来进行排序，那么需要经常将B中的元素来到A中进行查找，而查找一般都是使用遍历的方式进行的，如果List很大的情况下，效率问题还是需要考虑的，这时候如果将A中的元素存储在Map中，以B中的元素作为key，那么查找效率将大大提高，这是以空间换取时间的策略。

　　4.HashMap中的常用方法有哪些？

　　常用方法有put，get，putAll，remove，clear，replace，size。

　　5.HashMap的get()方法和put()方法的工作原理是什么？

　　通过对key的hashCode()进行hashing，并计算下标( n-1 & hash)，从而获得桶的位置。如果发生哈希冲突，则利用key.equals()方法去链表或树中去查找对应的节点。

　　6.HashMap中的碰撞探测(collision detection)以及碰撞的解决方法是什么？

　　当两个key的hashCode相同时，就会发生碰撞，就像上面的小明和小李，这时候后添加的元素将会以链表或树节点的形式挂在桶后面。

　　7.如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？

　　如果HashMap的大小超过了加载因子*容量，那么将会进行扩容操作，扩容到原来的两倍。

　　8.在设置HashMap的键是需要注意什么？可以使用自定义的对象作为键吗？

　　设置的key尽量使用不可变对象，例如数值，String，这样可以保证key的不可变性，也可以使用自定义的类对象，但需要对hashCode方法和equals方法有良好的设计。

　　此处应有掌声，本篇终于讲解完毕，这段时间因为其他时间，一直没多少时间来写博客，耽搁了两个星期，对不住各位看官啦，不过写一篇博客真心挺花时间的，这篇文章我也是想了好几天才想好思路，HashMap的东西实在是太多了，细节不太可能面面俱到，而且如果事无巨细全部介绍的话，显然对初学者来说不够友好，所以才决定分成了四篇，这样大家可以根据自己能理解的程度选择性的阅读。

　　还望各位看官赏个赞，对我的文章感兴趣的话，也欢迎动动小手点点关注，还是持续更新的。也欢迎提出好的建议，如果有重要知识点遗漏或者说错了的地方，还请各位看官及时指出，多多交流。