hashmap

HashMap是我们最常用的类之一，它实现了hash算法，虽然使用很简单，但是其实现有很多值得研究的地方。

HashMap存储的是key-value形式的键值对，这个键值对在实现中使用一个静态内部类Entry来表示，它存储了key、value、hash值、以及在hash冲突时链表中下一个元素的引用。

HashMap底层实现使用了一个数组来存储元素。它的初始容量默认是16，而且必须容量必须是2的整数次幂，最大容量是1<<30（10.7亿+），同时还使用一个加载因子（load factor）来控制这个map的这个hash表的扩容，默认为0.75，即当容量达到初始容量3/4时会扩容（当然不只这样，后面会说明）。

在往HashMap中添加元素时，会计算key的hashCode，然后基于这个hashCode和数组大小来确定它在数组中的存储位置，当遇到hash冲突时，会以链表的形式存储在数组中。

下面具体看看源码，首先看构造方法

[java]  view plain  copy

1. public HashMap(int initialCapacity, float loadFactor) {  
2. // 初始容量不能小于0，否则会抛出异常  
3.     if (initialCapacity < 0)  
4.         throw new IllegalArgumentException("Illegal initial capacity: " +  
5.                                            initialCapacity);  
6.     // 控制初始容量不能大于最大容量1<<30  
7.     if (initialCapacity > MAXIMUM_CAPACITY)  
8.         initialCapacity = MAXIMUM_CAPACITY;  
9.     // 检查加载因子的合法性，不能小于0，且必须是数值  
10.     if (loadFactor <= 0 || Float.isNaN(loadFactor))  
11.         throw new IllegalArgumentException("Illegal load factor: " +  
12.                                            loadFactor);  
13.   
14.     this.loadFactor = loadFactor;  
15.     threshold = initialCapacity;  
16.     // 这个init方法是留给子类扩展  
17.     init();  
18. }  

可以看到在创建HashMap时，并不分配内存空间，而是在真正往map中添加数据时才会分配，可以从put方法中看到：

[java]  view plain  copy

1. public V put(K key, V value) {  
2.     // 创建时未分配空间，所以检查如果还是空表的话，就分配内存空间  
3.     if (table == EMPTY_TABLE) {  
4.         inflateTable(threshold);  
5.     }  
6.     // 对null的key进行的特殊处理  
7.     if (key == null)  
8.         return putForNullKey(value);  
9.     // 计算key的hashCode  
10.     int hash = hash(key);  
11.     // 根据hashCode和当前容量来确定元素在hash表中的位置，即hash桶的位置  
12.     int i = indexFor(hash, table.length);  
13.     // 检查key是否已经存在，如果已经存在，则替换旧值为新值，并返回旧值  
14.     for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
15.         Object k;  
16.         // 这里可以看到是根据hashCode和equals方法来判断一个key是否已经存在  
17.         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
18.             V oldValue = e.value;  
19.             e.value = value;  
20.             e.recordAccess(this);  
21.             return oldValue;  
22.         }  
23.     }  
24.     // 增加map的修改次数，这用于实现fail-fast机制  
25.     modCount++;  
26.     // 真正把元素添加到hash表中指定的索引位置处理（也叫hash桶）  
27.     addEntry(hash, key, value, i);  
28.     // 返回null表示key之前不存在  
29.     return null;  
30. }  
31.   
32. void addEntry(int hash, K key, V value, int bucketIndex) {  
33. // 判断是否需要扩容，当前容量达到阙值，并且产生了hash冲突（指定hash桶已经有元素存在）  
34.     if ((size >= threshold) && (null != table[bucketIndex])) {  
35.         // 容量扩展为之前的2倍  
36.         resize(2 * table.length);  
37.         hash = (null != key) ? hash(key) : 0;  
38.         // 重新计算存储的hash桶位置  
39.         bucketIndex = indexFor(hash, table.length);  
40.     }  
41.     // 创建Entry并存储到hash表中  
42.     createEntry(hash, key, value, bucketIndex);  
43. }  
44.   
45. void createEntry(int hash, K key, V value, int bucketIndex) {  
46. // 取出之前已经存在的元素  
47.     Entry<K,V> e = table[bucketIndex];  
48.     // 把新元素放到链表的开头，即让新元素的next引用指向之前已经存在的元素  
49.     table[bucketIndex] = new Entry<>(hash, key, value, e);  
50.     // 修改元素计数  
51.     size++;  
52. }  

从代码中可以看到， 扩容需要满足以下两个条件 ：

1. 达到加载因子指定的阙值
2. put当前值时发生hash冲突（即当前桶的位置已经存在有元素了）

只是当前容器中key value数量超过阙值是不会进行扩容的。就是说，比如初始容量为16，当达到阙值以前发生大量的hash冲突，而后添加的元素又很少发生hash冲突，那么有可能key value的数量超过16*0.75=12甚至超过16都不进行扩容，所以hash算法必须保证分布均匀，尽量减少hash冲突。

上面是添加元素的实现，这里再看看它是如何初始化并分配内存的：

[java]  view plain  copy

1. private void inflateTable(int toSize) {  
2.     // 保证容量是2的整数次幂  
3.     int capacity = roundUpToPowerOf2(toSize);  
4.     // 在初始化的时候就把扩容的阙值计算好并保存，避免每次都重新计算  
5.     threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);  
6.     // 这里才会真正的分配内存  
7.     table = new Entry[capacity];  
8.     // 初始化hash种子  
9.     initHashSeedAsNeeded(capacity);  
10. }  
11. /** 
12.  * 保证容量是2的整数次幂，并且不超过最大容量。 
13.  * 比如：传入的是15，值变成16，传入的是17，则会变成32， 
14.  * 即大于当前值且与最接近2的整数次幂的数 
15.  */  
16. private static int roundUpToPowerOf2(int number) {  
17.     // 保证容量是2的整数次幂，并且不超过最大容量  
18.     return number >= MAXIMUM_CAPACITY  
19.             ? MAXIMUM_CAPACITY  
20.             : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;  
21. }  

对null key的特殊处理：

[java]  view plain  copy

1. private V putForNullKey(V value) {  
2. // 如果已经存在，则替换旧值  
3.     for (Entry<K,V> e = table[0]; e != null; e = e.next) {  
4.         if (e.key == null) {  
5.             V oldValue = e.value;  
6.             e.value = value;  
7.             e.recordAccess(this);  
8.             return oldValue;  
9.         }  
10.     }  
11.     // 增加map的修改次数，这用于实现fail-fast机制  
12.     modCount++;  
13.     // null key的hashCode固定为0，并且桶的位置也固定为0  
14.     addEntry(0, null, value, 0);  
15.     return null;  
16. }  

再来看如何确定非null key的位置

[java]  view plain  copy

1. static int indexFor(int h, int length) {  
2.     return h & (length-1);  
3. }  

h是key的hashCode，length是当前hash表的最大长度，h & (length-1)与h % length等价，只是前者使用位运算，而位运算比取模运算速度更快。这里为什么可以用&运算代替取模运算呢？因为length是2的整数次幂，而它减1，低位正好全是1，与另一个数进行&运算，结果肯定不会超过length，与%运算的效果一样。如果length不是2的整数次幂，那么是不能这样做的，所以这里运用的非常巧妙。

下面看看最核心的生成hashCode的hash方法：

[java]  view plain  copy

1. final int hash(Object k) {  
2.     int h = hashSeed;  
3.     if (0 != h && k instanceof String) {  
4.         return sun.misc.Hashing.stringHash32((String) k);  
5.     }  
6.     // 调用key的hashCode()方法得到hashCode  
7.     h ^= k.hashCode();  
8.   
9.     // 对hashCode进行一系列的位移与异或运算并把结果作为hashCode返回  
10.     h ^= (h >>> 20) ^ (h >>> 12);  
11.     return h ^ (h >>> 7) ^ (h >>> 4);  
12. }  

这里 为什么要进行这一系列的位移与异或运算 呢？主要是经过它这里的运算之后，能够使这个hashCode中的bit 0和1均匀分布，从而减少hash冲突，从而提高整个HashMap的效率。

扩容时的rehash：

[java]  view plain  copy

1. void resize(int newCapacity) {  
2.     Entry[] oldTable = table;  
3.     int oldCapacity = oldTable.length;  
4.     if (oldCapacity == MAXIMUM_CAPACITY) {  
5.         threshold = Integer.MAX_VALUE;  
6.         return;  
7.     }  
8.     // 重新创建底层数组  
9.     Entry[] newTable = new Entry[newCapacity];  
10.     // 对已经存在的元素进行重新hash放到新的hash桶中  
11.     transfer(newTable, initHashSeedAsNeeded(newCapacity));  
12.     table = newTable;  
13.     // 更新扩容阙值  
14.     threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);  
15. }  
16.   
17. void transfer(Entry[] newTable, boolean rehash) {  
18.     int newCapacity = newTable.length;  
19.     for (Entry<K,V> e : table) {  
20.         while(null != e) {  
21.             Entry<K,V> next = e.next;  
22.             if (rehash) {  
23.                 e.hash = null == e.key ? 0 : hash(e.key);  
24.             }  
25.             int i = indexFor(e.hash, newCapacity);  
26.             e.next = newTable[i];  
27.             newTable[i] = e;  
28.             e = next;  
29.         }  
30.     }  
31. }  

由于hash表长度变化了，所以对于已经存在的元素，需要重新计算hashCode并放到新的hash桶中。这是一个比较耗时的操作，所以在创建HashMap时，如果对数据量有个预期值，那么，应该设置更合适的初始容量，以避免添加数据的过程中不断的扩容造成的性能损失。

下面再来看看get操作

[java]  view plain  copy

1. public V get(Object key) {  
2. // null key进行特殊操作  
3.     if (key == null)  
4.         return getForNullKey();  
5.     // 获取key对应的Entry  
6.     Entry<K,V> entry = getEntry(key);  
7.     // 如果存在则返回key对应的值，不存在则返回null  
8.     return null == entry ? null : entry.getValue();  
9. }  
10.   
11. final Entry<K,V> getEntry(Object key) {  
12. // size为0表示没有元素，所以直接返回null  
13.     if (size == 0) {  
14.         return null;  
15.     }  
16.     // 获取key的hashCode  
17.     int hash = (key == null) ? 0 : hash(key);  
18.     // 获取key对应的hash桶中的元素，并对链表进行迭代返回相应的value  
19.     for (Entry<K,V> e = table[indexFor(hash, table.length)];  
20.          e != null;  
21.          e = e.next) {  
22.         Object k;  
23.         // 根据hashCode和equalse（）方法来确定key  
24.         if (e.hash == hash &&  
25.             ((k = e.key) == key || (key != null && key.equals(k))))  
26.             return e;  
27.     }  
28.     // 如果不存在，返回null  
29.     return null;  
30. }  

对于加载因子，默认为0.75，这是一个折衷的值， 我们可以通过构造方法来改变这个值，但是需要注意， 加载因子越大，查询数据的开销可能越大 。因为加载因子越大，意味着map中存放的元素越多，所以hash冲突的可能性越大，根据hashCode计算出的hash桶的位置相同，则保存为链表，而链表的查询操作会遍历整个链表，所以查询效率不高。而在get和put时都要查询元素，所以提高查询效率就提高了hashmap的效率。这是一种用空间换取时间的策略。

为什么HashMap很高效呢？HashMap通过以下几点保证了它的效率：

• 高效的hash算法，使其不易产生hash冲突
• 基于数组存储，实现了元素的快速存取
• 可通过加载因子，使用空间换取时间

转：http://blog.csdn.net/mhmyqn/article/details/48143465#