深入理解hashMap类中一些核心设计

前言

Map 是非常常用的一种数据接口。在 Java 中，提供了成熟的 Map 实现。

图 1

最主要的实现类有 Hashtable、HashMap、LinkedHashMap和 TreeMap。在 HashTable 的子类中，还有 Properties的实现。Properties 是专门读取配置文件的类，我们会在稍后介绍。这里首先值得关注的是 HashMap 和 HashTable 两套不同的实现，两者都实现了 Map 接口。从表面上看，并没有多大差别，但是在内部实现上却有些微小的细节。

首先，HashTable 的大部分方法都做了同步，而 HashMap 没有，因此， HashMap 不是线程安全的。
其次，HashTable 不允许 key 或者 value 使用 null 值，而 HashMap 可以。
第三，在内部实现算法上，它们对 key 的 hash 算法和 hash 值到内存索引的映射算法不同。

虽然有诸多不同，但是他们的性能确实相差无几。由于 HashMap 使用广泛性，现以 HashMap 为例，阐述它的实现机理。

 

1、HashMap 的实现原理

HashMap 内部维护一个数组，并且将 key 做 hash 算法，然后将 hash 值映射到内存地址，即数组的下标索引，这样就可以通过key直接取到所对应的数据。而对于发生碰撞的位置，则会维护一个链表，所有在同一位置发生碰撞的元素都会存放在同一位置的链表中。

图 2

如图 2，数组中的每一个元素都是一个 Entry 实例：

 

	static class Entry implements Map.Entry {
        final K key;
        V value;
        Entry next;
        int hash;
        //.....省略部分
	}

每一个实例都包含 元素key, 元素value , 元素hash值，以及指向下一个在当前位置发生冲突的 Entry实例。

 

2、Put 方法详细解析

下面我们来看一下最基本的put 操作。

 

	/*
	 * 将（key, value）放入 map
	 */
	public V put(K key, V value) {
		if (key == null)
			return putForNullKey(value);
		// 计算 key 对应的下标 。关于 hash 和 indexFor 方法，我们会在后面讲到。
		int hash = hash(key);
		int i = indexFor(hash, table.length);
		// 如果发生了冲突，那么就遍历当前冲突位置的链表。如果在链表中发现该元素已经存在(即两元素的 key 和 hash
		// 值一样)，则用新值替换原来的值，并返回原来的值。
		for (Entry e = table[i]; e != null; e = e.next) {
			Object k;
			if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
				V oldValue = e.value;
				e.value = value;
				// 将该元素的访问存入历史记录中（在LinkedHashMap才发挥作用）
				e.recordAccess(this);
				return oldValue;
			}
		}
		// 标志容器被修改次数的计数器，在使用迭代器遍历时起作用
		modCount++;
		// 为新值创建一个新元素，并添加到数组中
		addEntry(hash, key, value, i);
		return null;
	}

	void addEntry(int hash, K key, V value, int bucketIndex) {
		// 如果数组需要扩容，则进行扩容
		if ((size >= threshold) && (null != table[bucketIndex])) {
			resize(2 * table.length);
			hash = (null != key) ? hash(key) : 0;
			bucketIndex = indexFor(hash, table.length);
		}
		// 创建新元素并添加到数组中
		createEntry(hash, key, value, bucketIndex);
	}

	/*
	 * 创建新元素，并将该新元素加到下标位置的最前端，该新元素的next引用指向该位置原来的元素（如果有）
	 */
	void createEntry(int hash, K key, V value, int bucketIndex) {
		Entry e = table[bucketIndex];
		table[bucketIndex] = new Entry<>(hash, key, value, e);
		size++;
	}

应经加上了详细的注释，相信大家都能读得懂。同样的，get 操作就比这个简单多了，笔者就不再啰嗦了，下面直接将最关键的部分。

 

3、HashMap 的核心算法-hash 函数的实现

HashMap的高性能需要保证以下几点：

1、hash 算法必须是高效的
2、hash 值到内存地址（数组索引）的算法是快速的
3、根据内存地址（数组索引）可以直接取得对应的值

首先来看第一点，hash 算法的高效性，在 HashMap 中，put() 方法和 hash 算法有关代码如下：

 

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        //...........省略部分
    }

 

 

final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

HashMap的功能是通过“键(key)”能够快速的找到“值”。下面我们分析下HashMap计算下标索引的思路：

1、 当调用put(key,value)时，首先获取key的hashcode，int hash = key.hashCode();
2、 再把hash通过一下运算得到一个int h。

hash ^= (hash >>> 20) ^ (hash >>> 12);
int h = hash ^ (hash >>> 7) ^ (hash >>> 4);

为什么要经过这样的运算呢？这就是HashMap的高明之处。先看个例子，一个十进制数32768(二进制1000 0000 0000 0000)，经过上述公式运算之后的结果是35080(二进制1000 1001 0000 1000)。看出来了吗？或许这样还看不出什么，再举个数字61440(二进制1111 0000 0000 0000)，运算结果是65263(二进制1111 1110 1110 1111)，现在应该很明显了，它的目的是让“1”变的均匀一点，散列的本意就是要尽量均匀分布。假设key.hashCode()的值为：0x7FFFFFFF， table.length为默认值16。它的详细运行过程如下图 3 所示。

图 3

3、 得到h之后，下一步便要解决，怎样通过 h ，得到元素的数组下标。

前面说过hashmap的底层采用数组盛放数据，所以我们当然希望这个hashmap里面的元素位置尽量的分布均匀些，尽量使得每个位置上的元素数量只有一个，这样当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，而不用再去遍历链表。 所以我们首先想到最简单的办法就是把hashcode对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。这也是 HashTable 采用的策略，HashTable中的算法只是把key的 hashcode与length相除取余，即hash % length，这样有可能会造成index分布不均匀。而且，“模”运算的消耗还是比较大的，能不能找一种更快速，消耗更小的方式那？java中是这样做的：

 

/**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

将取得的 h 跟数组的长度-1做一次“与”运算（&）。看上去很简单，其实比较有玄机。比如数组的长度是2的4次方，那么hashcode就会和2的4次方-1做“与”运算。很多人都有这个疑问，为什么hashmap的数组初始化大小都是2的次方大小时，hashmap的效率最高，我以2的4次方举例，来解释一下为什么数组大小为2的幂时hashmap访问的性能最高。

看下图 4，左边两组是数组长度为16（2的4次方），右边两组是数组长度为15。两组的hashcode均为8和9，但是很明显，当它们和1110“与”的时候，产生了相同的结果，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到同一个链表上，那么查询的时候就需要遍历这个链表，得到8或者9，这样就降低了查询的效率。同时，我们也可以发现，当数组长度为15的时候，hashcode的值会与14（1110）进行“与”，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个末尾都为1 的位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！

图 4

所以说，当数组长度为2的n次幂的时候，不同的key算得得index相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了。

说到这里，我们再回头看一下hashmap中默认的数组大小是多少，查看源代码可以得知是16，为什么是16，而不是15，也不是20呢，看到上面annegu的解释之后我们就清楚了吧，显然是因为16是2的整数次幂的原因，在小数据量的情况下16比15和20更能减少key之间的碰撞，而加快查询的效率。

所以，在存储大容量数据的时候，最好预先指定hashmap的size为2的整数次幂次方。就算不指定的话，也会以大于且最接近指定值大小的2次幂来初始化的。

 

4、 HashMap 的 resize() 性能瓶颈

当hashmap中的元素越来越多的时候，碰撞的几率也就越来越高（因为数组的长度是固定的），所以为了提高查询的效率，就要对hashmap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，所以这是一个通用的操作，很多人对它的性能表示过怀疑。在hashmap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

那么hashmap什么时候进行扩容呢？当hashmap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，也就是说，默认情况下，数组大小为16，那么当hashmap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知hashmap中元素的个数，那么预设元素的个数能够有效的提高hashmap的性能。比如说，我们有1000个元素new HashMap(1000), 但是理论上来讲new HashMap(1024)更合适，不过上面annegu已经说过，即使是1000，hashmap也自动会将其设置为1024。 但是new HashMap(1024)还不是更合适的，因为0.75*1000 < 1000, 也就是说为了让0.75 * size > 1000, 我们必须这样new HashMap(2048)才最合适，既考虑了&的问题，也避免了resize的问题。

 

总结：

本文主要描述了HashMap的结构，put 操作的详细实现，hashmap中hash函数的实现，以及该实现的特性，同时描述了hashmap中resize带来性能消耗的根本原因。尤其是hash函数的实现，可以说是整个HashMap的精髓所在，只有真正理解了这个hash函数，才可以说对HashMap有了一定的理解。