一个面试题:
往HashMap中存100个元素,问:HashMap的初始化大小是多少最合适?
HashMap概述:
HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作,并允许使用null键和null值。此类不保证映射的顺序,特别是它不保证该顺序恒久不变。
HashMap的数据结构:
在java编程语言中,最基本的数据结构就只有两种,一种是数组,另一种是模拟指针(地址引用),其他的复杂数据结构,如二叉树、图,我目前是没见过相应实现。在java中,所有的高级数据结构都可以通过这两种基本结构来构造。HashMap也不例外。
HashMap实际上是一个数组和链表构成的散列表,如图:
HashMap初始化源码:
点击(此处)折叠或打开
- public class HashMap {
- Entry[] table;
- …
- public HashMap(int initialCapacity, float loadFactor) {
- … .
- table = new Entry[capacity];
- }
- …
- static class Entry{
- final K key;
- V value;
- Entry<K,V> next;
- final int hash;
- …
- }
- }
从源码可以看出,Entry就是数组中的元素,每个Entry 其实就是一个key-value对,它持有一个指向下一个元素的引用next,这就是解决哈希冲突的关键。由它生成一张单链表。
下面说说最重要的方法put与get方法:
先看源码:
点击(此处)折叠或打开
- public V put(K key, V value) {
- int hash = hash(key.hashCode());
- int i = indexFor(hash, table.length);
- 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;
- e.recordAccess(this);
- return oldValue;
- }
- }
- addEntry(hash, key, value, i);
- }
-
- void addEntry(int hash, K key, V value, int bucketIndex) {
- Entry<K,V> e = table[bucketIndex];
- table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
- }
Entry构造函数:
点击(此处)折叠或打开
- Entry ( int h, K k, V v, Entry<K,V> n) {
- value = v; next = n; key = k; hash = h;
- }
不难看出,put做了两件事:
1,遍历Entry链表,如果找到跟key“相同”的旧key,则覆盖旧值。这里的“相同”指hash值相同、内容相同(即equals返回true)
2,若没有找到“相同”的旧key,则用key、value构造新的Entry插入到链表的表头,让其next指向原来的Entry。
点击(此处)折叠或打开
- public V get(Object key) {
- int hash = hash(key.hashCode());
- for (Entry<K,V> e = table[indexFor(hash, table.length)];
- e != null;
- e = e.next) {
- Object k;
- if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
- return e.value;
- }
- }
从上面的代码可以看出,从HashMap中get元素时,首先计算key的hasCode,找到数组中对应位置的Entry,然后遍历Entry链表,直到找到key.equals(k)返回true的元素,完成。
而我们知道,链表的查询是相当耗时的(大小同为n的数组和链表,时间复杂度分别为1和(n+1)/2 ) ,所以我们希望HashMap的元素尽可能的分布均匀些,尽可能少的产生哈希冲突,这样就不必构造单链表。怎样达到“均匀分布”呢?我们首相想到的是把hash值对数组长度取模运算,这样,元素的分布相对来说是比较均匀的。但是模运算比较耗性能,HashMap是这样做的:int i = indexFor(hash, table.length);
i 就是元素的下标,indexFor的实现:
点击(此处)折叠或打开
- static int indexFor(int h, int length) {
- return h & (length-1);
- }
所以,为了让下标i均匀地分布,我们必须让h & (length-1)尽可能少地产生哈希冲突。所以,我们初始化HashMap的大小直接影响着HashMap的性能。
举个例子:假如数组的长度为15,两个元素的hash值分别为8、9,计算h & (length-1)的结果,
8:1000 & 1110 = 1000
9:1001 & 1110 = 1000
所以,8、9产生哈希冲突,成为同义词,他们将利用拉链法生成单链表,影响性能,而更糟的是,0001、0011、0101、1001、1011、0111、1101这几个位置永远无法利用,空间浪费相当大,可使用的位置非常少,进一步增加了冲突的几率。
而如果数组的长度为16, h & (length-1)情况如下:
8:1000 & 1111 = 1000
9:1001 & 1111 = 1001
不同的hash值将产生不同的数组下标,有效地避免了hash冲突。这就是我们为什么要将HashMap的初始化大小设置为2的n次方的缘故。即使我们不指定大小或指定大小为非2的n次方,HasMap也会暗中帮我们转化为2的n次方:
点击(此处)折叠或打开
- // Find a power of 2 >= initialCapacity
- int capacity = 1;
- while (capacity < initialCapacity)
- capacity <<= 1
所以,100个元素,new HashMap(?)
HashMap的扩容
当HashMap中的元素越来越多时,哈希冲突的机遇就越来越高(因为数组的长度是固定的,大部分位置已经被占有),所以为了提高查询效率,就要对HashMap的数组进行扩容。可能有人怀疑其性能,因为HashMap扩容之后,会发生resize操作,即:原数组中的元素必须重新计算其在新数组中的位置,并且放进去。但考虑到链表查询的时间复杂度和resize的时间复杂度,不难做出选择。
那HashMap什么时候进行扩容?在HashMap中有一个loadFactor(加载因子),当元素个数超过数组大小*loadFactor时,就会进行扩容。loadFactor的默认值为0.75(对空间和时间效率的一个平衡选择),也就是说,默认情况下,数组大小为16,当HashMap中元素个数超过16*0.75=12时,就会把数组的大小扩展为16*2=32,然后重新计算每个元素在新数组中的位置。这是一个耗性能的操作,也要尽量避免。所以如果我们已经知道元素的个数,初始化时设置相应的大小能有效地提高HashMap的性能。
回到本文开头,现在有100个元素,new HashMap时,首先考虑避免哈希冲突,我们会new HashMap(128),但这还不是最合适的大小,因为0.75*128=96<100,即,put第96个元素时,会自动进行扩容,所以,为了避免扩容的resize带来的影响,我们最好设置new HashMap(256)。
来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/28912557/viewspace-1254882/,如需转载,请注明出处,否则将追究法律责任。
转载于:http://blog.itpub.net/28912557/viewspace-1254882/