轉載地址：http://blog.csdn.net/wangxiaotongfan/article/details/51346167
學完了Map的全部內容，我們再回頭開開Map的框架圖。
![]()
本章內容包括：
第1部分 Map概括
第2部分 HashMap和Hashtable異同
第3部分 HashMap和WeakHashMap異同
(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.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中，則刪除鏈表中的節點即可。
上面介紹了HashMap和Hashtable的相同點。正是由於它們都是散列表，我們關注更多的是“它們的區別，以及它們分別適合在什麼情況下使用”。那接下來，我們先看看它們的區別。
|
第2.2部分 HashMap和Hashtable的不同點 |
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新增的類。
Hashtable的幾乎所有函數都是同步的，即它是線程安全的，支持多線程。
而HashMap的函數則是非同步的，它不是線程安全的。若要在多線程中使用HashMap，需要我們額外的進行同步處理。 對HashMap的同步處理可以使用Collections類提供的synchronizedMap靜態方法，或者直接使用JDK 5.0之後提供的java.util.concurrent包裏的ConcurrentHashMap類。
HashMap的key、value都可以爲null。
Hashtable的key、value都不可以爲null。
我們先看看HashMap和Hashtable “添加key-value”的方法
HashMap的添加key-value的方法
1
2 public V put(K key, V value) {
3
4 if (key == null)
5 return putForNullKey(value);
6
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
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
21 modCount++;
22 addEntry(hash, key, value, i);
23 return null;
24 }
25
26
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
33 e.recordAccess(this);
34 return oldValue;
35 }
36 }
37
38
39 modCount++;
40 addEntry(0, null, value, 0);
41 return null;
42 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
Hashtable的添加key-value的方法
1
2 public synchronized V put(K key, V value) {
3
4 if (value == null) {
5 throw new NullPointerException();
6 }
7
8
9
10 Entry tab[] = table;
11
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
24
25 modCount++;
26
27
28 if (count >= threshold) {
29
30 rehash();
31
32 tab = table;
33 index = (hash & 0x7FFFFFFF) % tab.length;
34 }
35
36
37
38 tab[index] = new Entry<K,V>(hash, key, value, e);
39
40 count++;
41 return null;
42 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
根據上面的代碼，我們可以看出：
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。
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
2 public Set<Map.Entry<K,V>> entrySet() {
3 return entrySet0();
4 }
5
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
11
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
20 Iterator<Map.Entry<K,V>> newEntryIterator() {
21 return new EntryIterator();
22 }
23
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
33 int expectedModCount;
34
35 int index;
36
37 Entry<K,V> current;
38
39 HashIterator() {
40 expectedModCount = modCount;
41 if (size > 0) {
42 Entry[] t = table;
43
44
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
64
65
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 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
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
16 Entry[] table = Hashtable.this.table;
17
18 int index = table.length;
19 Entry<K,V> entry = null;
20 Entry<K,V> lastReturned = null;
21 int type;
22
23
24
25 boolean iterator;
26
27
28 protected int expectedModCount = modCount;
29
30 Enumerator(int type, boolean iterator) {
31 this.type = type;
32 this.iterator = iterator;
33 }
34
35
36 public boolean hasMoreElements() {
37 Entry<K,V> e = entry;
38 int i = index;
39 Entry[] t = table;
40
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
51
52
53 public T nextElement() {
54 Entry<K,V> et = entry;
55 int i = index;
56 Entry[] t = table;
57
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
72
73 public boolean hasNext() {
74 return hasMoreElements();
75 }
76
77
78
79 public T next() {
80 if (modCount != expectedModCount)
81 throw new ConcurrentModificationException();
82 return nextElement();
83 }
84
85 ...
86
87 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
HashMap默認的容量大小是16；增加容量時，每次將容量變爲“原始容量x2”。
Hashtable默認的容量大小是11；增加容量時，每次將容量變爲“原始容量x2 + 1”。
HashMap默認的“加載因子”是0.75, 默認的容量大小是16。
1
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 }
當HashMap的 “實際容量” >= “閾值”時，(閾值 = 總的容量 * 加載因子)，就將HashMap的容量翻倍。
1
2 void addEntry(int hash, K key, V value, int bucketIndex) {
3
4 Entry<K,V> e = table[bucketIndex];
5
6
7 table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
8
9 if (size++ >= threshold)
10 resize(2 * table.length);
11 }
Hashtable默認的“加載因子”是0.75, 默認的容量大小是11。
1
2 public Hashtable() {
3
4 this(11, 0.75f);
5 }
當Hashtable的 “實際容量” >= “閾值”時，(閾值 = 總的容量 x 加載因子)，就將變爲“原始容量x2 + 1”。
1
2
3
4
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 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
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
7 public V put(K key, V value) {
8
9 if (key == null)
10 return putForNullKey(value);
11
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
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
26 modCount++;
27 addEntry(hash, key, value, i);
28 return null;
29 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
Hashtable沒有自定義哈希算法，而直接採用的key的hashCode()。
1 public synchronized V put(K key, V value) {
2
3 if (value == null) {
4 throw new NullPointerException();
5 }
6
7
8
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
21
22 modCount++;
23
24
25 if (count >= threshold) {
26
27 rehash();
28
29 tab = table;
30 index = (hash & 0x7FFFFFFF) % tab.length;
31 }
32
33
34 Entry<K,V> e = tab[index];
35
36 tab[index] = new Entry<K,V>(hash, key, value, e);
37
38 count++;
39 return null;
40 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
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 [email protected]
13 */
14 public class CompareHashmapAndWeakhashmap {
15
16 public static void main(String[] args) throws Exception {
17
18
19 compareWithString();
20
21 compareWithSelfClass();
22 }
23
24 /**
25 * 遍歷map，並打印map的大小
26 */
27 private static void iteratorAndCountMap(Map map) {
28
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
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
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
50 Map wmap = new WeakHashMap();
51 wmap.put(w1, "w1");
52 wmap.put(w2, "w2");
53
54
55 Map hmap = new HashMap();
56 hmap.put(h1, "h1");
57 hmap.put(h2, "h2");
58
59
60
61 hmap.remove(h1);
62
63
64
65
66
67
68 w1 = null;
69 System.gc();
70
71
72 System.out.printf(" -- HashMap --\n");
73 iteratorAndCountMap(hmap);
74
75
76 System.out.printf(" -- WeakHashMap --\n");
77 iteratorAndCountMap(wmap);
78 }
79
80 /**
81 * 通過自定義類測試HashMap和WeakHashMap
82 */
83 private static void compareWithSelfClass() {
84
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
91 Map wmap = new WeakHashMap();
92 wmap.put(s1, "s1");
93 wmap.put(s2, "s2");
94
95
96 Map hmap = new HashMap();
97 hmap.put(s3, "s3");
98 hmap.put(s4, "s4");
99
100
101
102 hmap.remove(s3);
103
104
105
106
107
108
109 s1 = null;
110 System.gc();
111
112
120
121
122 System.out.printf(" -- Self-def HashMap --\n");
123 iteratorAndCountMap(hmap);
124
125
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
138
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 }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
運行結果：
-- 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
