Java集合類操作優(yōu)化經(jīng)驗總結

1、本文首先針對 Java 集合接口進行了一些介紹，并對這些接口的實現(xiàn)類進行詳細描述，包括 LinkedList、ArrayList、Vector、Stack、Hashtable、HashMap、WeakHashMap 等，然后對一些實現(xiàn)類的實現(xiàn)方式和使用經(jīng)驗進行講解，同時重點介紹 WeakHashMap。希望通過本文介紹，可以讓讀者對集合的操作方式、注意事項等有一些了解。在實際的項目開發(fā)中會有很多的對象，如何高效、方便地管理對象，成為影響程序性能與可維護性的重要環(huán)節(jié)。Java 提供了集合框架來解決此類問題，線性表、鏈表、哈希表等是常用的數(shù)據(jù)結構，在進行 Java 開發(fā)時，JDK 已經(jīng)為

2、我們提供了一系列相應的類來實現(xiàn)基本的數(shù)據(jù)結構，所有類都在 java.util 這個包里，清單 1 描述了集合類的關系。清單 1.集合類之間關系CollectionListLinkedListArrayListVectorStackSetMapHashtableHashMapWeakHashMap本文講的就是集合框架的使用經(jīng)驗總結，注意，本文所有代碼基于 JDK7。集合接口Collection 接口Collection 是最基本的集合接口，一個 Collection 代表一組 Object，即 Collection 的元素（Elements）。一些 Collection 允許相同的元素、支持對元

3、素進行排序，另一些則不行。JDK 不提供直接繼承自 Collection 的類，JDK 提供的類都是繼承自 Collection 的子接口，如 List 和 Set。所有實現(xiàn) Collection 接口的類都必須提供兩個標準的構造函數(shù)，無參數(shù)的構造函數(shù)用于創(chuàng)建一個空的 Collection，有一個 Collection 參數(shù)的構造函數(shù)用于創(chuàng)建一個新的 Collection，這個新的 Collection 與傳入的 Collection 有相同的元素，后一個構造函數(shù)允許用戶復制一個 Collection。如何遍歷 Collection 中的每一個元素？不論 Collection 的實際類型如何，

4、它都支持一個 iterator() 的方法，該方法返回一個迭代子，使用該迭代子即可逐一訪問 Collection 中每一個元素。典型的用法如下：Iterator it = collection.iterator(); / 獲得一個迭代子while(it.hasNext()Object obj = it.next(); / 得到下一個元素Collection 接口派生的兩個接口是 List 和 Set。Collection 接口提供的主要方法：1. boolean add(Object o) 添加對象到集合；2. boolean remove(Object o) 刪除指定的對象；3. int s

5、ize() 返回當前集合中元素的數(shù)量；4. boolean contains(Object o) 查找集合中是否有指定的對象；5. boolean isEmpty() 判斷集合是否為空；6. Iterator iterator() 返回一個迭代器；7. boolean containsAll(Collection c) 查找集合中是否有集合 C 中的元素；8. boolean addAll(Collection c) 將集合 C 中所有的元素添加給該集合；9. void clear() 刪除集合中所有元素；10. void removeAll(Collection c) 從集合中刪除 C 集合

6、中也有的元素；11. void retainAll(Collection c) 從集合中刪除集合 C 中不包含的元素。List 接口List 是有序的 Collection，使用此接口能夠精確的控制每個元素插入的位置。用戶能夠使用索引（元素在 List 中的位置，類似于數(shù)組下標）來訪問 List 中的元素，這類似于 Java 的數(shù)組。和下文要提到的 Set 不同，List 允許有相同的元素。除了具有 Collection 接口必備的 iterator() 方法外，List 還提供一個 listIterator() 方法，返回一個 ListIterator 接口。和標準的 Iterator 接口

7、相比，ListIterator 多了一些 add() 之類的方法，允許添加、刪除、設定元素、向前或向后遍歷等功能。實現(xiàn) List 接口的常用類有 LinkedList，ArrayList，Vector 和 Stack 等。List 接口提供的主要方法：1. void add(int index,Object element) 在指定位置上添加一個對象；2. boolean addAll(int index,Collection c) 將集合 C 的元素添加到指定的位置；3. Object get(int index) 返回 List 中指定位置的元素；4. int indexOf(Object

8、 o) 返回第一個出現(xiàn)元素 O 的位置；5. Object removeint(int index) 刪除指定位置的元素；6. Object set(int index,Object element) 用元素 element 取代位置 index 上的元素, 返回被取代的元素。Map 接口Map 沒有繼承 Collection 接口。Map 提供 Key 到 Value 的映射，一個 Map 中不能包含相同的 Key，每個 Key 只能映射一個 Value。Map 接口提供 3 種集合的視圖，Map 的內(nèi)容可以被當作一組 Key 集合，一組 Value 集合，或者一組 Key-Value 映射

9、。Map 提供的主要方法：1. boolean equals(Object o) 比較對象；2. boolean remove(Object o) 刪除一個對象；3. put(Object key,Object value) 添加 key 和 value。RandomAccess 接口RandomAccess 接口是一個標志接口，本身并沒有提供任何方法，任務凡是通過調(diào)用 RandomAccess 接口的對象都可以認為是支持快速隨機訪問的對象。此接口的主要目的是標識那些可支持快速隨機訪問的 List 實現(xiàn)。任何一個基于數(shù)組的 List 實現(xiàn)都實現(xiàn)了 RaodomAccess 接口，而基于鏈表的實

10、現(xiàn)則都沒有。因為只有數(shù)組能夠進行快速的隨機訪問，而對鏈表的隨機訪問需要進行鏈表的遍歷。因此，此接口的好處是，可以在應用程序中知道正在處理的 List 對象是否可以進行快速隨機訪問，從而針對不同的 List 進行不同的操作，以提高程序的性能。集合類介紹LinkedList 類LinkedList 實現(xiàn)了 List 接口，允許 Null 元素。此外 LinkedList 提供額外的 Get、Remove、Insert 等方法在 LinkedList 的首部或尾部操作數(shù)據(jù)。這些操作使得 LinkedList 可被用作堆棧（Stack）、隊列（Queue）或雙向隊列（Deque）。請注意 Linked

11、List 沒有同步方法，它不是線程同步的，即如果多個線程同時訪問一個 List，則必須自己實現(xiàn)訪問同步。一種解決方法是在創(chuàng)建 List 時構造一個同步的 List，方法如List list = Collections.synchronizedList(new LinkedList(.)；ArrayList 類ArrayList 實現(xiàn)了可變大小的數(shù)組。它允許所有元素，包括 Null。Size、IsEmpty、Get、Set 等方法的運行時間為常數(shù)，但是 Add 方法開銷為分攤的常數(shù)，添加 N 個元素需要 O(N) 的時間，其他的方法運行時間為線性。每個 ArrayList 實例都有一個容量（Ca

12、pacity），用于存儲元素的數(shù)組的大小，這個容量可隨著不斷添加新元素而自動增加。當需要插入大量元素時，在插入前可以調(diào)用 ensureCapacity 方法來增加 ArrayList 的容量以提高插入效率。和 LinkedList 一樣，ArrayList 也是線程非同步的（unsynchronized）。ArrayList 提供的主要方法：1. Boolean add(Object o) 將指定元素添加到列表的末尾；2. Boolean add(int index,Object element) 在列表中指定位置加入指定元素；3. Boolean addAll(Collection c) 將

13、指定集合添加到列表末尾；4. Boolean addAll(int index,Collection c) 在列表中指定位置加入指定集合；5. Boolean clear() 刪除列表中所有元素；6. Boolean clone() 返回該列表實例的一個拷貝；7. Boolean contains(Object o) 判斷列表中是否包含元素；8. Boolean ensureCapacity(int m) 增加列表的容量，如果必須，該列表能夠容納 m 個元素；9. Object get(int index) 返回列表中指定位置的元素；10. Int indexOf(Object elem) 在

14、列表中查找指定元素的下標；11. Int size() 返回當前列表的元素個數(shù)。Vector 類Vector 非常類似于 ArrayList，區(qū)別是 Vector 是線程同步的。由 Vector 創(chuàng)建的 Iterator，雖然和 ArrayList 創(chuàng)建的 Iterator 是同一接口，但是，因為 Vector 是同步的，當一個 Iterator 被創(chuàng)建而且正在被使用，另一個線程改變了 Vector 的狀態(tài)（例如，添加或刪除了一些元素），這時調(diào)用 Iterator 的方法時將拋出 ConcurrentModificationException，因此必須捕獲該異常。Stack 類Stack 繼承

15、自 Vector，實現(xiàn)了一個后進先出的堆棧。Stack 提供 5 個額外的方法使得 Vector 得以被當作堆棧使用。除了基本的 Push 和 Pop 方法，還有 Peek 方法得到棧頂?shù)脑兀珽mpty 方法測試堆棧是否為空，Search 方法檢測一個元素在堆棧中的位置。注意，Stack 剛創(chuàng)建后是空棧。Set 類Set 是一種不包含重復的元素的 Collection，即任意的兩個元素 e1 和 e2 都有 e1.equals(e2)=false。Set 最多有一個 null 元素。很明顯，Set 的構造函數(shù)有一個約束條件，傳入的 Collection 參數(shù)不能包含重復的元素。請注意，必須小

16、心操作可變對象（Mutable Object），如果一個 Set 中的可變元素改變了自身狀態(tài)，這可能會導致一些問題。Hashtable 類Hashtable 繼承 Map 接口，實現(xiàn)了一個基于 Key-Value 映射的哈希表。任何非空（non-null）的對象都可作為 Key 或者 Value。添加數(shù)據(jù)使用 Put(Key，Value)，取出數(shù)據(jù)使用 Get(Key)，這兩個基本操作的時間開銷為常數(shù)。Hashtable 通過 Initial Capacity 和 Load Factor 兩個參數(shù)調(diào)整性能。通常缺省的 Load Factor 0.75 較好地實現(xiàn)了時間和空間的均衡。增大 Loa

17、d Factor 可以節(jié)省空間但相應的查找時間將增大，會影響像 Get 和 Put 這樣的操作。使用 Hashtable 的簡單示例，將 1、2、3 這三個數(shù)字放到 Hashtable 里面，他們的 Key 分別是”one”、”two”、”three”，代碼如清單 2 所示。清單 2 .Hashtable 示例Hashtable numbers = new Hashtable();numbers.put(“one”, new Integer(1);numbers.put(“two”, new Integer(2);numbers.put(“three”, new Integer(3);如果我們

18、需要取出一個數(shù)，比如 2，可以用相應的 key 來取出，代碼如清單 3 所示。清單 3.從 Hastable 讀取數(shù)據(jù)Integer n = (Integer)numbers.get(“two”); System.out.println(“two =”+ n);由于作為 Key 的對象將通過計算其散列函數(shù)來確定與之對應的 Value 的位置，因此任何作為 key 的對象都必須實現(xiàn) HashCode 和 Equals 方法。HashCode 和 Equals 方法繼承自根類 Object，如果你用自定義的類當作 Key 的話，要相當小心，按照散列函數(shù)的定義，如果兩個對象相同，即 obj1.equ

19、als(obj2)=true，則它們的 HashCode 必須相同，但如果兩個對象不同，則它們的 HashCode 不一定不同，如果兩個不同對象的 HashCode 相同，這種現(xiàn)象稱為沖突，沖突會導致操作哈希表的時間開銷增大，所以盡量定義好的 HashCode() 方法，能加快哈希表的操作。如果相同的對象有不同的 HashCode，對哈希表的操作會出現(xiàn)意想不到的結果（期待的 Get 方法返回 Null），要避免這種問題，最好同時復寫 Equals 方法和 HashCode 方法，而不要只寫其中一個。HashMap 類HashMap 和 Hashtable 類似，不同之處在于 HashMap 是

20、線程非同步的，并且允許 Null，即 Null Value 和 Null Key。但是將 HashMap 視為 Collection 時（values() 方法可返回 Collection），其迭代子操作時間開銷和 HashMap 的容量成比例。因此，如果迭代操作的性能相當重要的話，不要將 HashMap 的初始化容量設得過高，或者 Load Factor 參數(shù)設置過低。WeakHashMap 類WeakHashMap 是一種改進的 HashMap，它對 Key 實行“弱引用”，如果一個 Key 不再被外部所引用，那么該 Key 可以被 GC 回收。集合類實踐ArrayList、Vector、

21、LinkedList 均來自 AbstractList 的實現(xiàn)，而 AbstractList 直接實現(xiàn)了 List 接口，并擴展自 AbstarctCollection。ArrayList 和 Vector 使用了數(shù)組實現(xiàn)，ArrayList 沒有對任何一個方法提供線程同步，因此不是線程安全的，Vector 中絕大部分方法都做了線程同步，是一種線程安全的實現(xiàn)。LinkedList 使用了循環(huán)雙向鏈表數(shù)據(jù)結構，由一系列表項連接而成，一個表項總是包含 3 個部分，元素內(nèi)容、前驅(qū)表項和后驅(qū)表項。當 ArrayList 對容量的需求超過當前數(shù)組的大小時，需要進行擴容。擴容過程中，會進行大量的數(shù)組復制操

22、作，而數(shù)組復制時，最終將調(diào)用 System.arraycopy() 方法。LinkedList 由于使用了鏈表的結構，因此不需要維護容量的大小，然而每次的元素增加都需要新建一個 Entry 對象，并進行更多的賦值操作，在頻繁的系統(tǒng)調(diào)用下，對性能會產(chǎn)生一定的影響，在不間斷地生成新的對象還是占用了一定的資源。而因為數(shù)組的連續(xù)性，因此總是在尾端增加元素時，只有在空間不足時才產(chǎn)生數(shù)組擴容和數(shù)組復制。ArrayList 是基于數(shù)組實現(xiàn)的，而數(shù)組是一塊連續(xù)的內(nèi)存空間，如果在數(shù)組的任意位置插入元素，必然導致在該位置后的所有元素需要重新排列，因此其效率較差，盡可能將數(shù)據(jù)插入到尾部。LinkedList 不會因

23、為插入數(shù)據(jù)導致性能下降。ArrayList 的每一次有效的元素刪除操作后都要進行數(shù)組的重組，并且刪除的元素位置越靠前，數(shù)組重組時的開銷越大，要刪除的元素位置越靠后，開銷越小。LinkedList 要移除中間的數(shù)據(jù)需要便利完半個 List。清單 4. ArrayList 和 LinkedList 使用代碼import java.util.ArrayList;import java.util.LinkedList;public class ArrayListandLinkedList public static void main(String args) long start = System.

24、currentTimeMillis(); ArrayList list = new ArrayList(); Object obj = new Object(); for(int i=0;i<5000000;i+) list.add(obj); long end = System.currentTimeMillis(); System.out.println(end-start); start = System.currentTimeMillis(); LinkedList list1 = new LinkedList(); Object obj1 = new Object(); for

25、(int i=0;i<5000000;i+) list1.add(obj1); end = System.currentTimeMillis(); System.out.println(end-start); start = System.currentTimeMillis(); Object obj2 = new Object(); for(int i=0;i<1000;i+) list.add(0,obj2); end = System.currentTimeMillis(); System.out.println(end-start); start = System.curr

26、entTimeMillis(); Object obj3 = new Object(); for(int i=0;i<1000;i+) list1.add(obj1); end = System.currentTimeMillis(); System.out.println(end-start); start = System.currentTimeMillis(); list.remove(0); end = System.currentTimeMillis(); System.out.println(end-start); start = System.currentTimeMill

27、is(); list1.remove(250000); end = System.currentTimeMillis(); System.out.println(end-start); 清單 5. 運行輸出639129669690015HashMap 是將 Key 做 Hash 算法，然后將 Hash 值映射到內(nèi)存地址，直接取得 Key 所對應的數(shù)據(jù)。在 HashMap 中，底層數(shù)據(jù)結構使用的是數(shù)組，所謂的內(nèi)存地址即數(shù)組的下標索引。HashMap 的高性能需要保證以下幾點：1. Hash 算法必須是高效的；2. Hash 值到內(nèi)存地址 (數(shù)組索引) 的算法是快速的；3. 根據(jù)內(nèi)存地址 (數(shù)組索

28、引) 可以直接取得對應的值。HashMap 實際上是一個鏈表的數(shù)組。前面已經(jīng)介紹過，基于 HashMap 的鏈表方式實現(xiàn)機制，只要 HashCode() 和 Hash() 方法實現(xiàn)得足夠好，能夠盡可能地減少沖突的產(chǎn)生，那么對 HashMap 的操作幾乎等價于對數(shù)組的隨機訪問操作，具有很好的性能。但是，如果 HashCode() 或者 Hash() 方法實現(xiàn)較差，在大量沖突產(chǎn)生的情況下，HashMap 事實上就退化為幾個鏈表，對 HashMap 的操作等價于遍歷鏈表，此時性能很差。HashMap 的一個功能缺點是它的無序性，被存入到 HashMap 中的元素，在遍歷 HashMap 時，其輸出是

29、無序的。如果希望元素保持輸入的順序，可以使用 LinkedHashMap 替代。LinkedHashMap 繼承自 HashMap，具有高效性，同時在 HashMap 的基礎上，又在內(nèi)部增加了一個鏈表，用以存放元素的順序。HashMap 通過 hash 算法可以最快速地進行 Put() 和 Get() 操作。TreeMap 則提供了一種完全不同的 Map 實現(xiàn)。從功能上講，TreeMap 有著比 HashMap 更為強大的功能，它實現(xiàn)了 SortedMap 接口，這意味著它可以對元素進行排序。TreeMap 的性能略微低于 HashMap。如果在開發(fā)中需要對元素進行排序，那么使用 HashMa

30、p 便無法實現(xiàn)這種功能，使用 TreeMap 的迭代輸出將會以元素順序進行。LinkedHashMap 是基于元素進入集合的順序或者被訪問的先后順序排序，TreeMap 則是基于元素的固有順序 (由 Comparator 或者 Comparable 確定)。LinkedHashMap 是根據(jù)元素增加或者訪問的先后順序進行排序，而 TreeMap 則根據(jù)元素的 Key 進行排序。清單 6 所示代碼演示了使用 TreeMap 實現(xiàn)業(yè)務邏輯的排序。清單 6. TreeMap 實現(xiàn)排序import java.util.Iterator;import java.util.Map;import java.

31、util.TreeMap;public class Student implements Comparable<Student>public String name;public int score;public Student(String name,int score) = name;this.score = score;Override/告訴 TreeMap 如何排序public int compareTo(Student o) / TODO Auto-generated method stubif(o.score<this.score)return

32、1;else if(o.score>this.score)return -1;return 0;Overridepublic String toString()StringBuffer sb = new StringBuffer();sb.append("name:");sb.append(name);sb.append(" ");sb.append("score:");sb.append(score);return sb.toString();public static void main(String args)TreeMa

33、p map = new TreeMap();Student s1 = new Student("1",100);Student s2 = new Student("2",99);Student s3 = new Student("3",97);Student s4 = new Student("4",91);map.put(s1, new StudentDetailInfo(s1);map.put(s2, new StudentDetailInfo(s2);map.put(s3, new StudentDetail

34、Info(s3);map.put(s4, new StudentDetailInfo(s4);/打印分數(shù)位于 S4 和 S2 之間的人Map map1=(TreeMap)map).subMap(s4, s2);for(Iterator iterator=map1.keySet().iterator();iterator.hasNext();)Student key = (Student)iterator.next();System.out.println(key+"->"+map.get(key);System.out.println("subMap end

35、");/打印分數(shù)比 s1 低的人map1=(TreeMap)map).headMap(s1);for(Iterator iterator=map1.keySet().iterator();iterator.hasNext();)Student key = (Student)iterator.next();System.out.println(key+"->"+map.get(key);System.out.println("subMap end");/打印分數(shù)比 s1 高的人map1=(TreeMap)map).tailMap(s1);f

36、or(Iterator iterator=map1.keySet().iterator();iterator.hasNext();)Student key = (Student)iterator.next();System.out.println(key+"->"+map.get(key);System.out.println("subMap end");class StudentDetailInfoStudent s;public StudentDetailInfo(Student s)this.s = s;Overridepublic Stri

37、ng toString()return + "'s detail information"清單 7 .運行輸出name:4 score:91->4's detail informationname:3 score:97->3's detail informationsubMap endname:4 score:91->4's detail informationname:3 score:97->3's detail informationname:2 score:99->2's de

38、tail informationsubMap endname:1 score:100->1's detail informationsubMap endWeakHashMap 特點是當除了自身有對 Key 的引用外，如果此 Key 沒有其他引用，那么此 Map 會自動丟棄該值。如清單 8 所示代碼聲明了兩個 Map 對象，一個是 HashMap，一個是 WeakHashMap，同時向兩個 map 中放入 A、B 兩個對象，當 HashMap 刪除 A，并且 A、B 都指向 Null 時，WeakHashMap 中的 A 將自動被回收掉。出現(xiàn)這個狀況的原因是，對于 A 對象而言，當

39、 HashMap 刪除并且將 A 指向 Null 后，除了 WeakHashMap 中還保存 A 外已經(jīng)沒有指向 A 的指針了，所以 WeakHashMap 會自動舍棄掉 a，而對于 B 對象雖然指向了 null，但 HashMap 中還有指向 B 的指針，所以 WeakHashMap 將會保留 B 對象。清單 8.WeakHashMap 示例代碼import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.WeakHashMap; public class WeakHas

40、hMapTest public static void main(String args) throws Exception String a = new String("a"); String b = new String("b"); Map weakmap = new WeakHashMap(); Map map = new HashMap(); map.put(a, "aaa"); map.put(b, "bbb"); weakmap.put(a, "aaa"); weakmap.put(

41、b, "bbb"); map.remove(a); a=null; b=null; System.gc(); Iterator i = map.entrySet().iterator(); while (i.hasNext() Map.Entry en = (Map.Entry)i.next(); System.out.println("map:"+en.getKey()+":"+en.getValue(); Iterator j = weakmap.entrySet().iterator(); while (j.hasNext()

42、Map.Entry en = (Map.Entry)j.next(); System.out.println("weakmap:"+en.getKey()+":"+en.getValue(); 清單 9 .運行輸出map:b:bbbweakmap:b:bbbWeakHashMap 主要通過 expungeStaleEntries 這個函數(shù)來實現(xiàn)移除其內(nèi)部不用的條目，從而達到自動釋放內(nèi)存的目的。基本上只要對 WeakHashMap 的內(nèi)容進行訪問就會調(diào)用這個函數(shù)，從而達到清除其內(nèi)部不再為外部引用的條目。但是如果預先生成了 WeakHashMap，而在 GC

43、 以前又不曾訪問該 WeakHashMap, 那不是就不能釋放內(nèi)存了嗎？清單 10. WeakHashMapTest1import java.util.ArrayList;import java.util.List;import java.util.WeakHashMap;public class WeakHashMapTest1 public static void main(String args) throws Exception List<WeakHashMap<byte, byte>> maps = new ArrayList<WeakHashMap&l

44、t;byte, byte>>(); for (int i = 0; i < 1000; i+) WeakHashMap<byte, byte> d = new WeakHashMap<byte, byte>(); d.put(new byte10001000, new byte10001000); maps.add(d); System.gc(); System.err.println(i); 不改變?nèi)魏?JVM 參數(shù)的情況運行清單 10 所示代碼，由于 Java 默認內(nèi)存是 64M，拋出內(nèi)存溢出了錯誤。清單 11. 運行輸出241242243Exce

45、ption in thread "main" java.lang.OutOfMemoryError: Java heap spaceat WeakHashMapTest1.main(WeakHashMapTest1.java:10)果不其然，WeakHashMap 這個時候并沒有自動幫我們釋放不用的內(nèi)存。清單 12 所示代碼不會出現(xiàn)內(nèi)存溢出問題。清單 12. WeakHashMapTest2import java.util.ArrayList;import java.util.List;import java.util.WeakHashMap;public class We

46、akHashMapTest2 public static void main(String args) throws Exception List<WeakHashMap<byte, byte>> maps = new ArrayList<WeakHashMap<byte, byte>>(); for (int i = 0; i < 1000; i+) WeakHashMap<byte, byte> d = new WeakHashMap<byte, byte>(); d.put(new byte10001000,

47、new byte10001000); maps.add(d); System.gc(); System.err.println(i); for (int j = 0; j < i; j+) System.err.println(j + " size" + maps.get(j).size(); 運行結果發(fā)現(xiàn)這次測試輸出正常, 不再出現(xiàn)內(nèi)存溢出問題。總的來說，WeakHashMap 并不是你什么也干它就能自動釋放內(nèi)部不用的對象的，而是在你訪問它的內(nèi)容的時候釋放內(nèi)部不用的對象。WeakHashMap 實現(xiàn)弱引用，是因為它的 Entry<K,V>是繼承自 Wea

48、kReference<K>的，在 WeakHashMap$Entry<K,V>的類定義及構造函數(shù)里面如清單 13 所示。清單 13. WeakHashMap 類定義private static class Entry<K,V> extends WeakReference<K> implements Map.Entry<K,V> Entry(K key, V value, ReferenceQueue<K> queue,int hash, Entry<K,V> next) super(key, queue); this.value = value; this.hash = hash; this.next = next; 請注意它構造父類的語句：“super(key, queue);”，傳入的是 Key，因此 Key 才是進行弱引用的，Value 是直接強引用關聯(lián)在 this.value 之中。在