（1）HashMap源码解析

转载----http://blog.csdn.net/ns_code/article/details/36034955

另：

另外一篇源码分析也不错，这里附上链接：http://blog.csdn.net/vking_wang/article/details/14166593#comments

HashMap简介

    HashMap是基于哈希表实现的，每一个元素是一个key-value对，其内部通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。

    HashMap是非线程安全的，只是用于单线程环境下，多线程环境下可以采用concurrent并发包下的concurrentHashMap。

    HashMap 实现了Serializable接口，因此它支持序列化，实现了Cloneable接口，能被克隆。

HashMap源码剖析

    HashMap的源码如下(加入了比较详细的注释)：

[java]  view plain  copy

 

1. package java.util;    
2. import java.io.*;    
3.    
4. public class HashMap<K,V>    
5.     extends AbstractMap<K,V>    
6.     implements Map<K,V>, Cloneable, Serializable    
7. {    
8.    
9.     // 默认的初始容量（容量为HashMap中槽的数目）是16，且实际容量必须是2的整数次幂。    
10.     static final int DEFAULT_INITIAL_CAPACITY = 16;    
11.    
12.     // 最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换）    
13.     static final int MAXIMUM_CAPACITY = 1 << 30;    
14.    
15.     // 默认加载因子为0.75   
16.     static final float DEFAULT_LOAD_FACTOR = 0.75f;    
17.    
18.     // 存储数据的Entry数组，长度是2的幂。    
19.     // HashMap采用链表法解决冲突，每一个Entry本质上是一个单向链表    
20.     transient Entry[] table;    
21.    
22.     // HashMap的底层数组中已用槽的数量    
23.     transient int size;    
24.    
25.     // HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子）    
26.     int threshold;    
27.    
28.     // 加载因子实际大小    
29.     final float loadFactor;    
30.    
31.     // HashMap被改变的次数    
32.     transient volatile int modCount;    
33.    
34.     // 指定“容量大小”和“加载因子”的构造函数    
35.     public HashMap(int initialCapacity, float loadFactor) {    
36.         if (initialCapacity < 0)    
37.             throw new IllegalArgumentException("Illegal initial capacity: " +    
38.                                                initialCapacity);    
39.         // HashMap的最大容量只能是MAXIMUM_CAPACITY    
40.         if (initialCapacity > MAXIMUM_CAPACITY)    
41.             initialCapacity = MAXIMUM_CAPACITY;    
42.         //加载因此不能小于0  
43.         if (loadFactor <= 0 || Float.isNaN(loadFactor))    
44.             throw new IllegalArgumentException("Illegal load factor: " +    
45.                                                loadFactor);    
46.    
47.         // 找出“大于initialCapacity”的最小的2的幂    
48.         int capacity = 1;    
49.         while (capacity < initialCapacity)    
50.             capacity <<= 1;    
51.    
52.         // 设置“加载因子”    
53.         this.loadFactor = loadFactor;    
54.         // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。    
55.         threshold = (int)(capacity * loadFactor);    
56.         // 创建Entry数组，用来保存数据    
57.         table = new Entry[capacity];    
58.         init();    
59.     }    
60.    
61.    
62.     // 指定“容量大小”的构造函数    
63.     public HashMap(int initialCapacity) {    
64.         this(initialCapacity, DEFAULT_LOAD_FACTOR);    
65.     }    
66.    
67.     // 默认构造函数。    
68.     public HashMap() {    
69.         // 设置“加载因子”为默认加载因子0.75    
70.         this.loadFactor = DEFAULT_LOAD_FACTOR;    
71.         // 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。    
72.         threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);    
73.         // 创建Entry数组，用来保存数据    
74.         table = new Entry[DEFAULT_INITIAL_CAPACITY];    
75.         init();    
76.     }    
77.    
78.     // 包含“子Map”的构造函数    
79.     public HashMap(Map<? extends K, ? extends V> m) {    
80.         this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,    
81.                       DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);    
82.         // 将m中的全部元素逐个添加到HashMap中    
83.         putAllForCreate(m);    
84.     }    
85.    
86.     //求hash值的方法，重新计算hash值  
87.     static int hash(int h) {    
88.         h ^= (h >>> 20) ^ (h >>> 12);    
89.         return h ^ (h >>> 7) ^ (h >>> 4);    
90.     }    
91.    
92.     // 返回h在数组中的索引值，这里用&代替取模，旨在提升效率   
93.     // h & (length-1)保证返回值的小于length    
94.     static int indexFor(int h, int length) {    
95.         return h & (length-1);    
96.     }    
97.    
98.     public int size() {    
99.         return size;    
100.     }    
101.    
102.     public boolean isEmpty() {    
103.         return size == 0;    
104.     }    
105.    
106.     // 获取key对应的value    
107.     public V get(Object key) {    
108.         if (key == null)    
109.             return getForNullKey();    
110.         // 获取key的hash值    
111.         int hash = hash(key.hashCode());    
112.         // 在“该hash值对应的链表”上查找“键值等于key”的元素    
113.         for (Entry<K,V> e = table[indexFor(hash, table.length)];    
114.              e != null;    
115.              e = e.next) {    
116.             Object k;    
117.             //判断key是否相同  
118.             if (e.hash == hash && ((k = e.key) == key || key.equals(k)))    
119.                 return e.value;    
120.         }  
121.         //没找到则返回null  
122.         return null;    
123.     }    
124.    
125.     // 获取“key为null”的元素的值    
126.     // HashMap将“key为null”的元素存储在table[0]位置，但不一定是该链表的第一个位置！    
127.     private V getForNullKey() {    
128.         for (Entry<K,V> e = table[0]; e != null; e = e.next) {    
129.             if (e.key == null)    
130.                 return e.value;    
131.         }    
132.         return null;    
133.     }    
134.    
135.     // HashMap是否包含key    
136.     public boolean containsKey(Object key) {    
137.         return getEntry(key) != null;    
138.     }    
139.    
140.     // 返回“键为key”的键值对    
141.     final Entry<K,V> getEntry(Object key) {    
142.         // 获取哈希值    
143.         // HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值    
144.         int hash = (key == null) ? 0 : hash(key.hashCode());    
145.         // 在“该hash值对应的链表”上查找“键值等于key”的元素    
146.         for (Entry<K,V> e = table[indexFor(hash, table.length)];    
147.              e != null;    
148.              e = e.next) {    
149.             Object k;    
150.             if (e.hash == hash &&    
151.                 ((k = e.key) == key || (key != null && key.equals(k))))    
152.                 return e;    
153.         }    
154.         return null;    
155.     }    
156.    
157.     // 将“key-value”添加到HashMap中    
158.     public V put(K key, V value) {    
159.         // 若“key为null”，则将该键值对添加到table[0]中。    
160.         if (key == null)    
161.             return putForNullKey(value);    
162.         // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。    
163.         int hash = hash(key.hashCode());    
164.         int i = indexFor(hash, table.length);    
165.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {    
166.             Object k;    
167.             // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！    
168.             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {    
169.                 V oldValue = e.value;    
170.                 e.value = value;    
171.                 e.recordAccess(this);    
172.                 return oldValue;    
173.             }    
174.         }    
175.    
176.         // 若“该key”对应的键值对不存在，则将“key-value”添加到table中    
177.         modCount++;  
178.         //将key-value添加到table[i]处  
179.         addEntry(hash, key, value, i);    
180.         return null;    
181.     }    
182.    
183.     // putForNullKey()的作用是将“key为null”键值对添加到table[0]位置    
184.     private V putForNullKey(V value) {    
185.         for (Entry<K,V> e = table[0]; e != null; e = e.next) {    
186.             if (e.key == null) {    
187.                 V oldValue = e.value;    
188.                 e.value = value;    
189.                 e.recordAccess(this);    
190.                 return oldValue;    
191.             }    
192.         }    
193.         // 如果没有存在key为null的键值对，则直接题阿见到table[0]处!    
194.         modCount++;    
195.         addEntry(0, null, value, 0);    
196.         return null;    
197.     }    
198.    
199.     // 创建HashMap对应的“添加方法”，    
200.     // 它和put()不同。putForCreate()是内部方法，它被构造函数等调用，用来创建HashMap    
201.     // 而put()是对外提供的往HashMap中添加元素的方法。    
202.     private void putForCreate(K key, V value) {    
203.         int hash = (key == null) ? 0 : hash(key.hashCode());    
204.         int i = indexFor(hash, table.length);    
205.    
206.         // 若该HashMap表中存在“键值等于key”的元素，则替换该元素的value值    
207.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {    
208.             Object k;    
209.             if (e.hash == hash &&    
210.                 ((k = e.key) == key || (key != null && key.equals(k)))) {    
211.                 e.value = value;    
212.                 return;    
213.             }    
214.         }    
215.    
216.         // 若该HashMap表中不存在“键值等于key”的元素，则将该key-value添加到HashMap中    
217.         createEntry(hash, key, value, i);    
218.     }    
219.    
220.     // 将“m”中的全部元素都添加到HashMap中。    
221.     // 该方法被内部的构造HashMap的方法所调用。    
222.     private void putAllForCreate(Map<? extends K, ? extends V> m) {    
223.         // 利用迭代器将元素逐个添加到HashMap中    
224.         for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {    
225.             Map.Entry<? extends K, ? extends V> e = i.next();    
226.             putForCreate(e.getKey(), e.getValue());    
227.         }    
228.     }    
229.    
230.     // 重新调整HashMap的大小，newCapacity是调整后的容量    
231.     void resize(int newCapacity) {    
232.         Entry[] oldTable = table;    
233.         int oldCapacity = oldTable.length;   
234.         //如果就容量已经达到了最大值，则不能再扩容，直接返回  
235.         if (oldCapacity == MAXIMUM_CAPACITY) {    
236.             threshold = Integer.MAX_VALUE;    
237.             return;    
238.         }    
239.    
240.         // 新建一个HashMap，将“旧HashMap”的全部元素添加到“新HashMap”中，    
241.         // 然后，将“新HashMap”赋值给“旧HashMap”。    
242.         Entry[] newTable = new Entry[newCapacity];    
243.         transfer(newTable);    
244.         table = newTable;    
245.         threshold = (int)(newCapacity * loadFactor);    
246.     }    
247.    
248.     // 将HashMap中的全部元素都添加到newTable中    
249.     void transfer(Entry[] newTable) {    
250.         Entry[] src = table;    
251.         int newCapacity = newTable.length;    
252.         for (int j = 0; j < src.length; j++) {    
253.             Entry<K,V> e = src[j];    
254.             if (e != null) {    
255.                 src[j] = null;    
256.                 do {    
257.                     Entry<K,V> next = e.next;    
258.                     int i = indexFor(e.hash, newCapacity);    
259.                     e.next = newTable[i];    
260.                     newTable[i] = e;    
261.                     e = next;    
262.                 } while (e != null);    
263.             }    
264.         }    
265.     }    
266.    
267.     // 将"m"的全部元素都添加到HashMap中    
268.     public void putAll(Map<? extends K, ? extends V> m) {    
269.         // 有效性判断    
270.         int numKeysToBeAdded = m.size();    
271.         if (numKeysToBeAdded == 0)    
272.             return;    
273.    
274.         // 计算容量是否足够，    
275.         // 若“当前阀值容量 < 需要的容量”，则将容量x2。    
276.         if (numKeysToBeAdded > threshold) {    
277.             int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);    
278.             if (targetCapacity > MAXIMUM_CAPACITY)    
279.                 targetCapacity = MAXIMUM_CAPACITY;    
280.             int newCapacity = table.length;    
281.             while (newCapacity < targetCapacity)    
282.                 newCapacity <<= 1;    
283.             if (newCapacity > table.length)    
284.                 resize(newCapacity);    
285.         }    
286.    
287.         // 通过迭代器，将“m”中的元素逐个添加到HashMap中。    
288.         for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {    
289.             Map.Entry<? extends K, ? extends V> e = i.next();    
290.             put(e.getKey(), e.getValue());    
291.         }    
292.     }    
293.    
294.     // 删除“键为key”元素    
295.     public V remove(Object key) {    
296.         Entry<K,V> e = removeEntryForKey(key);    
297.         return (e == null ? null : e.value);    
298.     }    
299.    
300.     // 删除“键为key”的元素    
301.     final Entry<K,V> removeEntryForKey(Object key) {    
302.         // 获取哈希值。若key为null，则哈希值为0；否则调用hash()进行计算    
303.         int hash = (key == null) ? 0 : hash(key.hashCode());    
304.         int i = indexFor(hash, table.length);    
305.         Entry<K,V> prev = table[i];    
306.         Entry<K,V> e = prev;    
307.    
308.         // 删除链表中“键为key”的元素    
309.         // 本质是“删除单向链表中的节点”    
310.         while (e != null) {    
311.             Entry<K,V> next = e.next;    
312.             Object k;    
313.             if (e.hash == hash &&    
314.                 ((k = e.key) == key || (key != null && key.equals(k)))) {    
315.                 modCount++;    
316.                 size--;    
317.                 if (prev == e)    
318.                     table[i] = next;    
319.                 else   
320.                     prev.next = next;    
321.                 e.recordRemoval(this);    
322.                 return e;    
323.             }    
324.             prev = e;    
325.             e = next;    
326.         }    
327.    
328.         return e;    
329.     }    
330.    
331.     // 删除“键值对”    
332.     final Entry<K,V> removeMapping(Object o) {    
333.         if (!(o instanceof Map.Entry))    
334.             return null;    
335.    
336.         Map.Entry<K,V> entry = (Map.Entry<K,V>) o;    
337.         Object key = entry.getKey();    
338.         int hash = (key == null) ? 0 : hash(key.hashCode());    
339.         int i = indexFor(hash, table.length);    
340.         Entry<K,V> prev = table[i];    
341.         Entry<K,V> e = prev;    
342.    
343.         // 删除链表中的“键值对e”    
344.         // 本质是“删除单向链表中的节点”    
345.         while (e != null) {    
346.             Entry<K,V> next = e.next;    
347.             if (e.hash == hash && e.equals(entry)) {    
348.                 modCount++;    
349.                 size--;    
350.                 if (prev == e)    
351.                     table[i] = next;    
352.                 else   
353.                     prev.next = next;    
354.                 e.recordRemoval(this);    
355.                 return e;    
356.             }    
357.             prev = e;    
358.             e = next;    
359.         }    
360.    
361.         return e;    
362.     }    
363.    
364.     // 清空HashMap，将所有的元素设为null    
365.     public void clear() {    
366.         modCount++;    
367.         Entry[] tab = table;    
368.         for (int i = 0; i < tab.length; i++)    
369.             tab[i] = null;    
370.         size = 0;    
371.     }    
372.    
373.     // 是否包含“值为value”的元素    
374.     public boolean containsValue(Object value) {    
375.     // 若“value为null”，则调用containsNullValue()查找    
376.     if (value == null)    
377.             return containsNullValue();    
378.    
379.     // 若“value不为null”，则查找HashMap中是否有值为value的节点。    
380.     Entry[] tab = table;    
381.         for (int i = 0; i < tab.length ; i++)    
382.             for (Entry e = tab[i] ; e != null ; e = e.next)    
383.                 if (value.equals(e.value))    
384.                     return true;    
385.     return false;    
386.     }    
387.    
388.     // 是否包含null值    
389.     private boolean containsNullValue() {    
390.     Entry[] tab = table;    
391.         for (int i = 0; i < tab.length ; i++)    
392.             for (Entry e = tab[i] ; e != null ; e = e.next)    
393.                 if (e.value == null)    
394.                     return true;    
395.     return false;    
396.     }    
397.    
398.     // 克隆一个HashMap，并返回Object对象    
399.     public Object clone() {    
400.         HashMap<K,V> result = null;    
401.         try {    
402.             result = (HashMap<K,V>)super.clone();    
403.         } catch (CloneNotSupportedException e) {    
404.             // assert false;    
405.         }    
406.         result.table = new Entry[table.length];    
407.         result.entrySet = null;    
408.         result.modCount = 0;    
409.         result.size = 0;    
410.         result.init();    
411.         // 调用putAllForCreate()将全部元素添加到HashMap中    
412.         result.putAllForCreate(this);    
413.    
414.         return result;    
415.     }    
416.    
417.     // Entry是单向链表。    
418.     // 它是 “HashMap链式存储法”对应的链表。    
419.     // 它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数    
420.     static class Entry<K,V> implements Map.Entry<K,V> {    
421.         final K key;    
422.         V value;    
423.         // 指向下一个节点    
424.         Entry<K,V> next;    
425.         final int hash;    
426.    
427.         // 构造函数。    
428.         // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"    
429.         Entry(int h, K k, V v, Entry<K,V> n) {    
430.             value = v;    
431.             next = n;    
432.             key = k;    
433.             hash = h;    
434.         }    
435.    
436.         public final K getKey() {    
437.             return key;    
438.         }    
439.    
440.         public final V getValue() {    
441.             return value;    
442.         }    
443.    
444.         public final V setValue(V newValue) {    
445.             V oldValue = value;    
446.             value = newValue;    
447.             return oldValue;    
448.         }    
449.    
450.         // 判断两个Entry是否相等    
451.         // 若两个Entry的“key”和“value”都相等，则返回true。    
452.         // 否则，返回false    
453.         public final boolean equals(Object o) {    
454.             if (!(o instanceof Map.Entry))    
455.                 return false;    
456.             Map.Entry e = (Map.Entry)o;    
457.             Object k1 = getKey();    
458.             Object k2 = e.getKey();    
459.             if (k1 == k2 || (k1 != null && k1.equals(k2))) {    
460.                 Object v1 = getValue();    
461.                 Object v2 = e.getValue();    
462.                 if (v1 == v2 || (v1 != null && v1.equals(v2)))    
463.                     return true;    
464.             }    
465.             return false;    
466.         }    
467.    
468.         // 实现hashCode()    
469.         public final int hashCode() {    
470.             return (key==null   ? 0 : key.hashCode()) ^    
471.                    (value==null ? 0 : value.hashCode());    
472.         }    
473.    
474.         public final String toString() {    
475.             return getKey() + "=" + getValue();    
476.         }    
477.    
478.         // 当向HashMap中添加元素时，绘调用recordAccess()。    
479.         // 这里不做任何处理    
480.         void recordAccess(HashMap<K,V> m) {    
481.         }    
482.    
483.         // 当从HashMap中删除元素时，绘调用recordRemoval()。    
484.         // 这里不做任何处理    
485.         void recordRemoval(HashMap<K,V> m) {    
486.         }    
487.     }    
488.    
489.     // 新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。    
490.     void addEntry(int hash, K key, V value, int bucketIndex) {    
491.         // 保存“bucketIndex”位置的值到“e”中    
492.         Entry<K,V> e = table[bucketIndex];    
493.         // 设置“bucketIndex”位置的元素为“新Entry”，    
494.         // 设置“e”为“新Entry的下一个节点”    
495.         table[bucketIndex] = new Entry<K,V>(hash, key, value, e);    
496.         // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小    
497.         if (size++ >= threshold)    
498.             resize(2 * table.length);    
499.     }    
500.    
501.     // 创建Entry。将“key-value”插入指定位置。    
502.     void createEntry(int hash, K key, V value, int bucketIndex) {    
503.         // 保存“bucketIndex”位置的值到“e”中    
504.         Entry<K,V> e = table[bucketIndex];    
505.         // 设置“bucketIndex”位置的元素为“新Entry”，    
506.         // 设置“e”为“新Entry的下一个节点”    
507.         table[bucketIndex] = new Entry<K,V>(hash, key, value, e);    
508.         size++;    
509.     }    
510.    
511.     // HashIterator是HashMap迭代器的抽象出来的父类，实现了公共了函数。    
512.     // 它包含“key迭代器(KeyIterator)”、“Value迭代器(ValueIterator)”和“Entry迭代器(EntryIterator)”3个子类。    
513.     private abstract class HashIterator<E> implements Iterator<E> {    
514.         // 下一个元素    
515.         Entry<K,V> next;    
516.         // expectedModCount用于实现fast-fail机制。    
517.         int expectedModCount;    
518.         // 当前索引    
519.         int index;    
520.         // 当前元素    
521.         Entry<K,V> current;    
522.    
523.         HashIterator() {    
524.             expectedModCount = modCount;    
525.             if (size > 0) { // advance to first entry    
526.                 Entry[] t = table;    
527.                 // 将next指向table中第一个不为null的元素。    
528.                 // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。    
529.                 while (index < t.length && (next = t[index++]) == null)    
530.                     ;    
531.             }    
532.         }    
533.    
534.         public final boolean hasNext() {    
535.             return next != null;    
536.         }    
537.    
538.         // 获取下一个元素    
539.         final Entry<K,V> nextEntry() {    
540.             if (modCount != expectedModCount)    
541.                 throw new ConcurrentModificationException();    
542.             Entry<K,V> e = next;    
543.             if (e == null)    
544.                 throw new NoSuchElementException();    
545.    
546.             // 注意！！！    
547.             // 一个Entry就是一个单向链表    
548.             // 若该Entry的下一个节点不为空，就将next指向下一个节点;    
549.             // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。    
550.             if ((next = e.next) == null) {    
551.                 Entry[] t = table;    
552.                 while (index < t.length && (next = t[index++]) == null)    
553.                     ;    
554.             }    
555.             current = e;    
556.             return e;    
557.         }    
558.    
559.         // 删除当前元素    
560.         public void remove() {    
561.             if (current == null)    
562.                 throw new IllegalStateException();    
563.             if (modCount != expectedModCount)    
564.                 throw new ConcurrentModificationException();    
565.             Object k = current.key;    
566.             current = null;    
567.             HashMap.this.removeEntryForKey(k);    
568.             expectedModCount = modCount;    
569.         }    
570.    
571.     }    
572.    
573.     // value的迭代器    
574.     private final class ValueIterator extends HashIterator<V> {    
575.         public V next() {    
576.             return nextEntry().value;    
577.         }    
578.     }    
579.    
580.     // key的迭代器    
581.     private final class KeyIterator extends HashIterator<K> {    
582.         public K next() {    
583.             return nextEntry().getKey();    
584.         }    
585.     }    
586.    
587.     // Entry的迭代器    
588.     private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {    
589.         public Map.Entry<K,V> next() {    
590.             return nextEntry();    
591.         }    
592.     }    
593.    
594.     // 返回一个“key迭代器”    
595.     Iterator<K> newKeyIterator()   {    
596.         return new KeyIterator();    
597.     }    
598.     // 返回一个“value迭代器”    
599.     Iterator<V> newValueIterator()   {    
600.         return new ValueIterator();    
601.     }    
602.     // 返回一个“entry迭代器”    
603.     Iterator<Map.Entry<K,V>> newEntryIterator()   {    
604.         return new EntryIterator();    
605.     }    
606.    
607.     // HashMap的Entry对应的集合    
608.     private transient Set<Map.Entry<K,V>> entrySet = null;    
609.    
610.     // 返回“key的集合”，实际上返回一个“KeySet对象”    
611.     public Set<K> keySet() {    
612.         Set<K> ks = keySet;    
613.         return (ks != null ? ks : (keySet = new KeySet()));    
614.     }    
615.    
616.     // Key对应的集合    
617.     // KeySet继承于AbstractSet，说明该集合中没有重复的Key。    
618.     private final class KeySet extends AbstractSet<K> {    
619.         public Iterator<K> iterator() {    
620.             return newKeyIterator();    
621.         }    
622.         public int size() {    
623.             return size;    
624.         }    
625.         public boolean contains(Object o) {    
626.             return containsKey(o);    
627.         }    
628.         public boolean remove(Object o) {    
629.             return HashMap.this.removeEntryForKey(o) != null;    
630.         }    
631.         public void clear() {    
632.             HashMap.this.clear();    
633.         }    
634.     }    
635.    
636.     // 返回“value集合”，实际上返回的是一个Values对象    
637.     public Collection<V> values() {    
638.         Collection<V> vs = values;    
639.         return (vs != null ? vs : (values = new Values()));    
640.     }    
641.    
642.     // “value集合”    
643.     // Values继承于AbstractCollection，不同于“KeySet继承于AbstractSet”，    
644.     // Values中的元素能够重复。因为不同的key可以指向相同的value。    
645.     private final class Values extends AbstractCollection<V> {    
646.         public Iterator<V> iterator() {    
647.             return newValueIterator();    
648.         }    
649.         public int size() {    
650.             return size;    
651.         }    
652.         public boolean contains(Object o) {    
653.             return containsValue(o);    
654.         }    
655.         public void clear() {    
656.             HashMap.this.clear();    
657.         }    
658.     }    
659.    
660.     // 返回“HashMap的Entry集合”    
661.     public Set<Map.Entry<K,V>> entrySet() {    
662.         return entrySet0();    
663.     }    
664.    
665.     // 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象    
666.     private Set<Map.Entry<K,V>> entrySet0() {    
667.         Set<Map.Entry<K,V>> es = entrySet;    
668.         return es != null ? es : (entrySet = new EntrySet());    
669.     }    
670.    
671.     // EntrySet对应的集合    
672.     // EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。    
673.     private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {    
674.         public Iterator<Map.Entry<K,V>> iterator() {    
675.             return newEntryIterator();    
676.         }    
677.         public boolean contains(Object o) {    
678.             if (!(o instanceof Map.Entry))    
679.                 return false;    
680.             Map.Entry<K,V> e = (Map.Entry<K,V>) o;    
681.             Entry<K,V> candidate = getEntry(e.getKey());    
682.             return candidate != null && candidate.equals(e);    
683.         }    
684.         public boolean remove(Object o) {    
685.             return removeMapping(o) != null;    
686.         }    
687.         public int size() {    
688.             return size;    
689.         }    
690.         public void clear() {    
691.             HashMap.this.clear();    
692.         }    
693.     }    
694.    
695.     // java.io.Serializable的写入函数    
696.     // 将HashMap的“总的容量，实际容量，所有的Entry”都写入到输出流中    
697.     private void writeObject(java.io.ObjectOutputStream s)    
698.         throws IOException    
699.     {    
700.         Iterator<Map.Entry<K,V>> i =    
701.             (size > 0) ? entrySet0().iterator() : null;    
702.    
703.         // Write out the threshold, loadfactor, and any hidden stuff    
704.         s.defaultWriteObject();    
705.    
706.         // Write out number of buckets    
707.         s.writeInt(table.length);    
708.    
709.         // Write out size (number of Mappings)    
710.         s.writeInt(size);    
711.    
712.         // Write out keys and values (alternating)    
713.         if (i != null) {    
714.             while (i.hasNext()) {    
715.             Map.Entry<K,V> e = i.next();    
716.             s.writeObject(e.getKey());    
717.             s.writeObject(e.getValue());    
718.             }    
719.         }    
720.     }    
721.    
722.    
723.     private static final long serialVersionUID = 362498820763181265L;    
724.    
725.     // java.io.Serializable的读取函数：根据写入方式读出    
726.     // 将HashMap的“总的容量，实际容量，所有的Entry”依次读出    
727.     private void readObject(java.io.ObjectInputStream s)    
728.          throws IOException, ClassNotFoundException    
729.     {    
730.         // Read in the threshold, loadfactor, and any hidden stuff    
731.         s.defaultReadObject();    
732.    
733.         // Read in number of buckets and allocate the bucket array;    
734.         int numBuckets = s.readInt();    
735.         table = new Entry[numBuckets];    
736.    
737.         init();  // Give subclass a chance to do its thing.    
738.    
739.         // Read in size (number of Mappings)    
740.         int size = s.readInt();    
741.    
742.         // Read the keys and values, and put the mappings in the HashMap    
743.         for (int i=0; i<size; i++) {    
744.             K key = (K) s.readObject();    
745.             V value = (V) s.readObject();    
746.             putForCreate(key, value);    
747.         }    
748.     }    
749.    
750.     // 返回“HashMap总的容量”    
751.     int   capacity()     { return table.length; }    
752.     // 返回“HashMap的加载因子”    
753.     float loadFactor()   { return loadFactor;   }    
754. }   

几点总结

    1、首先要清楚HashMap的存储结构，如下图所示：

    图中，紫色部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。

    2、首先看链表中节点的数据结构：

[java]  view plain  copy

 

1. // Entry是单向链表。    
2. // 它是 “HashMap链式存储法”对应的链表。    
3. // 它实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数    
4. static class Entry<K,V> implements Map.Entry<K,V> {    
5.     final K key;    
6.     V value;    
7.     // 指向下一个节点    
8.     Entry<K,V> next;    
9.     final int hash;    
10.   
11.     // 构造函数。    
12.     // 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"    
13.     Entry(int h, K k, V v, Entry<K,V> n) {    
14.         value = v;    
15.         next = n;    
16.         key = k;    
17.         hash = h;    
18.     }    
19.   
20.     public final K getKey() {    
21.         return key;    
22.     }    
23.   
24.     public final V getValue() {    
25.         return value;    
26.     }    
27.   
28.     public final V setValue(V newValue) {    
29.         V oldValue = value;    
30.         value = newValue;    
31.         return oldValue;    
32.     }    
33.   
34.     // 判断两个Entry是否相等    
35.     // 若两个Entry的“key”和“value”都相等，则返回true。    
36.     // 否则，返回false    
37.     public final boolean equals(Object o) {    
38.         if (!(o instanceof Map.Entry))    
39.             return false;    
40.         Map.Entry e = (Map.Entry)o;    
41.         Object k1 = getKey();    
42.         Object k2 = e.getKey();    
43.         if (k1 == k2 || (k1 != null && k1.equals(k2))) {    
44.             Object v1 = getValue();    
45.             Object v2 = e.getValue();    
46.             if (v1 == v2 || (v1 != null && v1.equals(v2)))    
47.                 return true;    
48.         }    
49.         return false;    
50.     }    
51.   
52.     // 实现hashCode()    
53.     public final int hashCode() {    
54.         return (key==null   ? 0 : key.hashCode()) ^    
55.                (value==null ? 0 : value.hashCode());    
56.     }    
57.   
58.     public final String toString() {    
59.         return getKey() + "=" + getValue();    
60.     }    
61.   
62.     // 当向HashMap中添加元素时，绘调用recordAccess()。    
63.     // 这里不做任何处理    
64.     void recordAccess(HashMap<K,V> m) {    
65.     }    
66.   
67.     // 当从HashMap中删除元素时，绘调用recordRemoval()。    
68.     // 这里不做任何处理    
69.     void recordRemoval(HashMap<K,V> m) {    
70.     }    
71. }    

    它的结构元素除了key、value、hash外，还有next，next指向下一个节点。另外，这里覆写了equals和hashCode方法来保证键值对的独一无二。

    3、HashMap共有四个构造方法。构造方法中提到了两个很重要的参数：初始容量和加载因子。这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中槽的数量（即哈希数组的长度），初始容量是创建哈希表时的容量（从构造函数中可以看出，如果不指明，则默认为16），加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 resize 操作（即扩容）。

    下面说下加载因子，如果加载因子越大，对空间的利用更充分，但是查找效率会降低（链表长度会越来越长）；如果加载因子太小，那么表中的数据将过于稀疏（很多空间还没用，就开始扩容了），对空间造成严重浪费。如果我们在构造方法中不指定，则系统默认加载因子为0.75，这是一个比较理想的值，一般情况下我们是无需修改的。

    另外，无论我们指定的容量为多少，构造方法都会将实际容量设为不小于指定容量的2的次方的一个数，且最大值不能超过2的30次方

    4、HashMap中key和value都允许为null。

    5、要重点分析下HashMap中用的最多的两个方法put和get。先从比较简单的get方法着手，源码如下：

[java]  view plain  copy

 

1. // 获取key对应的value    
2. public V get(Object key) {    
3.     if (key == null)    
4.         return getForNullKey();    
5.     // 获取key的hash值    
6.     int hash = hash(key.hashCode());    
7.     // 在“该hash值对应的链表”上查找“键值等于key”的元素    
8.     for (Entry<K,V> e = table[indexFor(hash, table.length)];    
9.          e != null;    
10.          e = e.next) {    
11.         Object k;    
12. /判断key是否相同  
13.         if (e.hash == hash && ((k = e.key) == key || key.equals(k)))    
14.             return e.value;    
15.     }  
16. 没找到则返回null  
17.     return null;    
18. }    
19.   
20. // 获取“key为null”的元素的值    
21. // HashMap将“key为null”的元素存储在table[0]位置，但不一定是该链表的第一个位置！    
22. private V getForNullKey() {    
23.     for (Entry<K,V> e = table[0]; e != null; e = e.next) {    
24.         if (e.key == null)    
25.             return e.value;    
26.     }    
27.     return null;    
28. }    

    首先，如果key为null，则直接从哈希表的第一个位置table[0]对应的链表上查找。记住，key为null的键值对永远都放在以table[0]为头结点的链表中，当然不一定是存放在头结点table[0]中。

    如果key不为null，则先求的key的hash值，根据hash值找到在table中的索引，在该索引对应的单链表中查找是否有键值对的key与目标key相等，有就返回对应的value，没有则返回null。

    put方法稍微复杂些，代码如下：

[java]  view plain  copy

 

1.   // 将“key-value”添加到HashMap中    
2.   public V put(K key, V value) {    
3.       // 若“key为null”，则将该键值对添加到table[0]中。    
4.       if (key == null)    
5.           return putForNullKey(value);    
6.       // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。    
7.       int hash = hash(key.hashCode());    
8.       int i = indexFor(hash, table.length);    
9.       for (Entry<K,V> e = table[i]; e != null; e = e.next) {    
10.           Object k;    
11.           // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！    
12.           if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {    
13.               V oldValue = e.value;    
14.               e.value = value;    
15.               e.recordAccess(this);    
16.               return oldValue;    
17.           }    
18.       }    
19.   
20.       // 若“该key”对应的键值对不存在，则将“key-value”添加到table中    
21.       modCount++;  
22. //将key-value添加到table[i]处  
23.       addEntry(hash, key, value, i);    
24.       return null;    
25.   }   

    如果key为null，则将其添加到table[0]对应的链表中，putForNullKey的源码如下：

[java]  view plain  copy

 

1. // putForNullKey()的作用是将“key为null”键值对添加到table[0]位置    
2. private V putForNullKey(V value) {    
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.     // 如果没有存在key为null的键值对，则直接题阿见到table[0]处!    
12.     modCount++;    
13.     addEntry(0, null, value, 0);    
14.     return null;    
15. }   

    如果key不为null，则同样先求出key的hash值，根据hash值得出在table中的索引，而后遍历对应的单链表，如果单链表中存在与目标key相等的键值对，则将新的value覆盖旧的value，比将旧的value返回，如果找不到与目标key相等的键值对，或者该单链表为空，则将该键值对插入到改单链表的头结点位置（每次新插入的节点都是放在头结点的位置），该操作是有addEntry方法实现的，它的源码如下：

[java]  view plain  copy

 

1. // 新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。    
2. void addEntry(int hash, K key, V value, int bucketIndex) {    
3.     // 保存“bucketIndex”位置的值到“e”中    
4.     Entry<K,V> e = table[bucketIndex];    
5.     // 设置“bucketIndex”位置的元素为“新Entry”，    
6.     // 设置“e”为“新Entry的下一个节点”    
7.     table[bucketIndex] = new Entry<K,V>(hash, key, value, e);    
8.     // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小    
9.     if (size++ >= threshold)    
10.         resize(2 * table.length);    
11. }    

    注意这里倒数第三行的构造方法，将key-value键值对赋给table[bucketIndex]，并将其next指向元素e，这便将key-value放到了头结点中，并将之前的头结点接在了它的后面。该方法也说明，每次put键值对的时候，总是将新的该键值对放在table[bucketIndex]处（即头结点处）。

    两外注意最后两行代码，每次加入键值对时，都要判断当前已用的槽的数目是否大于等于阀值（容量*加载因子），如果大于等于，则进行扩容，将容量扩为原来容量的2倍。

    6、关于扩容。上面我们看到了扩容的方法，resize方法，它的源码如下：

[java]  view plain  copy

 

1. // 重新调整HashMap的大小，newCapacity是调整后的单位    
2. void resize(int newCapacity) {    
3.     Entry[] oldTable = table;    
4.     int oldCapacity = oldTable.length;    
5.     if (oldCapacity == MAXIMUM_CAPACITY) {    
6.         threshold = Integer.MAX_VALUE;    
7.         return;    
8.     }    
9.   
10.     // 新建一个HashMap，将“旧HashMap”的全部元素添加到“新HashMap”中，    
11.     // 然后，将“新HashMap”赋值给“旧HashMap”。    
12.     Entry[] newTable = new Entry[newCapacity];    
13.     transfer(newTable);    
14.     table = newTable;    
15.     threshold = (int)(newCapacity * loadFactor);    
16. }    

    很明显，是新建了一个HashMap的底层数组，而后调用transfer方法，将就HashMap的全部元素添加到新的HashMap中（要重新计算元素在新的数组中的索引位置）。transfer方法的源码如下：

[java]  view plain  copy

 

1. // 将HashMap中的全部元素都添加到newTable中    
2. void transfer(Entry[] newTable) {    
3.     Entry[] src = table;    
4.     int newCapacity = newTable.length;    
5.     for (int j = 0; j < src.length; j++) {    
6.         Entry<K,V> e = src[j];    
7.         if (e != null) {    
8.             src[j] = null;    
9.             do {    
10.                 Entry<K,V> next = e.next;    
11.                 int i = indexFor(e.hash, newCapacity);    
12.                 e.next = newTable[i];    
13.                 newTable[i] = e;    
14.                 e = next;    
15.             } while (e != null);    
16.         }    
17.     }    
18. }    

    很明显，扩容是一个相当耗时的操作，因为它需要重新计算这些元素在新的数组中的位置并进行复制处理。因此，我们在用HashMap的时，最好能提前预估下HashMap中元素的个数，这样有助于提高HashMap的性能。

    7、注意containsKey方法和containsValue方法。前者直接可以通过key的哈希值将搜索范围定位到指定索引对应的链表，而后者要对哈希数组的每个链表进行搜索。

    8、我们重点来分析下求hash值和索引值的方法，这两个方法便是HashMap设计的最为核心的部分，二者结合能保证哈希表中的元素尽可能均匀地散列。

    计算哈希值的方法如下：

[java]  view plain  copy

 

1. static int hash(int h) {  
2.         h ^= (h >>> 20) ^ (h >>> 12);  
3.         return h ^ (h >>> 7) ^ (h >>> 4);  
4.     }  

    它只是一个数学公式，IDK这样设计对hash值的计算，自然有它的好处，至于为什么这样设计，我们这里不去追究，只要明白一点，用的位的操作使hash值的计算效率很高。

    由hash值找到对应索引的方法如下：

[java]  view plain  copy

 

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

    这个我们要重点说下，我们一般对哈希表的散列很自然地会想到用hash值对length取模（即除法散列法），Hashtable中也是这样实现的，这种方法基本能保证元素在哈希表中散列的比较均匀，但取模会用到除法运算，效率很低，HashMap中则通过h&(length-1)的方法来代替取模，同样实现了均匀的散列，但效率要高很多，这也是HashMap对Hashtable的一个改进。

    接下来，我们分析下为什么哈希表的容量一定要是2的整数次幂。首先，length为2的整数次幂的话，h&(length-1)就相当于对length取模，这样便保证了散列的均匀，同时也提升了效率；其次，length为2的整数次幂的话，为偶数，这样length-1为奇数，奇数的最后一位是1，这样便保证了h&(length-1)的最后一位可能为0，也可能为1（这取决于h的值），即与后的结果可能为偶数，也可能为奇数，这样便可以保证散列的均匀性，而如果length为奇数的话，很明显length-1为偶数，它的最后一位是0，这样h&(length-1)的最后一位肯定为0，即只能为偶数，这样任何hash值都只会被散列到数组的偶数下标位置上，这便浪费了近一半的空间，因此，length取2的整数次幂，是为了使不同hash值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列。