Map總結(HashMap, Hashtable, TreeMap, WeakHashMap等使用場景)
學完了Map的全部內容,我們再回頭開開Map的框架圖。
第1部分 Map概括
Map 是“鍵值對”映射的抽象接口。 AbstractMap 實現了Map中的絕大部分函數接口。它減少了“Map的實現類”的重復編碼。 SortedMap 有序的“鍵值對”映射接口。 NavigableMap 是繼承於SortedMap的,支持導航函數的接口。 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中,則刪除鏈表中的節點即可。
上面介紹了HashMap和Hashtable的相同點。正是由於它們都是散列表,我們關注更多的是“它們的區別,以及它們分別適合在什麼情況下使用”。那接下來,我們先看看它們的區別。
第2.2部分 HashMap和Hashtable的不同點
1 繼承和實現方式不同
HashMap 繼承於AbstractMap,實現了Map、Cloneable、java.io.Serializable接口。 Hashtable 繼承於Dictionary,實現了Map、Cloneable、java.io.Serializable接口。
HashMap的定義:
publicclass HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { ... }
Hashtable的定義:
publicclass 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的方法
// 將“key-value”添加到HashMap中 public V put(K key, V value) { // 若“key為null”,則將該鍵值對添加到table[0]中。 if (key == null) return putForNullKey(value); // 若“key不為null”,則計算該key的哈希值,然後將其添加到該哈希值對應的鏈表中。 int hash = hash(key.hashCode()); int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; // 若“該key”對應的鍵值對已經存在,則用新的value取代舊的value。然後退出! if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } // 若“該key”對應的鍵值對不存在,則將“key-value”添加到table中 modCount++; addEntry(hash, key, value, i); return null; } // putForNullKey()的作用是將“key為null”鍵值對添加到table[0]位置 private V putForNullKey(V value) { for (Entry<K,V> e = table[0]; e != null; e = e.next) { if (e.key == null) { V oldValue = e.value; e.value = value; // recordAccess()函數什麼也沒有做 e.recordAccess(this); return oldValue; } } // 添加第1個“key為null”的元素都table中的時候,會執行到這裡。 // 它的作用是將“設置table[0]的key為null,值為value”。 modCount++; addEntry(0, null, value, 0); return null; }
Hashtable的添加key-value的方法
// 將“key-value”添加到Hashtable中 public synchronized V put(K key, V value) { // Hashtable中不能插入value為null的元素!!! if (value == null) { throw new NullPointerException(); } // 若“Hashtable中已存在鍵為key的鍵值對”, // 則用“新的value”替換“舊的value” Entry tab[] = table; // Hashtable中不能插入key為null的元素!!! // 否則,下面的語句會拋出異常! int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { V old = e.value; e.value = value; return old; } } // 若“Hashtable中不存在鍵為key的鍵值對”, // (01) 將“修改統計數”+1 modCount++; // (02) 若“Hashtable實際容量” > “阈值”(阈值=總的容量 * 加載因子) // 則調整Hashtable的大小 if (count >= threshold) { // Rehash the table if the threshold is exceeded rehash(); tab = table; index = (hash & 0x7FFFFFFF) % tab.length; } // (03) 將“Hashtable中index”位置的Entry(鏈表)保存到e中 Entry<K,V> e = tab[index]; // (04) 創建“新的Entry節點”,並將“新的Entry”插入“Hashtable的index位置”,並設置e為“新的Entry”的下一個元素(即“新Entry”為鏈表表頭)。 tab[index] = new Entry<K,V>(hash, key, value, e); // (05) 將“Hashtable的實際容量”+1 count++; return null; }
根據上面的代碼,我們可以看出:
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的實現方式:先“從前向後”的遍歷數組;對數組具體某一項對應的鏈表,則從表頭開始往後遍歷。
// 返回“HashMap的Entry集合” public Set<Map.Entry<K,V>> entrySet() { return entrySet0(); } // 返回“HashMap的Entry集合”,它實際是返回一個EntrySet對象 private Set<Map.Entry<K,V>> entrySet0() { Set<Map.Entry<K,V>> es = entrySet; return es != null ? es : (entrySet = new EntrySet()); } // EntrySet對應的集合 // EntrySet繼承於AbstractSet,說明該集合中沒有重復的EntrySet。 private final class EntrySet extends AbstractSet<Map.Entry<K,V>> { ... public Iterator<Map.Entry<K,V>> iterator() { return newEntryIterator(); } ... } // 返回一個“entry迭代器” Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); } // Entry的迭代器 private final class EntryIterator extends HashIterator<Map.Entry<K,V>> { public Map.Entry<K,V> next() { return nextEntry(); } } private abstract class HashIterator<E> implements Iterator<E> { // 下一個元素 Entry<K,V> next; // expectedModCount用於實現fail-fast機制。 int expectedModCount; // 當前索引 int index; // 當前元素 Entry<K,V> current; HashIterator() { expectedModCount = modCount; if (size > 0) { // advance to first entry Entry[] t = table; // 將next指向table中第一個不為null的元素。 // 這裡利用了index的初始值為0,從0開始依次向後遍歷,直到找到不為null的元素就退出循環。 while (index < t.length && (next = t[index++]) == null) ; } } public final boolean hasNext() { return next != null; } // 獲取下一個元素 final Entry<K,V> nextEntry() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); Entry<K,V> e = next; if (e == null) throw new NoSuchElementException(); // 注意!!! // 一個Entry就是一個單向鏈表 // 若該Entry的下一個節點不為空,就將next指向下一個節點; // 否則,將next指向下一個鏈表(也是下一個Entry)的不為null的節點。 if ((next = e.next) == null) { Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } current = e; return e; } ... }
Hashtable的實現方式:先從“後向往前”的遍歷數組;對數組具體某一項對應的鏈表,則從表頭開始往後遍歷。
public Set<Map.Entry<K,V>> entrySet() { if (entrySet==null) entrySet = Collections.synchronizedSet(new EntrySet(), this); return entrySet; } private class EntrySet extends AbstractSet<Map.Entry<K,V>> { public Iterator<Map.Entry<K,V>> iterator() { return getIterator(ENTRIES); } ... } private class Enumerator<T> implements Enumeration<T>, Iterator<T> { // 指向Hashtable的table Entry[] table = Hashtable.this.table; // Hashtable的總的大小 int index = table.length; Entry<K,V> entry = null; Entry<K,V> lastReturned = null; int type; // Enumerator是 “迭代器(Iterator)” 還是 “枚舉類(Enumeration)”的標志 // iterator為true,表示它是迭代器;否則,是枚舉類。 boolean iterator; // 在將Enumerator當作迭代器使用時會用到,用來實現fail-fast機制。 protected int expectedModCount = modCount; Enumerator(int type, boolean iterator) { this.type = type; this.iterator = iterator; } // 從遍歷table的數組的末尾向前查找,直到找到不為null的Entry。 public boolean hasMoreElements() { Entry<K,V> e = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (e == null && i > 0) { e = t[--i]; } entry = e; index = i; return e != null; } // 獲取下一個元素 // 注意:從hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍歷方式” // 首先,從後向前的遍歷table數組。table數組的每個節點都是一個單向鏈表(Entry)。 // 然後,依次向後遍歷單向鏈表Entry。 public T nextElement() { Entry<K,V> et = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (et == null && i > 0) { et = t[--i]; } entry = et; index = i; if (et != null) { Entry<K,V> e = lastReturned = entry; entry = e.next; return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e); } throw new NoSuchElementException("Hashtable Enumerator"); } // 迭代器Iterator的判斷是否存在下一個元素 // 實際上,它是調用的hasMoreElements() public boolean hasNext() { return hasMoreElements(); } // 迭代器獲取下一個元素 // 實際上,它是調用的nextElement() public T next() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); return nextElement(); } ... }
6 容量的初始值 和 增加方式都不一樣
HashMap默認的容量大小是16;增加容量時,每次將容量變為“原始容量x2”。 Hashtable默認的容量大小是11;增加容量時,每次將容量變為“原始容量x2 + 1”。
HashMap默認的“加載因子”是0.75, 默認的容量大小是16。
// 默認的初始容量是16,必須是2的冪。 static final int DEFAULT_INITIAL_CAPACITY = 16; // 默認加載因子 static final float DEFAULT_LOAD_FACTOR = 0.75f; // 指定“容量大小”的構造函數 public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
當HashMap的 “實際容量” >= “阈值”時,(阈值 = 總的容量 * 加載因子),就將HashMap的容量翻倍。
// 新增Entry。將“key-value”插入指定位置,bucketIndex是位置索引。 void addEntry(int hash, K key, V value, int bucketIndex) { // 保存“bucketIndex”位置的值到“e”中 Entry<K,V> e = table[bucketIndex]; // 設置“bucketIndex”位置的元素為“新Entry”, // 設置“e”為“新Entry的下一個節點” table[bucketIndex] = new Entry<K,V>(hash, key, value, e); // 若HashMap的實際大小 不小於 “阈值”,則調整HashMap的大小 if (size++ >= threshold) resize(2 * table.length); }
Hashtable默認的“加載因子”是0.75, 默認的容量大小是11。
1 // 默認構造函數。 2 public Hashtable() { 3 // 默認構造函數,指定的容量大小是11;加載因子是0.75 4 this(11, 0.75f); 5 }
當Hashtable的 “實際容量” >= “阈值”時,(阈值 = 總的容量 x 加載因子),就將變為“原始容量x2 + 1”。
// 調整Hashtable的長度,將長度變成原來的(2倍+1) // (01) 將“舊的Entry數組”賦值給一個臨時變量。 // (02) 創建一個“新的Entry數組”,並賦值給“舊的Entry數組” // (03) 將“Hashtable”中的全部元素依次添加到“新的Entry數組”中 protected void rehash() { int oldCapacity = table.length; Entry[] oldMap = table; int newCapacity = oldCapacity * 2 + 1; Entry[] newMap = new Entry[newCapacity]; modCount++; threshold = (int)(newCapacity * loadFactor); table = newMap; for (int i = oldCapacity ; i-- > 0 ;) { for (Entry<K,V> old = oldMap[i] ; old != null ; ) { Entry<K,V> e = old; old = old.next; int index = (e.hash & 0x7FFFFFFF) % newCapacity; e.next = newMap[index]; newMap[index] = e; } } }
7 添加key-value時的hash值算法不同
HashMap添加元素時,是使用自定義的哈希算法。 Hashtable沒有自定義哈希算法,而直接采用的key的hashCode()。
HashMap添加元素時,是使用自定義的哈希算法。
static int hash(int h) { h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); } // 將“key-value”添加到HashMap中 public V put(K key, V value) { // 若“key為null”,則將該鍵值對添加到table[0]中。 if (key == null) return putForNullKey(value); // 若“key不為null”,則計算該key的哈希值,然後將其添加到該哈希值對應的鏈表中。 int hash = hash(key.hashCode()); int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; // 若“該key”對應的鍵值對已經存在,則用新的value取代舊的value。然後退出! if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } // 若“該key”對應的鍵值對不存在,則將“key-value”添加到table中 modCount++; addEntry(hash, key, value, i); return null; }
Hashtable沒有自定義哈希算法,而直接采用的key的hashCode()。
public synchronized V put(K key, V value) { // Hashtable中不能插入value為null的元素!!! if (value == null) { throw new NullPointerException(); } // 若“Hashtable中已存在鍵為key的鍵值對”, // 則用“新的value”替換“舊的value” Entry tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { V old = e.value; e.value = value; return old; } } // 若“Hashtable中不存在鍵為key的鍵值對”, // (01) 將“修改統計數”+1 modCount++; // (02) 若“Hashtable實際容量” > “阈值”(阈值=總的容量 * 加載因子) // 則調整Hashtable的大小 if (count >= threshold) { // Rehash the table if the threshold is exceeded rehash(); tab = table; index = (hash & 0x7FFFFFFF) % tab.length; } // (03) 將“Hashtable中index”位置的Entry(鏈表)保存到e中 Entry<K,V> e = tab[index]; // (04) 創建“新的Entry節點”,並將“新的Entry”插入“Hashtable的index位置”,並設置e為“新的Entry”的下一個元素(即“新Entry”為鏈表表頭)。 tab[index] = new Entry<K,V>(hash, key, value, e); // (05) 將“Hashtable的實際容量”+1 count++; return null; }
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的比較測試程序
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.WeakHashMap; import java.util.Date; import java.lang.ref.WeakReference; /** * @desc HashMap 和 WeakHashMap比較程序 * * @author skywang * @email [email protected] */ public class CompareHashmapAndWeakhashmap { public static void main(String[] args) throws Exception { // 當“弱鍵”是String時,比較HashMap和WeakHashMap compareWithString(); // 當“弱鍵”是自定義類型時,比較HashMap和WeakHashMap compareWithSelfClass(); } /** * 遍歷map,並打印map的大小 */ private static void iteratorAndCountMap(Map map) { // 遍歷map for (Iterator iter = map.entrySet().iterator(); iter.hasNext(); ) { Map.Entry en = (Map.Entry)iter.next(); System.out.printf("map entry : %s - %s\n ",en.getKey(), en.getValue()); } // 打印HashMap的實際大小 System.out.printf(" map size:%s\n\n", map.size()); } /** * 通過String對象測試HashMap和WeakHashMap */ private static void compareWithString() { // 新建4個String字符串 String w1 = new String("W1"); String w2 = new String("W2"); String h1 = new String("H1"); String h2 = new String("H2"); // 新建 WeakHashMap對象,並將w1,w2添加到 WeakHashMap中 Map wmap = new WeakHashMap(); wmap.put(w1, "w1"); wmap.put(w2, "w2"); // 新建 HashMap對象,並將h1,h2添加到 WeakHashMap中 Map hmap = new HashMap(); hmap.put(h1, "h1"); hmap.put(h2, "h2"); // 刪除HashMap中的“h1”。 // 結果:刪除“h1”之後,HashMap中只有 h2 ! hmap.remove(h1); // 將WeakHashMap中的w1設置null,並執行gc()。系統會回收w1 // 結果:w1是“弱鍵”,被GC回收後,WeakHashMap中w1對應的鍵值對,也會被從WeakHashMap中刪除。 // w2是“弱鍵”,但它不是null,不會被GC回收;也就不會被從WeakHashMap中刪除。 // 因此,WeakHashMap中只有 w2 // 注意:若去掉“w1=null” 或者“System.gc()”,結果都會不一樣! w1 = null; System.gc(); // 遍歷並打印HashMap的大小 System.out.printf(" -- HashMap --\n"); iteratorAndCountMap(hmap); // 遍歷並打印WeakHashMap的大小 System.out.printf(" -- WeakHashMap --\n"); iteratorAndCountMap(wmap); } /** * 通過自定義類測試HashMap和WeakHashMap */ private static void compareWithSelfClass() { // 新建4個自定義對象 Self s1 = new Self(10); Self s2 = new Self(20); Self s3 = new Self(30); Self s4 = new Self(40); // 新建 WeakHashMap對象,並將s1,s2添加到 WeakHashMap中 Map wmap = new WeakHashMap(); wmap.put(s1, "s1"); wmap.put(s2, "s2"); // 新建 HashMap對象,並將s3,s4添加到 WeakHashMap中 Map hmap = new HashMap(); hmap.put(s3, "s3"); hmap.put(s4, "s4"); // 刪除HashMap中的s3。 // 結果:刪除s3之後,HashMap中只有 s4 ! hmap.remove(s3); // 將WeakHashMap中的s1設置null,並執行gc()。系統會回收w1 // 結果:s1是“弱鍵”,被GC回收後,WeakHashMap中s1對應的鍵值對,也會被從WeakHashMap中刪除。 // w2是“弱鍵”,但它不是null,不會被GC回收;也就不會被從WeakHashMap中刪除。 // 因此,WeakHashMap中只有 s2 // 注意:若去掉“s1=null” 或者“System.gc()”,結果都會不一樣! s1 = null; System.gc(); /* // 休眠500ms try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } // */ // 遍歷並打印HashMap的大小 System.out.printf(" -- Self-def HashMap --\n"); iteratorAndCountMap(hmap); // 遍歷並打印WeakHashMap的大小 System.out.printf(" -- Self-def WeakHashMap --\n"); iteratorAndCountMap(wmap); } private static class Self { int id; public Self(int id) { this.id = id; } // 覆蓋finalize()方法 // 在GC回收時會被執行 protected void finalize() throws Throwable { super.finalize(); System.out.printf("GC Self: id=%d addr=0x%s)\n", id, this); } } }