zy19982004--容器学习一：HashMap源码分析

一.HashMap的存储结构

 

二.HashMap成员变量

Java代码  

1. //默认初始容量，总为2的次方值  
2. static final int DEFAULT_INITIAL_CAPACITY = 16;  
3.   
4. //最大容量  
5. static final int MAXIMUM_CAPACITY = 1 << 30;  
6.   
7. //默认加载因子    
8. static final float DEFAULT_LOAD_FACTOR = 0.75f;  
9.   
10. //Entry数组，每一个Entry是一个键值对实体  
11. transient Entry[] table;  
12.   
13. //实际存的Entry个数    
14. transient int size;  
15.   
16. //数组扩容的阀值，当size+1 > threshold时，扩充到以前容量的两倍  
17. //threshold = table.length * loadFactor  
18. int threshold;  
19.   
20. //负载比率  
21. final float loadFactor;  
22.   
23. //Map结构一旦变化，如put remove clear等操作的时候，modCount随之变化  
24. transient volatile int modCount;  

 

三.Entry对象

Java代码  

1. //很简单的一个键值对实体而已  
2. static class Entry<K,V> implements Map.Entry<K,V> {  
3.         final K key;          //key  
4.         V value;              //value  
5.         Entry<K,V> next;  //next Entry  
6.         final int hash;       //计算出key的hash值  
7.   
8.         /** 
9.          * Creates new entry. 
10.          */  
11.         Entry(int h, K k, V v, Entry<K,V> n) {  
12.             value = v;  
13.             next = n;  
14.             key = k;  
15.             hash = h;  
16.         }  
17.         .....  
18. }  

 

四.构造函数

Java代码  

1. // 构造函数  
2. public HashMap(int initialCapacity, float loadFactor) {  
3.     if (initialCapacity < 0)  
4.         throw new IllegalArgumentException("Illegal initial capacity: "  
5.                 + initialCapacity);  
6.     if (initialCapacity > MAXIMUM_CAPACITY)  
7.         initialCapacity = MAXIMUM_CAPACITY;  
8.     if (loadFactor <= 0 || Float.isNaN(loadFactor))  
9.         throw new IllegalArgumentException("Illegal load factor: "  
10.                 + loadFactor);  
11.   
12.     // 将传入的initialCapacity值，转变成2的次方值capacity去实例化hashmap的属性  
13.     // 比喻传入initialCapacity = 100，则算出来capacity = 2 << 7 = 128，  
14.     // 最终threshold = 128 * 0.75 = 96，table = new Entry[128]  
15.     int capacity = 1;  
16.     while (capacity < initialCapacity)  
17.         capacity <<= 1;  //左移，相当于capacity*2
18.   
19.     this.loadFactor = loadFactor;  
20.     threshold = (int) (capacity * loadFactor);  
21.     table = new Entry[capacity];  
22.     // 模板方法模式，子类想在init里面做点什么重写init就好了  
23.     init();  
24. }  

 

五.hash算法和index算法

（帮助理解hash算法：http://692088846.iteye.com/admin/blogs/2075638）

Java代码  

1. /** 
2.  * 让hashMap里面的元素尽量分布均需，方便查找 
3.  * @param h entry中key的hash值 
4.  * @return 打散后的hash值 
5.  */  
6. static int hash(int h) {  
7.     // This function ensures that hashCodes that differ only by  
8.     // constant multiples at each bit position have a bounded  
9.     // number of collisions (approximately 8 at default load factor).  
10.     h ^= (h >>> 20) ^ (h >>> 12);  
11.     return h ^ (h >>> 7) ^ (h >>> 4);  
12. }  
13.   
14. /**  
15.  * 类似求模运算， 将hash值同length-1(必定是01111...1)相与，运算的结果处于1到length-1间，0刚好用来保存key为null和0的元素  
16.  * @param h 打散后的hash值  
17.  * @param length 数组的长度  
18.  * @return 数组下标 1到lenght-1   
19.  */   
20. static int indexFor(int h, int length) {  
21.     return h & (length-1);  
22. }  

 

六.取数据  

Java代码  

1. public V get(Object key) {  
2.         if (key == null)  
3.             return getForNullKey();  
4.         //key != null时  
5.         //1.根据key计算出hash和index  
6.         int hash = hash(key.hashCode());  
7.         //2.从index处的链表头Entry e开始遍历链表，  
8.         //如果e满足hash(key.hashCode()) == e.hash && (key == e.key || key.equals(e.key))，就是我们要找的entry  
9.         for (Entry<K,V> e = table[indexFor(hash, table.length)];  
10.              e != null;  
11.              e = e.next) {  
12.             Object k;          
13.             if (e.hash == hash && ((k = e.key) == key || key.equals(k)))    //注释3里的逻辑更好理解  
14.                 return e.value;  
15.         }  
16.         return null;  
17.     }  
18.   
19.     //如果key为空，直接从table[0]链表里面遍历寻找value  
20.     private V getForNullKey() {  
21.         for (Entry<K,V> e = table[0]; e != null; e = e.next) {  
22.             if (e.key == null)  
23.                 return e.value;  
24.         }  
25.         return null;  
26.     }  

 

七.存数据，扩容

Java代码  

1. public V put(K key, V value) {  
2.         //1.key为空时候，调用putForNullKey方法  
3.         if (key == null)  
4.             return putForNullKey(value);  
5.         //2.key不为空  
6.         //2-1.计算hash和index  
7.         int hash = hash(key.hashCode());  
8.         int i = indexFor(hash, table.length);  
9.         //2-2.根据index得到当前链表头e=table[i]不为空  
10.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
11.             Object k;  
12.             //2-3.如果e满足hash(key.hashCode())=e.hash && key==e.key || key.equals(e.key)，value覆盖oldValue  
13.             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
14.                 V oldValue = e.value;  
15.                 e.value = value;  
16.                 e.recordAccess(this);  
17.                 return oldValue;  
18.             }  
19.         }  
20.         //2-4.table[i]为空，直接插入entry  
21.         modCount++;  
22.         addEntry(hash, key, value, i);  
23.         return null;  
24.     }  
25.   
26.     private V putForNullKey(V value) {  
27.         //1.从0位置的链表头开始，遍历  
28.         for (Entry<K,V> e = table[0]; e != null; e = e.next) {  
29.             //1-1.e.key==null时，直接替代value  
30.             if (e.key == null) {  
31.                 V oldValue = e.value;  
32.                 e.value = value;  
33.                 e.recordAccess(this);  
34.                 return oldValue;  
35.             }  
36.         }  
37.         //2.头Entry不存在时，直接插入entry  
38.         modCount++;  
39.         addEntry(0, null, value, 0);  
40.         return null;  
41.     }  
42.       
43.     /**  
44.      * @param hash 计算后key的hash值 
45.      * @param key  
46.      * @param value 
47.      * @param bucketIndex 应该插入到Entry[]的哪个位置 
48.      */  
49.     void addEntry(int hash, K key, V value, int bucketIndex) {  
50.         //1.当前bucketIndex位置的头Entry e  
51.         Entry<K,V> e = table[bucketIndex];  
52.         //2.在bucketIndex位置新建一个Entry，新建Entry.next=原头Entry，也就是addEntry的Entry都被加到了链表头  
53.         table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
54.         //hashmap在每次addEntry完后检查是否扩容，而list是在每次加入之前检查：ensureCapacity(size + 1);elementData[size++] = e;  
55.         if (size++ >= threshold)  
56.             resize(2 * table.length);  
57.     }  
58.       
59.     //扩容，把hashmap的容量设置为新容量newCapacity  
60.     void resize(int newCapacity) {  
61.         Entry[] oldTable = table;  
62.         int oldCapacity = oldTable.length;  
63.         //每次扩到到原来的两倍，总有一个时候到MAXIMUM_CAPACITY  
64.         if (oldCapacity == MAXIMUM_CAPACITY) {  
65.             //到了MAXIMUM_CAPACITY设置threshold后直接return  
66.             threshold = Integer.MAX_VALUE;  
67.             return;  
68.         }  
69.   
70.         //1.新建newCapacity大小的Entry数组  
71.         Entry[] newTable = new Entry[newCapacity];  
72.         //2.把当前Entry的数据全部移到新Entry数组中  
73.         transfer(newTable);  
74.         //3.用已经就绪的新Entry数组重新给table赋值  
75.         table = newTable;  
76.         //4.设置新的threshold  
77.         threshold = (int)(newCapacity * loadFactor);  
78.     }  
79.   
80.     void transfer(Entry[] newTable) {  
81.         Entry[] src = table;  
82.         int newCapacity = newTable.length;  
83.         //1.从0开始遍历原Entry数组  
84.         for (int j = 0; j < src.length; j++) {  
85.             //2.拿到下标为j的链表头Entry e  
86.             Entry<K,V> e = src[j];  
87.             //3.遍历链表  
88.             if (e != null) {  
89.                 src[j] = null;  
90.                 do {  
91.                     //3-1.e的下一个Entry，为了继续遍历做准备  
92.                     Entry<K,V> next = e.next;  
93.                     //3-2.计算e应该存放在新Entry数组的位置下标  
94.                     int i = indexFor(e.hash, newCapacity);  
95.                     //3-3.将e插入到新Entry[i]链表的表头  
96.                     e.next = newTable[i];  
97.                     //3-4.将Entry[i]表头的Entry重新定位为e，这样就完成了一个元素的重新hash   
98.                     newTable[i] = e;  
99.                     //3-5.继续链表的下一个Entry  
100.                     e = next;  
101.                 } while (e != null);  
102.             }  
103.         }  
104.     }  

 

八.删数据

 

Java代码  

1. public V remove(Object key) {  
2.         Entry<K, V> e = removeEntryForKey(key);  
3.         return (e == null ? null : e.value);  
4.     }  
5.   
6.     /** 
7.      * Removes and returns the entry associated with the specified key in the 
8.      * HashMap. Returns null if the HashMap contains no mapping for this key. 
9.      */  
10.     final Entry<K, V> removeEntryForKey(Object key) {  
11.         // 1.计算hash和index  
12.         int hash = (key == null) ? 0 : hash(key.hashCode());  
13.         int i = indexFor(hash, table.length);  
14.         Entry<K, V> prev = table[i];  
15.         Entry<K, V> e = prev;  
16.         // 2.遍历i位置的Entry链表  
17.         while (e != null) {  
18.             Entry<K, V> next = e.next;  
19.             Object k;  
20.             // 2-1.e满足hash(key.hashCode()) == e.hash && (key == e.key ||  
21.             // key.equals(e.key))，找到了要移除的Entry  
22.             if (e.hash == hash  
23.                     && ((k = e.key) == key || (key != null && key.equals(k)))) {  
24.                 // 2-2.移除操作modCount++, size--  
25.                 modCount++;  
26.                 size--;  
27.                 // 2-3-1.如果prev和e相等，说明要删除的Entry是链表头，直接将table[i]位置的Entry设置为next，就删除了e  
28.                 if (prev == e)  
29.                     table[i] = next;  
30.                 else  
31.                     // 2-3-2.如果不相等e =  
32.                     // prev.next，说明要删除的Entry是除链表头外的其他Entry，将prev.next设置为next，就删除了e  
33.                     prev.next = next;  
34.                 e.recordRemoval(this);  
35.                 return e;  
36.             }  
37.             // 把prev和e到移到下一个  
38.             prev = e;  
39.             e = next;  
40.         }  
41.   
42.         return e;  
43.     }  
44.   
45.     /** 
46.      * 还是将o的key拿到，然后和removeEntryForKey(Object key)一样了 
47.      *  
48.      * @param o 
49.      *            must be Map.Entry 
50.      * @return 
51.      */  
52.     final Entry<K, V> removeMapping(Object o) {  
53.         if (!(o instanceof Map.Entry))  
54.             return null;  
55.   
56.         Map.Entry<K, V> entry = (Map.Entry<K, V>) o;  
57.         Object key = entry.getKey();  
58.         ......  
59.     }  

 

九.对table[0]位置存放数据的理解

Java代码  

1. package com.zzy.collection2;  
2.   
3. import java.util.Map;  
4.   
5. public class TestHashMapEntry0 {  
6.     public static void main(String[] args) {  
7.         Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
8.         map.put(null, 1);  
9.         map.put(null, 2);  
10.           
11.         map.put(0, 3);  
12.         map.put(0, 4);  
13.     }  
14.   
15. }  

 

1. put(null, value)其本质是addEntry(0, null, value, 0);
2. put(0, value)其本质是addEntry(0, 0, value, 0);
3. put(null, value1)后put(0, value2)都是向table[0]链表中处添加Entry，但 0 != null，所有value2不会覆盖value1。
4. put(null, value1)后再次put(null, value2)，value2覆盖value1。