HashMap常问面试题整理

去面试时,hashmap总是被经常问的问题,下面总结了几道关于hashmap的问题。

1、hashmap的主要参数都有哪些?

2、hashmap的数据结构是什么样子的?自己如何实现一个hashmap?

3、hash计算规则是什么?

4、说说hashmap的存取过程?

5、说说hashmap如何处理碰撞的,或者说说它的扩容?

解答:以1.7为例,也会掺杂一些1.8的不同点。

1、

1)桶(capacity)容量,即数组长度:DEFAULT_INITIAL_CAPACITY=1<<4;默认值为16

  即在不提供有参构造的时候,声明的hashmap的桶容量;

2)MAXIMUM_CAPACITY = 1 << 30;

  极限容量,表示hashmap能承受的最大桶容量为2的30次方,超过这个容量将不再扩容,让hash碰撞起来吧!

3)static final float DEFAULT_LOAD_FACTOR = 0.75f;

  负载因子(loadfactor,默认0.75),负载因子有个奇特的效果,表示当当前容量大于(size/)时,将进行hashmap的扩容,扩容一般为扩容为原来的两倍。

4)int threshold;阈值

  阈值算法为capacity*loadfactory,大致当map中entry数量大于此阈值时进行扩容(1.8)

5)transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;(默认为空{})

  核心的数据结构,即所谓的数组+链表的部分。

2、hashmap的数据结构是什么样子的?自己如何实现一个hashmap?

  主要数据结构即为数组+链表。

  在hashmap中的主要表现形式为一个table,类型为Entry<K,V>[] table

  首先是一个Entry型的数组,Entry为hashmap的内部类:

  

1 static class Entry<K,V> implements Map.Entry<K,V> {
2         final K key;
3         V value;
4         Entry<K,V> next;
5         int hash;
6 }

  在这里可以看到,在Entry类中存在next,所以,它又是链表的形式。

  这就是hashmap的主要数据结构。

3、hash的计算规则,这又要看源码了:

  

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

  这是1.8的源码,1.7太复杂但原理是一致的,简单说这就是个“扰动函数”,最终的目的是让散列分布地更加均匀。

  算法就是拿存储key的hashcode值先右移16位,再与hashcode值进行亦或操作,即不求进位只求按位相加的值:盗图:

  

  最后是如何获得,本key在table中的位置呢?本身应该是取得了hash进行磨除取余运算,但是,源码:

1 static int indexFor(int h, int length) {
2         // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
3         return h & (length-1);
4     }

  为什么又做了个与运算求得位置呢?简单说,它的意义和取余一致。

  不信可以自己算一下。

  首先说,他利用了table的长度肯定是2的整数次幂的原理,假设当前length为16,2的4次方

  而与&运算,又是只求进位运算,比如1111&110001结果为000001

  只求进位运算(&),保证算出的结果一定在table的length之内,最大为1111。

  故而,它的运算结果与价值等同于取余运算,并且即使不管hash值有多大都可以算出结果,并且在length之内。

  并且,这种类型的运算,能够更加的节约计算机资源,少了加(计算机所有运算都是加运行)运算过程,更加地节省资源。

4、hashmap的存取过程

  源码1.7:

 1 /**
 2 *往hashmap中放数据
 3 */
 4 public V put(K key, V value) {
 5         if (table == EMPTY_TABLE) {
 6             inflateTable(threshold);//判断如果为空table,先对table进行构造
 7             //构造通过前面的几个参数
 8         }
 9         //首先判断key是否为null,为null也可以存
10         //这里需要记住,null的key一定放在table的0号位置
11         if (key == null)
12             return putForNullKey(value);
13         //算出key的hash值
14         int hash = hash(key);
15         //根据hash值算出在table中的位置
16         int i = indexFor(hash, table.length);
17         //放入K\V,遍历链表,如果位置上存在相同key,进行替换value为新的,且将替换的旧的value返回
18         for (Entry<K,V> e = table[i]; e != null; e = e.next) {
19             Object k;
20             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
21                 V oldValue = e.value;
22                 e.value = value;
23                 e.recordAccess(this);
24                 return oldValue;
25             }
26         }
27         modCount++;
28         //增加一个entry,有两种情况,1、如果此位置存在entry,将此位置变为插入的entry,且将插入entry的next节点变为原来的entry;2、如果此位置不存在entry则直接插入新的entry
29         addEntry(hash, key, value, i);
30         return null;
31     }

取数据:

 1 //根据key获得一个entry
 2 public V get(Object key) {
 3         //如果key为null,获取0号位的切key为null的值
 4         if (key == null)
 5             return getForNullKey();
 6         //如果不是,获取entry,在下面方法
 7         Entry<K,V> entry = getEntry(key);
 8         //合法性判断
 9         return null == entry ? null : entry.getValue();
10     }
11 //获取一个key不为null的entry
12 final Entry<K,V> getEntry(Object key) {
13         //如果table为null,则返回null
14         if (size == 0) {
15             return null;
16         }
17         //计算hash值
18         int hash = (key == null) ? 0 : hash(key);
19         //根据hash值获得table的下标,遍历链表,寻找key,找到则返回
20         for (Entry<K,V> e = table[indexFor(hash, table.length)];
21              e != null;
22              e = e.next) {
23             Object k;
24             if (e.hash == hash &&
25                 ((k = e.key) == key || (key != null && key.equals(k))))
26                 return e;
27         }
28         return null;
29     }

 5.扩容和碰撞

  先说碰撞吧,由于hashmap在存值的时候并不是直接使用的key的hashcode,而是通过扰动函数算出了一个新的hash值,这个计算出的hash值可以明显的减少碰撞。

  还有一种解决碰撞的方式就是扩容,扩容其实很好理解,就是将原来桶的容量扩为原来的两倍。这样争取散列的均匀,比如:

  原来桶的长度为16,hash值为1和17的entry将会都在桶的0号位上,这样就出现了碰撞,而当桶扩容为原来的2倍时,hash值为1和17的entry分别在1和17号位上,整号岔开了碰撞。

  下面说说何时扩容,扩容都做了什么。

  1.7中,在put元素的过程中,判断table不为空、切新增的元素的key不与原来的重合之后,进行新增一个entry的逻辑。

1 void addEntry(int hash, K key, V value, int bucketIndex) {
2         if ((size >= threshold) && (null != table[bucketIndex])) {
3             resize(2 * table.length);
4             hash = (null != key) ? hash(key) : 0;
5             bucketIndex = indexFor(hash, table.length);
6         }
7         createEntry(hash, key, value, bucketIndex);
8     }

  由源代码可知,在新增元素时,会先判断:

  1)当前的entry数量是否大于或者等于阈值(loadfactory*capacity);

  2)判断当前table的位置是否存在entry。

  经上两个条件联合判定,才会进行数组的扩容工作,最后扩容完成才会去创建新的entry。

  而扩容的方法即为:resize()看代码

  

 1 void resize(int newCapacity) {
 2         //拿到原table对象
 3         Entry[] oldTable = table;
 4         //计算原table的桶长度
 5         int oldCapacity = oldTable.length;
 6         //先判定,当前容量是否已经是最大容量了(2的30次方)
 7         if (oldCapacity == MAXIMUM_CAPACITY) {
 8             //假如达到了,将阈值设为int的最大值2的31次方减1,返回
 9             threshold = Integer.MAX_VALUE;
10             return;
11         }
12         //创建新的table对象
13         Entry[] newTable = new Entry[newCapacity];
14         //将旧的table放入新的table中
15         transfer(newTable, initHashSeedAsNeeded(newCapacity));
16         //赋值新table
17         table = newTable;
18         //计算新的阈值
19         threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
20     }
21 //具体的扩容过程
22 void transfer(Entry[] newTable, boolean rehash) {
23         int newCapacity = newTable.length;
24         //遍历原table,重新散列
25         for (Entry<K,V> e : table) {
26             while(null != e) {
27                 Entry<K,V> next = e.next;
28                 if (rehash) {
29                     e.hash = null == e.key ? 0 : hash(e.key);
30                 }
31                 int i = indexFor(e.hash, newCapacity);
32                 e.next = newTable[i];
33                 newTable[i] = e;
34                 e = next;
35             }
36         }
37     }

至此,扩容就说完了。。。

posted @ 2018-04-07 23:09 清风小妖的天空521 阅读(...) 评论(...) 编辑 收藏