码迷,mamicode.com
首页 > 其他好文 > 详细

深入理解 hash 函数、HashMap、LinkedHashMap、TreeMap 【上】

时间:2014-09-18 03:06:23      阅读:361      评论:0      收藏:0      [点我收藏+]

标签:hashmap   hash   算法   

前言

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

bubuko.com,布布扣

图 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直接取到所对应的数据。而对于发生碰撞的位置,则会维护一个链表,所有在同一位置发生碰撞的元素都会存放在同一位置的链表中。

bubuko.com,布布扣

图 2

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

	static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> 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<K, V> 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<K, V> 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 所示。

bubuko.com,布布扣

图 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 的位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率! 

bubuko.com,布布扣

图 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有了一定的理解。


转载请注明原文地址:http://blog.csdn.net/zq602316498/

本文部分内容和图片来自于网络





深入理解 hash 函数、HashMap、LinkedHashMap、TreeMap 【上】

标签:hashmap   hash   算法   

原文地址:http://blog.csdn.net/zq602316498/article/details/39351363

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!