源码分析HashMap

源码分析HashMap

• 博客分类：
• 数据结构/算法

 

 

1、数据结构：数组+链表 

Java代码  

1. //成员变量，数组 table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
2.   transient Entry[] table;  
3.    
4.  //内部类，链表  
5.  static class Entry<K,V> implements Map.Entry<K,V> {  
6.         final K key;  
7.         V value;  
8.         //链表指向下个元素  
9.         Entry<K,V> next;  
10.         final int hash;  
11.   
12.         /** 
13.          * Creates new entry. 
14.          */  
15.         Entry(int h, K k, V v, Entry<K,V> n) {  
16.             value = v;  
17.             next = n;  
18.             key = k;  
19.             hash = h;  
20.         }  
21.   
22.         public final K getKey() {  
23.             return key;  
24.         }  
25.   
26.         public final V getValue() {  
27.             return value;  
28.         }  
29.   
30.         public final V setValue(V newValue) {  
31.         V oldValue = value;  
32.             value = newValue;  
33.             return oldValue;  
34.         }  
35.   
36.         public final boolean equals(Object o) {  
37.             if (!(o instanceof Map.Entry))  
38.                 return false;  
39.             Map.Entry e = (Map.Entry)o;  
40.             Object k1 = getKey();  
41.             Object k2 = e.getKey();  
42.             if (k1 == k2 || (k1 != null && k1.equals(k2))) {  
43.                 Object v1 = getValue();  
44.                 Object v2 = e.getValue();  
45.                 if (v1 == v2 || (v1 != null && v1.equals(v2)))  
46.                     return true;  
47.             }  
48.             return false;  
49.         }  
50.   
51.         public final int hashCode() {  
52.             return (key==null   ? 0 : key.hashCode()) ^  
53.                    (value==null ? 0 : value.hashCode());  
54.         }  
55.   
56.         public final String toString() {  
57.             return getKey() + "=" + getValue();  
58.         }  
59.   
60.         /** 
61.          * This method is invoked whenever the value in an entry is 
62.          * overwritten by an invocation of put(k,v) for a key k that's already 
63.          * in the HashMap. 
64.          */  
65.         void recordAccess(HashMap<K,V> m) {  
66.         }  
67.   
68.         /** 
69.          * This method is invoked whenever the entry is 
70.          * removed from the table. 
71.          */  
72.         void recordRemoval(HashMap<K,V> m) {  
73.         }  
74.     }  

 

2、put存值

Java代码  

1. public V put(K key, V value) {  
2.       if (key == null)  
3.           return putForNullKey(value);  
4.       //计算hash值  
5.       int hash = hash(key.hashCode());  
6.       //计算数组下标  
7.       int i = indexFor(hash, table.length);  
8.       for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
9.           Object k;  
10.           if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
11.               V oldValue = e.value;  
12.               e.value = value;  
13.               e.recordAccess(this);  
14.               return oldValue;  
15.           }  
16.       }  
17.   
18.       modCount++;  
19.       //添加元素  
20.       addEntry(hash, key, value, i);  
21.       return null;  
22.   }  
23.   //计算hash值  
24.   static int hash(int h) {  
25.       h ^= (h >>> 20) ^ (h >>> 12);  
26.       return h ^ (h >>> 7) ^ (h >>> 4);  
27.   }  
28.   //计算数组下标  
29.   static int indexFor(int h, int length) {  
30.       //保证结果的最大值是length-1，不会产生数组越界问题。  
31.       return h & (length-1);  
32.   }  
33. //向链表头部插入元素  
34. void addEntry(int hash, K key, V value, int bucketIndex) {  
35.             //获取table[i]的对象e  
36.         Entry<K,V> e = table[bucketIndex];  
37.         //将table[i]的对象修改为新增对象，让新增对象的next指向e。  
38.       table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
39.       if (size++ >= threshold)  
40.           resize(2 * table.length);  
41.  }          
42.  //超过阀值，生成新的Entry[]数组。  
43.   void resize(int newCapacity) {  
44.       Entry[] oldTable = table;  
45.       int oldCapacity = oldTable.length;  
46.       //最大容量：static final int MAXIMUM_CAPACITY = 1 << 30;  
47.       if (oldCapacity == MAXIMUM_CAPACITY) {  
48.           threshold = Integer.MAX_VALUE;  
49.           return;  
50.       }  
51.   
52.       Entry[] newTable = new Entry[newCapacity];  
53.       transfer(newTable);  
54.       //生成新的数组  
55.       table = newTable;  
56.       //阀值等于新的容量乘以加载因子（默认0.75）  
57.       threshold = (int)(newCapacity * loadFactor);  
58.   }          

 

 

 3、get取值

Java代码  

1. public V get(Object key) {  
2.   if (key == null)  
3.       return getForNullKey();  
4.   int hash = hash(key.hashCode());  
5.   for (Entry<K,V> e = table[indexFor(hash, table.length)];  
6.        e != null;  
7.        e = e.next) {  
8.       Object k;  
9.       //hash和key值都相等  
10.       if (e.hash == hash && ((k = e.key) == key || key.equals(k)))  
11.           return e.value;  
12.   }  
13.   return null;  

 

4、相关知识

        Hash，一般翻译做“散列”，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。

        java两个对象值相同(x.equals(y) == true)，则一定有相同的hash code。当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象equals必须具有相等的哈希码。hashCode相等对象未必相等。

        数组的特点是空间连续（大小固定）、寻址迅速，但是插入和删除时需要移动元素，所以查询快，增加删除慢。链表恰好相反，可动态增加或减少空间以适应新增和删除元素，但查找时只能顺着一个个节点查找，所以增加删除快，查找慢。哈希表综合2者优点，但实际上查找肯定没有数组快，插入删除没有链表快，一种折中的方式。