java中HashSet詳解

標籤：

HashSet 的實現

對於 HashSet 而言，它是基於 HashMap 實現的，HashSet 底層採用 HashMap 來儲存所有元素，因此 HashSet 的實現比較簡單，查看 HashSet 的原始碼，可以看到如下代碼：

Java代碼  

1. public class HashSet<E>   
2.  extends AbstractSet<E>   
3.  implements Set<E>, Cloneable, java.io.Serializable   
4. {   
5.  // 使用 HashMap 的 key 儲存 HashSet 中所有元素  
6.  private transient HashMap<E,Object> map;   
7.  // 定義一個虛擬 Object 對象作為 HashMap 的 value   
8.  private static final Object PRESENT = new Object();   
9.  ...   
10.  // 初始化 HashSet，底層會初始化一個 HashMap   
11.  public HashSet()   
12.  {   
13.      map = new HashMap<E,Object>();   
14.  }   
15.  // 以指定的 initialCapacity、loadFactor 建立 HashSet   
16.  // 其實就是以相應的參數建立 HashMap   
17.  public HashSet(int initialCapacity, float loadFactor)   
18.  {   
19.      map = new HashMap<E,Object>(initialCapacity, loadFactor);   
20.  }   
21.  public HashSet(int initialCapacity)   
22.  {   
23.      map = new HashMap<E,Object>(initialCapacity);   
24.  }   
25.  HashSet(int initialCapacity, float loadFactor, boolean dummy)   
26.  {   
27.      map = new LinkedHashMap<E,Object>(initialCapacity   
28.          , loadFactor);   
29.  }   
30.  // 調用 map 的 keySet 來返回所有的 key   
31.  public Iterator<E> iterator()   
32.  {   
33.      return map.keySet().iterator();   
34.  }   
35.  // 調用 HashMap 的 size() 方法返回 Entry 的數量，就得到該 Set 裡元素的個數  
36.  public int size()   
37.  {   
38.      return map.size();   
39.  }   
40.  // 調用 HashMap 的 isEmpty() 判斷該 HashSet 是否為空白，  
41.  // 當 HashMap 為空白時，對應的 HashSet 也為空白  
42.  public boolean isEmpty()   
43.  {   
44.      return map.isEmpty();   
45.  }   
46.  // 調用 HashMap 的 containsKey 判斷是否包含指定 key   
47.  //HashSet 的所有元素就是通過 HashMap 的 key 來儲存的  
48.  public boolean contains(Object o)   
49.  {   
50.      return map.containsKey(o);   
51.  }   
52.  // 將指定元素放入 HashSet 中，也就是將該元素作為 key 放入 HashMap   
53.  public boolean add(E e)   
54.  {   
55.      return map.put(e, PRESENT) == null;   
56.  }   
57.  // 調用 HashMap 的 remove 方法刪除指定 Entry，也就刪除了 HashSet 中對應的元素  
58.  public boolean remove(Object o)   
59.  {   
60.      return map.remove(o)==PRESENT;   
61.  }   
62.  // 調用 Map 的 clear 方法清空所有 Entry，也就清空了 HashSet 中所有元素  
63.  public void clear()   
64.  {   
65.      map.clear();   
66.  }   
67.  ...   
68. }   

由上面來源程式可以看出，HashSet 的實現其實非常簡單，它只是封裝了一個 HashMap 對象來儲存所有的集合元素，所有放入 HashSet 中的集合元素實際上由 HashMap 的 key 來儲存，而 HashMap 的 value 則儲存了一個 PRESENT，它是一個靜態 Object 對象。

HashSet 的絕大部分方法都是通過調用 HashMap 的方法來實現的，因此 HashSet 和 HashMap 兩個集合在實現本質上是相同的。
掌握上面理論知識之後，接下來看一個樣本程式，測試一下自己是否真正掌握了 HashMap 和 HashSet 集合的功能。

Java代碼  

1.  class Name  
2. {  
3.     private String first;   
4.     private String last;   
5.       
6.     public Name(String first, String last)   
7.     {   
8.         this.first = first;   
9.         this.last = last;   
10.     }   
11.   
12.     public boolean equals(Object o)   
13.     {   
14.         if (this == o)   
15.         {   
16.             return true;   
17.         }   
18.           
19.     if (o.getClass() == Name.class)   
20.         {   
21.             Name n = (Name)o;   
22.             return n.first.equals(first)   
23.                 && n.last.equals(last);   
24.         }   
25.         return false;   
26.     }   
27. }  
28.   
29. public class HashSetTest  
30. {  
31.     public static void main(String[] args)  
32.     {   
33.         Set<Name> s = new HashSet<Name>();  
34.         s.add(new Name("abc", "123"));  
35.         System.out.println(  
36.             s.contains(new Name("abc", "123")));  
37.     }  
38. }   

上面程式中向 HashSet 裡添加了一個 new Name("abc", "123") 對象之後，立即通過程式判斷該 HashSet 是否包含一個 new Name("abc", "123") 對象。粗看上去，很容易以為該程式會輸出 true。

實際運行上面程式將看到程式輸出 false，這是因為 HashSet 判斷兩個對象相等的標準除了要求通過 equals() 方法比較返回 true 之外，還要求兩個對象的 hashCode() 傳回值相等。而上面程式沒有重寫 Name 類的 hashCode() 方法，兩個 Name 對象的 hashCode() 傳回值並不相同，因此 HashSet 會把它們當成 2 個對象處理，因此程式返回 false。

由此可見，當我們試圖把某個類的對象當成 HashMap 的 key，或試圖將這個類的對象放入 HashSet 中儲存時，重寫該類的 equals(Object obj) 方法和 hashCode() 方法很重要，而且這兩個方法的傳回值必須保持一致：當該類的兩個的 hashCode() 傳回值相同時，它們通過 equals() 方法比較也應該返回 true。通常來說，所有參與計算 hashCode() 傳回值的關鍵屬性，都應該用於作為 equals() 比較的標準。
如下程式就正確重寫了 Name 類的 hashCode() 和 equals() 方法，程式如下：

Java代碼  

1. class Name   
2. {   
3.     private String first;  
4.     private String last;  
5.     public Name(String first, String last)  
6.     {   
7.         this.first = first;   
8.         this.last = last;   
9.     }   
10.     // 根據 first 判斷兩個 Name 是否相等  
11.     public boolean equals(Object o)   
12.     {   
13.         if (this == o)   
14.         {   
15.             return true;   
16.         }   
17.         if (o.getClass() == Name.class)   
18.         {   
19.             Name n = (Name)o;   
20.             return n.first.equals(first);   
21.         }   
22.         return false;   
23.     }   
24.        
25.     // 根據 first 計算 Name 對象的 hashCode() 傳回值  
26.     public int hashCode()   
27.     {   
28.         return first.hashCode();   
29.     }  
30.   
31.     public String toString()   
32.     {   
33.         return "Name[first=" + first + ", last=" + last + "]";   
34.     }   
35.  }   
36.    
37.  public class HashSetTest2   
38.  {   
39.     public static void main(String[] args)   
40.     {   
41.         HashSet<Name> set = new HashSet<Name>();   
42.         set.add(new Name("abc" , "123"));   
43.         set.add(new Name("abc" , "456"));   
44.         System.out.println(set);   
45.     }   
46. }  

上面程式中提供了一個 Name 類，該 Name 類重寫了 equals() 和 toString() 兩個方法，這兩個方法都是根據 Name 類的 first 執行個體變數來判斷的，當兩個 Name 對象的 first 執行個體變數相等時，這兩個 Name 對象的 hashCode() 傳回值也相同，通過 equals() 比較也會返回 true。

程式主方法先將第一個 Name 對象添加到 HashSet 中，該 Name 對象的 first 執行個體變數值為"abc"，接著程式再次試圖將一個 first 為"abc"的 Name 對象添加到 HashSet 中，很明顯，此時沒法將新的 Name 對象添加到該 HashSet 中，因為此處試圖添加的 Name 對象的 first 也是" abc"，HashSet 會判斷此處新增的 Name 對象與原有的 Name 對象相同，因此無法添加進入，程式在①號代碼處輸出 set 集合時將看到該集合裡只包含一個 Name 對象，就是第一個、last 為"123"的 Name 對象。

java中HashSet詳解（轉）