Java中HashMap的实现原理剖析

HashMap的基本原理

HashMap根据key通过hash函数计算出hash值直接就可以定位key所在位置，时间复杂度为O(1)，不同的key可能计算出相同的hash值，会产生冲突，发生冲突时，可以通过链地址法解决，就是在冲突的节点上延申出去一条链，通过hash函数定位到节点key跟查找的key不相等时，继续节点延申出来这条链去检索。

HashMap结构图：
hash函数：key%10
冲突处理：链地址法

以上简述了HashMap的基本原理，设计实现出一个性能好的HashMap却不容易，参考一下几个问题：

1、hash函数的设计
hash函数要尽量将key分散开，假设最坏情况，hash函数产生值是固定不变的，永远返回0，那么所有节点都还放在0号节点这个桶里面，也就退化成一条链做顺序查找，因此hash函数要能够将key尽量分散开，尽量保证分散各个桶的key数量差不多，才能有效利用hash函数进行查找。

2、如何确定hash表的容量
HashMap通过hash函数可以直接计算出在数组上的位置，初始容量（指数组的长度）多少比较合适呢？假设有10万个key容量为10，就算数据分布完全均匀，每个桶里面也包含了1万key，经过hash后还是需要进行大量查找，反过来假设容量为1万，key只有10个，就存在大量空间浪费，因此，容量跟数据量成正比，如果根本不确定数据量有多少，那还会涉及数组长度调整。

3、hash表容量调整后需要重新计算hash
hash表的容量调整后，需要重新计算hash，按新的容量重新计算数据分布，调整一次需要很大的计算量。

实现一个性能好的HashMap并容易，带着上面的问题，来看一下JDK 里面的HashMap是如何实现的。

HashMap的构造函数

/** 初始化容量和装载因子 */
public HashMap(int initialCapacity, float loadFactor);
/** 初始化容量*/
public HashMap(int initialCapacity);
/** 用默认容量和默认装载因子 */
public HashMap();
/** 通过Map对象初始化，默认装载因子 */
public HashMap(Map<? extends K, ? extends V> m);

主要看构造函数里面的两个参数

参数	用途	默认值
initialCapacity（初始容量）	就是数组的初始长度，必定是2的整数次幂，如16、32，如果传入的不是2的整数次幂，则自动向上去，例如传入29，30实际上长度都会用32	16
loadFactor （装载因子）	触发扩容的阈值，当（实际元素个数/当前容量）> 装载因子 时，HashMap会进行扩容	0.75

HashMap相关结构体

从源码中复制出来的字段

class HashMap{
	// 一维数组
	transient Node<K,V>[] table;
    // 遍历HashMap的Set视图，和HashMap共享数据节点的，遍历过一次后就会生成，下次遍历时直接从属性中取
    transient Set<Map.Entry<K,V>> entrySet;
    // 元素个数
    transient int size;
    // 统计修改次数，用于实现快速失败，当遍历的时候去增加删除HashMap元素会抛出异常
    transient int modCount;
    // 下一次的扩容的容量
    int threshold;
    // 装载因子
    final float loadFactor;
}

/** 链表节点 */
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
}

/** 红黑树节点 */
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
}

JDK中的HashMap也是采用链地址法解决冲突，元素少时用单向链表，元素多时用红黑树，单个桶内元素个数达到8时，就从将链表转换成红黑树进行存储。

HashMap实现

hash值计算和根据hash值计算在数组中的位置

通过key对象的hashCode计算hash：

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

通过hash计算元素在数组上的位置：

// n = tab.length
Node p = tab[i = (n - 1) & hash];

hash值是通过key的hashCode和hashCode的高16位右移到低16位后按位与得到hash值。
容量减1再和hash按位与得到在tab中的位置。

问题1：为什么要用容量减1后再和hash值按位与？为什么容量一定是2的整数幂
容量是2的整数次幂，拿8位数来说，2的二进制为10，4的二进制为100，8的二进制为1000，
8-1的二进制为0111，用0111和其他数按位与运算得到数范围再[0-7]刚好是数组的下标，运算简单高效。

问题2：为什么要将高16位移动到低16位作再按位与呢？
因为计算元素在数组上的位置时，是按位与的，在容量比较少时，只用到低位进行与运算，高位对计算没有影响，所以将高位的影响也传递到地位，这样hash值得高16位在容量比较时也能对位置产生影响。

HashMap容量调整

容量增长的代码：

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
        }
        // 构造函数传入容量一开始会放在threshold中，当前容量为0，使用构造方式的初始化容量参数初始化
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            // 使用默认参数初始化
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 计算下一次扩容的阈值，到达thr后进行扩容
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor; // 容量达到ft时进行扩容
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        
		// 容量增长后，需要重新计算元素的hash
		@SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            // 遍历数组中的所有bin
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null) // bin里面只有一个节点
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode) // bin里面是一棵红黑树
                    	// 将红黑树拆分到两个bin里面
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order // bin里面是链表
                    	// 拆成两条链表
                        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;
    }

每次增长容量都将容量翻倍，扩容后需要将原有节点重新分配新的bin(桶)内，旧的节点时在分配在新的数组上两个位置，假设旧的的容量时8，那计算位置时跟111按位与，新的容量为16，跟1111按位与，计算结果的低三位肯定是一样的，不相同的只可能有一位，所以只能分配到两个位置，新加入到按位与的高位为0时数组序号和原来的相等，为1拆分到新增的高位的bin（桶）内，并且每次拆分到新的数组用到的两个bin是互不重叠的。

总结

JDK中HashMap的hash函数设计非常巧妙，容量取2的整数次幂，容量减1后刚好可以将低位全部充填为1，然在再与hash值按位与，刚好能得到数组的下标，不用检查数组是否越界。hashCode的高16位右移到低16位生成hash值，将高位的影响传递到地位，保证当容量比较小时，高位也能对hash运算产生影响。在这种按位与计算元素所在位置方式，hash进行扩容时，也能刚好将原来在同一个bin的元素拆分到新的两个bin中，并且不会重叠。