Java 8 HashMap 实现机制简析

最近看《java核心思想》看到了容器部分，本书着重描述了HashMap 的实现机制，对于Map，我们的固有印象便是存取很快，特别是HashMap，我们知道底层是哈希表结构。但HashMap具体怎么维护这个数据结构，这是我们今天要记录的问题。

HashMap的基本组成

要知道HashMap为什么存取性能优异，就要了解它内部的构造。hashmap实质是由 数组+链表 构成，在java 8 中，链表被优化成 在数据量比较大的情况下转变成红黑树。下图是HashMap的基本结构。

对着图，我们分析它内部一些必要组成结构。

数组table

    /**     * 这个表数组，会在初次使用的时候初始化,并且在必要的时候重新设置大小,当空间重新分配时，长度总是2的倍数     * The table, initialized on first use, and resized as     * necessary. When allocated, length is always a power of two.     */    transient Node<K,V>[] table;

所以HashMap的第一层，是一个数组table ，通过构造器你会发现，数组table 不会在构造器内被初始化，而是在真正业务操作时初始化，比如put。数组table里面存的是Node<K,V>，这也就是HashMap的第二层。

Node<K,V>

Node<K,V>是一个内部类，结构如下：

可以看出这是一个自定义的容器 – HashMap真正存每个key-value数据的地方。通过 最前面的示例图和 table，node的简单介绍，我们可以总结出，hashmap先是一个数组，然后每个数组内部是一个node链表，我们的key-value数据被存放在每个Node节点中，

    /**     * Basic hash bin node, used for most entries.      */    static class Node<K,V> implements Map.Entry<K,V> {        final int hash;  //key的hash值        final K key; //key        V value;   //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() {            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;        }    }

HashMap的存取机制

这张图以put方法为例，精要的总结了HashMap存的流程，但是我们是不是看的一脸懵逼？那我们分步骤讲解.

当我们调用put方法时，我们需要先计算key的hash值

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

hashcode的意义和设计

hash()方法其实是调用了key的hashCode方法，每个Object都有equals()和hashCode方法，正常来说，我们都需要复写这个方法。普通的线性查找算法从头查到尾， 效率很慢，如果我们给每个key带上一个索引，程序根据这个索引直接找到这个key，便可以直接锁定这个值，这个索引便是我们说的hash值。折射到hashmap里的设计，数组table的下标保存的不是key，而是hash值， 数组的随机访问很快，通过索引我们可以做到快速定位。
根据《java编程思想》的说法，如果我们不复写hashcode方法，默认的返回值是对象地址，也就是说hashcode返回的都是唯一值，但是这样设计会要求数组table的空间很大，并不利于效率,最好的方法hash值的设计应该根据对象内容来设计，对象内容一致的hash值应该要一样。

这是Integer的hashcode，返回的就是实际的内容

public static int hashCode(int value) {    return value;}

但是还有一个问题，根据内容生成的hash值不就存在hash值相同的情况了吗，table数组怎么存啊？这种情况称为hash冲突，但是还记得上面说的 hashmap是由数组+链表组成的吗？所以hash值一样的数据被组成了一个链表，先通过hash值确定对象在table数组中的具体位置，然后通过equals()方法对链表上的数据进行一一比较，最终确定这个对象应该存在的位置。这种数据结构比从头到尾的线性查找更有效率。

所以在HashMap中 元素的操作都是通过 hashCode() 和 equals()组合来确定元素位置的。

再回到HashMap中的hash方法中，里面除了提取对象的hashcode值，自己也做了一些位运算处理.

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

HashMap扩容机制

计算完hash后开始调用putVal方法，因为在调用get put之前，数组table是没有初始化的，所以会先做一个数组初始化操作，初始化操作都在resize()方法中进行，但是resize方法不止是初始化数组，更重要的是后期数组table的扩容操作。

if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;

HashMap默认的初始化大小为16

    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

下面这段代码

final Node<K,V>[] resize() {        //现在的table数组        Node<K,V>[] oldTab = table;        //现在的table数组容量        int oldCap = (oldTab == null) ? 0 : oldTab.length;        //threshold 为扩容的临界点，公式为 capacity(现在的table数组容量) * load factor(装载因子，衡量hashmap满的程度，默认0.75)，超过临界点，就会扩容        int oldThr = threshold;        int newCap, newThr = 0;        //如果现在的table数组容量大于0        if (oldCap > 0) {        //如果table长度大于规定的最大容量，就不扩容            if (oldCap >= MAXIMUM_CAPACITY) {                threshold = Integer.MAX_VALUE;                return oldTab;            }            //否则newCap变成当前容量的2倍            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)                     //newThr 变成当前扩容临界点的2倍                newThr = oldThr << 1; // double threshold        }        //这个是针对创建hashmap时指定了initialCapacity 和 loadFactor的情况，会将容器扩容为计算好的threshold大小      //HashMap(int initialCapacity, float loadFactor)        else if (oldThr > 0) // initial capacity was placed in threshold            newCap = oldThr;     //table还未初始化，初始化为系统默认大小，并且计算好扩容的临界值        else {               // zero initial threshold signifies using defaults            newCap = DEFAULT_INITIAL_CAPACITY;            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);        }        if (newThr == 0) {            float ft = (float)newCap * loadFactor;            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?                      (int)ft : Integer.MAX_VALUE);        }        //总之，之前的都在计算newThr和newCap，确保它们有有意义的值。这样做是为了生成新的table，众所周知，当容器扩容时，为了保证kv元素能均匀的分布，我们需要重新计算迁移元素。并把旧的table释放。        threshold = newThr;        @SuppressWarnings({"rawtypes","unchecked"})        //根据计算的newCap生成新的table            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];        table = newTab;        if (oldTab != null) {            for (int j = 0; j < oldCap; ++j) {                Node<K,V> e;                if ((e = oldTab[j]) != null) {                    oldTab[j] = null;                    if (e.next == null)// 数据的迁移注意看这个公式，这也是计算某个kv元素存在table数组具体位置的公式 e.hash & (newCap - 1)// 假设初始容量为16  ，A元素没扩容前hash值为15，则A在原来的table上的位置为(15& (16-1)) = 15,那么扩容后为32，则新的hash值为  15&(32-1) = 15，这个元素不用做变动；// B元素没扩容前hash值为20，则B在原来的table上的位置为(20& (16-1)) = 4，那么扩容后新的hash值为20&(32-1) = 20，这个元素正好向右偏移了oldCap个单位。//这个巧妙的设计保证了一半元素原地不动，一半元素向右偏移了oldCap个单位（此结论未作严谨验证，但是意在表达hashmap扩容后，元素的迁移思路）                        newTab[e.hash & (newCap - 1)] = e;                    else if (e instanceof TreeNode)                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);                    else { // preserve order                        Node<K,V> loHead = null, loTail = null;                        Node<K,V> hiHead = null, hiTail = null;                        Node<K,V> next;                        do {                            next = e.next;                            if ((e.hash & oldCap) == 0) {                                if (loTail == null)                                    loHead = e;                                else                                    loTail.next = e;                                loTail = e;                            }                            else {                                if (hiTail == null)                                    hiHead = e;                                else                                    hiTail.next = e;                                hiTail = e;                            }                        } while ((e = next) != null);                        if (loTail != null) {                            loTail.next = null;                            newTab[j] = loHead;                        }                        if (hiTail != null) {                            hiTail.next = null;                            newTab[j + oldCap] = hiHead;                        }                    }                }            }        }        return newTab;    }

hashmap扩容机制都写在了上面代码的注释里，光从容器扩容的代码我们就可以大概了解到hashmap 的运作原理，其中包括了：

• capacity，loadFactor，threshold的基本概念和作用
• kv元素如何确定在table中的位置以及扩容后的位置

走完resize()方法，我们继续走完putVal方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node<K,V>[] tab; Node<K,V> p; int n, i;        if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;        //通过公式e.hash & (newCap - 1)确定kv元素的位置，如果该位置没有其它元素，直接在table[i]中插入        if ((p = tab[i = (n - 1) & hash]) == null)            tab[i] = newNode(hash, key, value, null);        //如果有其它元素        else {            Node<K,V> e; K k;            //如果旧kv的key跟新kv的key内容完全一样，则先用e记录，后面会覆盖其value            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k))))                e = p;            //如果该链表是一个红黑树结构，且两个key内容不相等，则会用putTreeVal将这新的记录插入到红黑树中去            else if (p instanceof TreeNode)                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);           //如果这个链表不是红黑树结构，且两个key内容不相等，会进入这段代码            else {                for (int binCount = 0; ; ++binCount) {                    if ((e = p.next) == null) {                        p.next = newNode(hash, key, value, null);      //这里要注意，在java8中，如果一个链表里的kv元素大于8，则会用treeifyBin将这个链表转化成红黑树结构，红黑树的查询效率更高。                        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内容一样需要做覆盖处理的具体代码            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的取过程

通过漫长的代码分析，我们走完hashmap是如何存一个元素的，下面再看看它是如何取的。

final Node<K,V> getNode(int hash, Object key) {    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;    //依旧从公式(n - 1) & hash 确定kv元素的具体位置    if ((tab = table) != null && (n = tab.length) > 0 &&        (first = tab[(n - 1) & hash]) != null) {        //总是检查第一个元素，如果第一个直接key内容完全匹配上，就返回        if (first.hash == hash &&             ((k = first.key) == key || (key != null && key.equals(k))))            return first;        if ((e = first.next) != null) {        //如果第一个元素取不到，且接下来是个红黑树结构，就用getTreeNode方法去取值            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;}

可以看出，存和取是一个互逆过程，两者原理相似。

结语

这篇文章从代码层面解释了HashMap的存取机制，它利用了数组的高随机访问能力，但是对于数据大容量问题，又用 链表/红黑树 与数组配合 作为解决方案，可见HashMap设计的精妙之处。

本文内容也参考了该文章，对该文章作者表示感谢

http://www.jianshu.com/p/aa017a3ddc40