Java 集合系列14之 Map總結(HashMap, Hashtable, TreeMap, WeakHashMap等使用場景)

時間 2019-11-11

標籤 java 集合系列 map 總結 hashmap hashtable treemap weakhashmap 使用場景欄目 Java 简体版

原文原文鏈接

概要

學完了Map的所有內容，咱們再回頭開開Map的框架圖。html

本章內容包括：
第1部分 Map歸納
 第2部分 HashMap和Hashtable異同
 第3部分 HashMap和WeakHashMap異同
java

轉載請註明出處：http://www.cnblogs.com/skywang12345/admin/EditPosts.aspx?postid=3311126算法

第1部分 Map歸納

(01) Map 是「鍵值對」映射的抽象接口。
(02) AbstractMap 實現了Map中的絕大部分函數接口。它減小了「Map的實現類」的重複編碼。
(03) SortedMap 有序的「鍵值對」映射接口。
(04) NavigableMap 是繼承於SortedMap的，支持導航函數的接口。
(05) HashMap, Hashtable, TreeMap, WeakHashMap這4個類是「鍵值對」映射的實現類。它們各有區別！數組

　　HashMap 是基於「拉鍊法」實現的散列表。通常用於單線程程序中。
　　Hashtable 也是基於「拉鍊法」實現的散列表。它通常用於多線程程序中。
　　WeakHashMap 也是基於「拉鍊法」實現的散列表，它通常也用於單線程程序中。相比HashMap，WeakHashMap中的鍵是「弱鍵」，當「弱鍵」被GC回收時，它對應的鍵值對也會被從WeakHashMap中刪除；而HashMap中的鍵是強鍵。
　　TreeMap 是有序的散列表，它是經過紅黑樹實現的。它通常用於單線程中存儲有序的映射。安全

第2部分 HashMap和Hashtable異同

第2.1部分 HashMap和Hashtable的相同點多線程

HashMap和Hashtable都是存儲「鍵值對(key-value)」的散列表，並且都是採用拉鍊法實現的。
存儲的思想都是：經過table數組存儲，數組的每個元素都是一個Entry；而一個Entry就是一個單向鏈表，Entry鏈表中的每個節點就保存了key-value鍵值對數據。框架

添加key-value鍵值對：首先，根據key值計算出哈希值，再計算出數組索引(即，該key-value在table中的索引)。而後，根據數組索引找到Entry(即，單向鏈表)，再遍歷單向鏈表，將key和鏈表中的每個節點的key進行對比。若key已經存在Entry鏈表中，則用該value值取代舊的value值；若key不存在Entry鏈表中，則新建一個key-value節點，並將該節點插入Entry鏈表的表頭位置。
刪除key-value鍵值對：刪除鍵值對，相比於「添加鍵值對」來講，簡單不少。首先，仍是根據key計算出哈希值，再計算出數組索引(即，該key-value在table中的索引)。而後，根據索引找出Entry(即，單向鏈表)。若節點key-value存在與鏈表Entry中，則刪除鏈表中的節點便可。ide

上面介紹了HashMap和Hashtable的相同點。正是因爲它們都是散列表，咱們關注更多的是「它們的區別，以及它們分別適合在什麼狀況下使用」。那接下來，咱們先看看它們的區別。函數

第2.2部分 HashMap和Hashtable的不一樣點oop

1 繼承和實現方式不一樣

HashMap 繼承於AbstractMap，實現了Map、Cloneable、java.io.Serializable接口。
Hashtable 繼承於Dictionary，實現了Map、Cloneable、java.io.Serializable接口。

HashMap的定義:

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable { ... }

Hashtable的定義:

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable { ... }

從中，咱們能夠看出：
1.1 HashMap和Hashtable都實現了Map、Cloneable、java.io.Serializable接口。
實現了Map接口，意味着它們都支持key-value鍵值對操做。支持「添加key-value鍵值對」、「獲取key」、「獲取value」、「獲取map大小」、「清空map」等基本的key-value鍵值對操做。
實現了Cloneable接口，意味着它能被克隆。
實現了java.io.Serializable接口，意味着它們支持序列化，能經過序列化去傳輸。

1.2 HashMap繼承於AbstractMap，而Hashtable繼承於Dictionary
Dictionary是一個抽象類，它直接繼承於Object類，沒有實現任何接口。Dictionary類是JDK 1.0的引入的。雖然Dictionary也支持「添加key-value鍵值對」、「獲取value」、「獲取大小」等基本操做，但它的API函數比Map少；並且 Dictionary通常是經過Enumeration(枚舉類)去遍歷，Map則是經過Iterator(迭代器)去遍歷。然而‘因爲Hashtable也實現了Map接口，因此，它即支持Enumeration遍歷，也支持Iterator遍歷。關於這點，後面還會進一步說明。
AbstractMap是一個抽象類，它實現了Map接口的絕大部分API函數；爲Map的具體實現類提供了極大的便利。它是JDK 1.2新增的類。

2 線程安全不一樣

Hashtable的幾乎全部函數都是同步的，即它是線程安全的，支持多線程。
而HashMap的函數則是非同步的，它不是線程安全的。若要在多線程中使用HashMap，須要咱們額外的進行同步處理。對HashMap的同步處理可使用Collections類提供的synchronizedMap靜態方法，或者直接使用JDK 5.0以後提供的java.util.concurrent包裏的ConcurrentHashMap類。

3 對null值的處理不一樣

HashMap的key、value均可覺得null。
Hashtable的key、value都不能夠爲null。

咱們先看看HashMap和Hashtable 「添加key-value」的方法

HashMap的添加key-value的方法

 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     addEntry(hash, key, value, i);
23     return null;
24 }
25 
26 // putForNullKey()的做用是將「key爲null」鍵值對添加到table[0]位置
27 private V putForNullKey(V value) {
28     for (Entry<K,V> e = table[0]; e != null; e = e.next) {
29         if (e.key == null) {
30             V oldValue = e.value;
31             e.value = value;
32             // recordAccess()函數什麼也沒有作
33             e.recordAccess(this);
34             return oldValue;
35         }
36     }
37     // 添加第1個「key爲null」的元素都table中的時候，會執行到這裏。
38     // 它的做用是將「設置table[0]的key爲null，值爲value」。
39     modCount++;
40     addEntry(0, null, value, 0);
41     return null;
42 }

View Code

Hashtable的添加key-value的方法

 1 // 將「key-value」添加到Hashtable中
 2 public synchronized V put(K key, V value) {
 3     // Hashtable中不能插入value爲null的元素！！！
 4     if (value == null) {
 5         throw new NullPointerException();
 6     }
 7 
 8     // 若「Hashtable中已存在鍵爲key的鍵值對」，
 9     // 則用「新的value」替換「舊的value」
10     Entry tab[] = table;
11     // Hashtable中不能插入key爲null的元素！！！
12     // 不然，下面的語句會拋出異常！
13     int hash = key.hashCode();
14     int index = (hash & 0x7FFFFFFF) % tab.length;
15     for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
16         if ((e.hash == hash) && e.key.equals(key)) {
17             V old = e.value;
18             e.value = value;
19             return old;
20         }
21     }
22 
23     // 若「Hashtable中不存在鍵爲key的鍵值對」，
24     // (01) 將「修改統計數」+1
25     modCount++;
26     // (02) 若「Hashtable實際容量」 > 「閾值」(閾值=總的容量 * 加載因子)
27     //  則調整Hashtable的大小
28     if (count >= threshold) {
29         // Rehash the table if the threshold is exceeded
30         rehash();
31 
32         tab = table;
33         index = (hash & 0x7FFFFFFF) % tab.length;
34     }
35 
36     // (03) 將「Hashtable中index」位置的Entry(鏈表)保存到e中 Entry<K,V> e = tab[index];
37     // (04) 建立「新的Entry節點」，並將「新的Entry」插入「Hashtable的index位置」，並設置e爲「新的Entry」的下一個元素(即「新Entry」爲鏈表表頭)。        
38     tab[index] = new Entry<K,V>(hash, key, value, e);
39     // (05) 將「Hashtable的實際容量」+1
40     count++;
41     return null;
42 }

View Code

根據上面的代碼，咱們能夠看出：

Hashtable的key或value，都不能爲null！不然，會拋出異常NullPointerException。
HashMap的key、value均可覺得null。 當HashMap的key爲null時，HashMap會將其固定的插入table[0]位置(即HashMap散列表的第一個位置)；並且table[0]處只會容納一個key爲null的值，當有多個key爲null的值插入的時候，table[0]會保留最後插入的value。

4 支持的遍歷種類不一樣

HashMap只支持Iterator(迭代器)遍歷。
而Hashtable支持Iterator(迭代器)和Enumeration(枚舉器)兩種方式遍歷。

Enumeration 是JDK 1.0添加的接口，只有hasMoreElements(), nextElement() 兩個API接口，不能經過Enumeration()對元素進行修改。
而Iterator 是JDK 1.2才添加的接口，支持hasNext(), next(), remove() 三個API接口。HashMap也是JDK 1.2版本才添加的，因此用Iterator取代Enumeration，HashMap只支持Iterator遍歷。

5 經過Iterator迭代器遍歷時，遍歷的順序不一樣

HashMap是「從前向後」的遍歷數組；再對數組具體某一項對應的鏈表，從表頭開始進行遍歷。
Hashtabl是「從後往前」的遍歷數組；再對數組具體某一項對應的鏈表，從表頭開始進行遍歷。

HashMap和Hashtable都實現Map接口，因此支持獲取它們「key的集合」、「value的集合」、「key-value的集合」，而後經過Iterator對這些集合進行遍歷。
因爲「key的集合」、「value的集合」、「key-value的集合」的遍歷原理都是同樣的；下面，我以遍歷「key-value的集合」來進行說明。

HashMap 和Hashtable 遍歷"key-value集合"的方式是：(01) 經過entrySet()獲取「Map.Entry集合」。 (02) 經過iterator()獲取「Map.Entry集合」的迭代器，再進行遍歷。

HashMap的實現方式：先「從前向後」的遍歷數組；對數組具體某一項對應的鏈表，則從表頭開始日後遍歷。

 1 // 返回「HashMap的Entry集合」
 2 public Set<Map.Entry<K,V>> entrySet() {
 3     return entrySet0();
 4 }
 5 // 返回「HashMap的Entry集合」，它實際是返回一個EntrySet對象
 6 private Set<Map.Entry<K,V>> entrySet0() {
 7     Set<Map.Entry<K,V>> es = entrySet;
 8     return es != null ? es : (entrySet = new EntrySet());
 9 }
10 // EntrySet對應的集合
11 // EntrySet繼承於AbstractSet，說明該集合中沒有重複的EntrySet。
12 private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
13     ...
14     public Iterator<Map.Entry<K,V>> iterator() {
15         return newEntryIterator();
16     }
17     ...
18 }
19 // 返回一個「entry迭代器」
20 Iterator<Map.Entry<K,V>> newEntryIterator()   {
21     return new EntryIterator();
22 }
23 // Entry的迭代器
24 private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
25     public Map.Entry<K,V> next() {
26         return nextEntry();
27     }
28 }
29 private abstract class HashIterator<E> implements Iterator<E> {
30     // 下一個元素
31     Entry<K,V> next;
32     // expectedModCount用於實現fail-fast機制。
33     int expectedModCount;
34     // 當前索引
35     int index;
36     // 當前元素
37     Entry<K,V> current;
38 
39     HashIterator() {
40         expectedModCount = modCount;
41         if (size > 0) { // advance to first entry
42             Entry[] t = table;
43             // 將next指向table中第一個不爲null的元素。
44             // 這裏利用了index的初始值爲0，從0開始依次向後遍歷，直到找到不爲null的元素就退出循環。
45             while (index < t.length && (next = t[index++]) == null)
46                 ;
47         }
48     }
49 
50     public final boolean hasNext() {
51         return next != null;
52     }
53 
54     // 獲取下一個元素
55     final Entry<K,V> nextEntry() {
56         if (modCount != expectedModCount)
57             throw new ConcurrentModificationException();
58         Entry<K,V> e = next;
59         if (e == null)
60             throw new NoSuchElementException();
61 
62         // 注意！！！
63         // 一個Entry就是一個單向鏈表
64         // 若該Entry的下一個節點不爲空，就將next指向下一個節點;
65         // 不然，將next指向下一個鏈表(也是下一個Entry)的不爲null的節點。
66         if ((next = e.next) == null) {
67             Entry[] t = table;
68             while (index < t.length && (next = t[index++]) == null)
69                 ;
70         }
71         current = e;
72         return e;
73     }
74 
75     ...
76 }

View Code

Hashtable的實現方式：先從「後向往前」的遍歷數組；對數組具體某一項對應的鏈表，則從表頭開始日後遍歷。

 1 public Set<Map.Entry<K,V>> entrySet() {
 2     if (entrySet==null)
 3         entrySet = Collections.synchronizedSet(new EntrySet(), this);
 4     return entrySet;
 5 }
 6 
 7 private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
 8     public Iterator<Map.Entry<K,V>> iterator() {
 9         return getIterator(ENTRIES);
10     }
11     ...
12 }
13 
14 private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
15     // 指向Hashtable的table
16     Entry[] table = Hashtable.this.table;
17     // Hashtable的總的大小
18     int index = table.length;
19     Entry<K,V> entry = null;
20     Entry<K,V> lastReturned = null;
21     int type;
22 
23     // Enumerator是 「迭代器(Iterator)」 仍是 「枚舉類(Enumeration)」的標誌
24     // iterator爲true，表示它是迭代器；不然，是枚舉類。
25     boolean iterator;
26 
27     // 在將Enumerator看成迭代器使用時會用到，用來實現fail-fast機制。
28     protected int expectedModCount = modCount;
29 
30     Enumerator(int type, boolean iterator) {
31         this.type = type;
32         this.iterator = iterator;
33     }
34 
35     // 從遍歷table的數組的末尾向前查找，直到找到不爲null的Entry。
36     public boolean hasMoreElements() {
37         Entry<K,V> e = entry;
38         int i = index;
39         Entry[] t = table;
40         /* Use locals for faster loop iteration */
41         while (e == null && i > 0) {
42             e = t[--i];
43         }
44         entry = e;
45         index = i;
46         return e != null;
47     }
48 
49     // 獲取下一個元素
50     // 注意：從hasMoreElements() 和nextElement() 能夠看出「Hashtable的elements()遍歷方式」
51     // 首先，從後向前的遍歷table數組。table數組的每一個節點都是一個單向鏈表(Entry)。
52     // 而後，依次向後遍歷單向鏈表Entry。
53     public T nextElement() {
54         Entry<K,V> et = entry;
55         int i = index;
56         Entry[] t = table;
57         /* Use locals for faster loop iteration */
58         while (et == null && i > 0) {
59             et = t[--i];
60         }
61         entry = et;
62         index = i;
63         if (et != null) {
64             Entry<K,V> e = lastReturned = entry;
65             entry = e.next;
66             return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
67         }
68         throw new NoSuchElementException("Hashtable Enumerator");
69     }
70 
71     // 迭代器Iterator的判斷是否存在下一個元素
72     // 實際上，它是調用的hasMoreElements()
73     public boolean hasNext() {
74         return hasMoreElements();
75     }
76 
77     // 迭代器獲取下一個元素
78     // 實際上，它是調用的nextElement()
79     public T next() {
80         if (modCount != expectedModCount)
81             throw new ConcurrentModificationException();
82         return nextElement();
83     }
84 
85     ...
86 
87 }

View Code

6 容量的初始值和增長方式都不同

HashMap默認的容量大小是16；增長容量時，每次將容量變爲「原始容量x2」。
Hashtable默認的容量大小是11；增長容量時，每次將容量變爲「原始容量x2 + 1」。

HashMap默認的「加載因子」是0.75, 默認的容量大小是16。

 1 // 默認的初始容量是16，必須是2的冪。
 2 static final int DEFAULT_INITIAL_CAPACITY = 16;
 3 
 4 // 默認加載因子
 5 static final float DEFAULT_LOAD_FACTOR = 0.75f;
 6 
 7 // 指定「容量大小」的構造函數
 8 public HashMap(int initialCapacity) {
 9     this(initialCapacity, DEFAULT_LOAD_FACTOR);
10 }

View Code

當HashMap的「實際容量」 >= 「閾值」時，(閾值 = 總的容量 * 加載因子)，就將HashMap的容量翻倍。

 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 }

View Code

Hashtable默認的「加載因子」是0.75, 默認的容量大小是11。

1 // 默認構造函數。
2 public Hashtable() {
3     // 默認構造函數，指定的容量大小是11；加載因子是0.75
4     this(11, 0.75f);
5 }

View Code

當Hashtable的「實際容量」 >= 「閾值」時，(閾值 = 總的容量 x 加載因子)，就將變爲「原始容量x2 + 1」。

 1 // 調整Hashtable的長度，將長度變成原來的(2倍+1)
 2 // (01) 將「舊的Entry數組」賦值給一個臨時變量。
 3 // (02) 建立一個「新的Entry數組」，並賦值給「舊的Entry數組」
 4 // (03) 將「Hashtable」中的所有元素依次添加到「新的Entry數組」中
 5 protected void rehash() {
 6     int oldCapacity = table.length;
 7     Entry[] oldMap = table;
 8 
 9     int newCapacity = oldCapacity * 2 + 1;
10     Entry[] newMap = new Entry[newCapacity];
11 
12     modCount++;
13     threshold = (int)(newCapacity * loadFactor);
14     table = newMap;
15 
16     for (int i = oldCapacity ; i-- > 0 ;) {
17         for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
18             Entry<K,V> e = old;
19             old = old.next;
20 
21             int index = (e.hash & 0x7FFFFFFF) % newCapacity;
22             e.next = newMap[index];
23             newMap[index] = e;
24         }
25     }
26 }

View Code

7 添加key-value時的hash值算法不一樣

HashMap添加元素時，是使用自定義的哈希算法。
Hashtable沒有自定義哈希算法，而直接採用的key的hashCode()。

HashMap添加元素時，是使用自定義的哈希算法。

 1 static int hash(int h) {
 2     h ^= (h >>> 20) ^ (h >>> 12);
 3     return h ^ (h >>> 7) ^ (h >>> 4);
 4 }
 5 
 6 // 將「key-value」添加到HashMap中
 7 public V put(K key, V value) {
 8     // 若「key爲null」，則將該鍵值對添加到table[0]中。
 9     if (key == null)
10         return putForNullKey(value);
11     // 若「key不爲null」，則計算該key的哈希值，而後將其添加到該哈希值對應的鏈表中。
12     int hash = hash(key.hashCode());
13     int i = indexFor(hash, table.length);
14     for (Entry<K,V> e = table[i]; e != null; e = e.next) {
15         Object k;
16         // 若「該key」對應的鍵值對已經存在，則用新的value取代舊的value。而後退出！
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 
25     // 若「該key」對應的鍵值對不存在，則將「key-value」添加到table中
26     modCount++;
27     addEntry(hash, key, value, i);
28     return null;
29 }

View Code

Hashtable沒有自定義哈希算法，而直接採用的key的hashCode()。

 1 public synchronized V put(K key, V value) {
 2     // Hashtable中不能插入value爲null的元素！！！
 3     if (value == null) {
 4         throw new NullPointerException();
 5     }
 6 
 7     // 若「Hashtable中已存在鍵爲key的鍵值對」，
 8     // 則用「新的value」替換「舊的value」
 9     Entry tab[] = table;
10     int hash = key.hashCode();
11     int index = (hash & 0x7FFFFFFF) % tab.length;
12     for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
13         if ((e.hash == hash) && e.key.equals(key)) {
14             V old = e.value;
15             e.value = value;
16             return old;
17             }
18     }
19 
20     // 若「Hashtable中不存在鍵爲key的鍵值對」，
21     // (01) 將「修改統計數」+1
22     modCount++;
23     // (02) 若「Hashtable實際容量」 > 「閾值」(閾值=總的容量 * 加載因子)
24     //  則調整Hashtable的大小
25     if (count >= threshold) {
26         // Rehash the table if the threshold is exceeded
27         rehash();
28 
29         tab = table;
30         index = (hash & 0x7FFFFFFF) % tab.length;
31     }
32 
33     // (03) 將「Hashtable中index」位置的Entry(鏈表)保存到e中
34     Entry<K,V> e = tab[index];
35     // (04) 建立「新的Entry節點」，並將「新的Entry」插入「Hashtable的index位置」，並設置e爲「新的Entry」的下一個元素(即「新Entry」爲鏈表表頭)。        
36     tab[index] = new Entry<K,V>(hash, key, value, e);
37     // (05) 將「Hashtable的實際容量」+1
38     count++;
39     return null;
40 }

View Code

8 部分API不一樣

Hashtable支持contains(Object value)方法，並且重寫了toString()方法；
而HashMap不支持contains(Object value)方法，沒有重寫toString()方法。

最後，再說說「HashMap和Hashtable」使用的情景。
其實，若瞭解它們之間的不一樣之處後，能夠很容易的區分根據狀況進行取捨。例如：(01) 若在單線程中，咱們每每會選擇HashMap；而在多線程中，則會選擇Hashtable。(02)，若不能插入null元素，則選擇Hashtable；不然，能夠選擇HashMap。
但這個不是絕對的標準。例如，在多線程中，咱們能夠本身對HashMap進行同步，也能夠選擇ConcurrentHashMap。當HashMap和Hashtable都不能知足本身的需求時，還能夠考慮新定義一個類，繼承或從新實現散列表；固然，通常狀況下是不須要的了。

第3部分 HashMap和WeakHashMap異同

3.1 HashMap和WeakHashMap的相同點

1 它們都是散列表，存儲的是「鍵值對」映射。
2 它們都繼承於AbstractMap，而且實現Map基礎。
3 它們的構造函數都同樣。
它們都包括4個構造函數，並且函數的參數都同樣。
4 默認的容量大小是16，默認的加載因子是0.75。
5 它們的「鍵」和「值」都容許爲null。
6 它們都是「非同步的」。

3.2 HashMap和WeakHashMap的不一樣點

1 HashMap實現了Cloneable和Serializable接口，而WeakHashMap沒有。
HashMap實現Cloneable，意味着它能經過clone()克隆本身。
HashMap實現Serializable，意味着它支持序列化，能經過序列化去傳輸。

2 HashMap的「鍵」是「強引用(StrongReference)」，而WeakHashMap的鍵是「弱引用(WeakReference)」。
WeakReference的「弱鍵」能實現WeakReference對「鍵值對」的動態回收。當「弱鍵」再也不被使用到時，GC會回收它，WeakReference也會將「弱鍵」對應的鍵值對刪除。
這個「弱鍵」實現的動態回收「鍵值對」的原理呢？其實，經過WeakReference(弱引用)和ReferenceQueue(引用隊列)實現的。首先，咱們須要瞭解WeakHashMap中：
第一，「鍵」是WeakReference，即key是弱鍵。
第二，ReferenceQueue是一個引用隊列，它是和WeakHashMap聯合使用的。當弱引用所引用的對象被垃圾回收，Java虛擬機就會把這個弱引用加入到與之關聯的引用隊列中。 WeakHashMap中的ReferenceQueue是queue。
第三，WeakHashMap是經過數組實現的，咱們假設這個數組是table。

接下來，說說「動態回收」的步驟。

(01) 新建WeakHashMap，將「鍵值對」添加到WeakHashMap中。
將「鍵值對」添加到WeakHashMap中時，添加的鍵都是弱鍵。
實際上，WeakHashMap是經過數組table保存Entry(鍵值對)；每個Entry其實是一個單向鏈表，即Entry是鍵值對鏈表。
(02) 當某「弱鍵」再也不被其它對象引用，並被GC回收時。在GC回收該「弱鍵」時，這個「弱鍵」也同時會被添加到queue隊列中。
例如，當咱們在將「弱鍵」key添加到WeakHashMap以後；後來將key設爲null。這時，便沒有外部外部對象再引用該了key。
接着，當Java虛擬機的GC回收內存時，會回收key的相關內存；同時，將key添加到queue隊列中。
(03) 當下一次咱們須要操做WeakHashMap時，會先同步table和queue。table中保存了所有的鍵值對，而queue中保存被GC回收的「弱鍵」；同步它們，就是刪除table中被GC回收的「弱鍵」對應的鍵值對。
例如，當咱們「讀取WeakHashMap中的元素或獲取WeakReference的大小時」，它會先同步table和queue，目的是「刪除table中被GC回收的‘弱鍵’對應的鍵值對」。刪除的方法就是逐個比較「table中元素的‘鍵’和queue中的‘鍵’」，若它們至關，則刪除「table中的該鍵值對」。

3.3 HashMap和WeakHashMap的比較測試程序

  1 import java.util.HashMap;
  2 import java.util.Iterator;
  3 import java.util.Map;
  4 import java.util.WeakHashMap;
  5 import java.util.Date;
  6 import java.lang.ref.WeakReference;
  7 
  8 /**
  9  * @desc HashMap 和 WeakHashMap比較程序
 10  *
 11  * @author skywang
 12  * @email kuiwu-wang@163.com
 13  */
 14 public class CompareHashmapAndWeakhashmap {
 15 
 16     public static void main(String[] args) throws Exception {
 17 
 18         // 當「弱鍵」是String時，比較HashMap和WeakHashMap
 19         compareWithString();
 20         // 當「弱鍵」是自定義類型時，比較HashMap和WeakHashMap
 21         compareWithSelfClass();
 22     }
 23 
 24     /**
 25      * 遍歷map，並打印map的大小
 26      */
 27     private static void iteratorAndCountMap(Map map) {
 28         // 遍歷map
 29         for (Iterator iter = map.entrySet().iterator();
 30                 iter.hasNext();  ) {
 31             Map.Entry en = (Map.Entry)iter.next();
 32             System.out.printf("map entry : %s - %s\n ",en.getKey(), en.getValue());
 33         }
 34 
 35         // 打印HashMap的實際大小
 36         System.out.printf(" map size:%s\n\n", map.size());
 37     }
 38 
 39     /**
 40      * 經過String對象測試HashMap和WeakHashMap
 41      */
 42     private static void compareWithString() {
 43         // 新建4個String字符串
 44         String w1 = new String("W1");
 45         String w2 = new String("W2");
 46         String h1 = new String("H1");
 47         String h2 = new String("H2");
 48 
 49         // 新建 WeakHashMap對象，並將w1,w2添加到 WeakHashMap中
 50         Map wmap = new WeakHashMap();
 51         wmap.put(w1, "w1");
 52         wmap.put(w2, "w2");
 53 
 54         // 新建 HashMap對象，並將h1,h2添加到 WeakHashMap中
 55         Map hmap = new HashMap();
 56         hmap.put(h1, "h1");
 57         hmap.put(h2, "h2");
 58 
 59         // 刪除HashMap中的「h1」。
 60         // 結果：刪除「h1」以後，HashMap中只有 h2 ！
 61         hmap.remove(h1);
 62 
 63         // 將WeakHashMap中的w1設置null，並執行gc()。系統會回收w1
 64         // 結果：w1是「弱鍵」，被GC回收後，WeakHashMap中w1對應的鍵值對，也會被從WeakHashMap中刪除。
 65         //       w2是「弱鍵」，但它不是null，不會被GC回收；也就不會被從WeakHashMap中刪除。
 66         // 所以，WeakHashMap中只有 w2
 67         // 注意：若去掉「w1=null」 或者「System.gc()」，結果都會不同！
 68         w1 = null;
 69         System.gc();
 70 
 71         // 遍歷並打印HashMap的大小
 72         System.out.printf(" -- HashMap --\n");
 73         iteratorAndCountMap(hmap);
 74 
 75         // 遍歷並打印WeakHashMap的大小
 76         System.out.printf(" -- WeakHashMap --\n");
 77         iteratorAndCountMap(wmap);
 78     }
 79 
 80     /**
 81      * 經過自定義類測試HashMap和WeakHashMap
 82      */
 83     private static void compareWithSelfClass() {
 84         // 新建4個自定義對象
 85         Self s1 = new Self(10);
 86         Self s2 = new Self(20);
 87         Self s3 = new Self(30);
 88         Self s4 = new Self(40);
 89         
 90         // 新建 WeakHashMap對象，並將s1,s2添加到 WeakHashMap中
 91         Map wmap = new WeakHashMap();
 92         wmap.put(s1, "s1");
 93         wmap.put(s2, "s2");
 94         
 95         // 新建 HashMap對象，並將s3,s4添加到 WeakHashMap中
 96         Map hmap = new HashMap();
 97         hmap.put(s3, "s3");
 98         hmap.put(s4, "s4");
 99 
100         // 刪除HashMap中的s3。
101         // 結果：刪除s3以後，HashMap中只有 s4 ！
102         hmap.remove(s3);
103 
104         // 將WeakHashMap中的s1設置null，並執行gc()。系統會回收w1
105         // 結果：s1是「弱鍵」，被GC回收後，WeakHashMap中s1對應的鍵值對，也會被從WeakHashMap中刪除。
106         //       w2是「弱鍵」，但它不是null，不會被GC回收；也就不會被從WeakHashMap中刪除。
107         // 所以，WeakHashMap中只有 s2
108         // 注意：若去掉「s1=null」 或者「System.gc()」，結果都會不同！
109         s1 = null;
110         System.gc();
111 
112         /*
113         // 休眠500ms
114         try {
115             Thread.sleep(500);
116         } catch (InterruptedException e) {
117             e.printStackTrace();
118         }
119         // */
120         
121         // 遍歷並打印HashMap的大小
122         System.out.printf(" -- Self-def HashMap --\n");
123         iteratorAndCountMap(hmap);
124 
125         // 遍歷並打印WeakHashMap的大小
126         System.out.printf(" -- Self-def WeakHashMap --\n");
127         iteratorAndCountMap(wmap);
128     }
129 
130     private static class Self { 
131         int id;
132 
133         public Self(int id) {
134             this.id = id;
135         }
136 
137         // 覆蓋finalize()方法
138         // 在GC回收時會被執行
139         protected void finalize() throws Throwable {
140             super.finalize();
141             System.out.printf("GC Self: id=%d addr=0x%s)\n", id, this);
142         }   
143     }
144 }

View Code

運行結果：

 -- HashMap --
map entry : H2 - h2
  map size:1

 -- WeakHashMap --
map entry : W2 - w2
  map size:1

 -- Self-def HashMap --
map entry : CompareHashmapAndWeakhashmap$Self@1ff9dc36 - s4
  map size:1

 -- Self-def WeakHashMap --
GC Self: id=10 addr=0xCompareHashmapAndWeakhashmap$Self@12276af2)
map entry : CompareHashmapAndWeakhashmap$Self@59de3f2d - s2
  map size:1