Java底层原理——HashMap底层原理（JDK1.8）

从1.7中可知HashMap是数组+链表的结构，HashMap在JDK1.8中加入了红黑树的实现，当链表长度大于8时，转换为红黑树的结构。

java8中没有indexFor函数，而是直接使用table[index=(n-1)&hash]

在JDK1.8中也使用了取代Entry的Node来实现Map.Entry接口

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;
    }

Node是一个内部类，实现了Map.Entry接口，本质就是一个键值对。

HashMap类中有一个非常重要的字段，就是Node[] table,即哈希桶数组，很明显它是一个Node的数组。

如果哈希桶数组很大，即使较差的Hash算法也会比较分散，如果哈希桶数组很小，即使好的Hash算法也会出现较多碰撞，所以就需要在空间成本和时间成本之间权衡，其实就是根据实际情况确定哈希桶数组的大小，并在此基础上设计好的hash算法减少Hash碰撞。主要就是通过好的Hash算法和扩容机制优化HashMap的Node数组。

同样有几个重要字段

int threshold;             // 所能容纳的key-value对极限
final float loadFactor;    // 负载因子
int modCount;
int size;

loadFactor参数

首先Node[] table的初始化长度length（默认值时16），loadFactor为负载因子（默认值问0.75),threshold时HashMap所能容纳的最大数据量的Node（键值对）个数。threshold = length * loadFactor。也就是说，在数组定义好长度之后，负载因子越大，所能容纳的键值对个数越多。

threshold参数

结合负载因子的定义公式可知，threshold就是就是在此loadFactor和length(数组长度)对应下允许的最大元素数目，超过这个数目就得重新resize(扩容),扩容后的HashMap容量是之前容量的两倍。默认的负载因子0.75是对空间和时间效率的一个平衡选择，除非在时间和空间比较特殊的情况下，如果内存空间很多而又对时间效率要求很高，可以降低负载因子loadFactor的值；相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子loadFactor的值，这个值可以大于1。

size参数

这个参数很好理解，就是HashMap中实际存在的键值对数量。

modCount参数

主要用来记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败。内部结构变化指的是结构发生变化，例如put新键值对，但是某个key对应的value值被覆盖不属于结构变化

同样在JDK1.8的HashMap中，哈希桶数组table的长度length大小必须为2的次幂。

引入红黑树的设计是因为，即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响HashMap的性能。当链表长度太长（默认超过8）时，链表就转换为红黑树，利用红黑数快速增删改查的特点提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法确定哈希桶数组索引位置

代码实现：

 

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

对于任意给定的对象，只要他们hashCode（）返回值相同，那么程序调用方法所计算到的Hash码也相同。

h & (table.length -1)这个得到对象保存位的方法非常巧妙，HashMap底层数组的长度总是2的次幂，这是HashMap在速度上的优化，当length总是2的n次方时，h & (table.length -1)等价于对length取模，也就是h%length，但是&比%有更高的效率。

put方法的实现

大致思路（bucket就是桶）

1.  对key的hashCode（）做hash，然后再计算index
2.  如果没碰撞放到bucket里
3. 如果碰撞了，以链表的形式存在buckets后；
4. 如果碰撞导致链表过长（大于等于TREEIFY_THRESHOLD也就是8）就把链表转换为红黑树
5. 如果节点已经存在就替换old value（保证key的唯一性）
6. 如果bucket满了（超过loadFactor*currrent capacity)，就要resize

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;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            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;
                }
            }
            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;
    }

get方法的实现

1. bucket里的第一个节点，直接命中
2. 如果有冲突，则通过key.equals(k)去查找对应的entry

若为树，则在树中通过key.equals(k)查找，O(logn)

若为链表，则在链表中通过key.equals(k)查找，O(n)

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;
        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)
                    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;
    }

扩容机制

扩容就是重新计算容量，也就是resize方法

JDK1.7的HashMap的扩容操作使用的是头插法，并且在扩容转移Entry中的元素时需要rehash（可能会出现死链的问题）

1.8则做了一些优化。经过观测我们可以发现，我们使用的时2次幂的扩展（指长度扩展为原来的2倍），所以元素的位置要么在原位置，要么实在原位置再移动2次幂的位置。看下图就可以明白了，n为table的长度

图(a)为扩容前的key1和key2确定索引位置的示例，图(b)为扩容后

 元素再重新计算hash后，因为n变为原来的2倍，那么n-1的mask范围再高位会多1bit(红色),因此新的index就会发生这样的变化，上面的为key1,下面的是key2

 因此，我们扩容的时候，不需要像JDK1.7那样rehash，只需要看看原来hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成"原索引+oldCapacity"，类似下图（绿色的bit为1，蓝色的bit为0）

 这个时机非常的巧妙，即省去了rehash的时间，而且新增的1bit是0还是1可以认为是随机的，因此resize的过程，均与的把之前的冲突分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点需要注意，JDK1.7在rehash的时候使用的是头插法（可能会产生死链问题），链表元素会倒置，而JDK1.8不会倒置。

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }