Java 集合學習系列(二)： HashSet 的實現原理

1. HashSet 概述
HashSet 實現 Set 接口，由哈希表（其實是一個 HashMap 實例）支持。它不保證 set 的迭代順序；特別是它不保證該順序恆久不變。此類容許使用 null 元素。
2. HashSet 的實現
對於 HashSet 而言，它是基於 HashMap 實現的， HashSet 底層使用 HashMap 來保存全部元素，所以 HashSet 的實現比較簡單，相關 HashSet 的操做，基本上都是直接調用底層HashMap 的相關方法來完成， HashSet 的源代碼以下：
Java 代碼

public class HashSet<E>  extends AbstractSet<E>  
      implements Set<E>, Cloneable, java.io.Serializable  {  
      static final long serialVersionUID = -5024744406713321676L;  
      // 底層使用 HashMap 來保存 HashSet 中全部元素。  
      private transient HashMap<E,Object> map;          
      // 定義一個虛擬的 Object 對象做爲 HashMap 的 value，將此對象定義爲 static final。
   
      private static final Object PRESENT = new Object();      
      /** 
       * 默認的無參構造器，構造一個空的 HashSet。 
       *  
       * 實際底層會初始化一個空的 HashMap，並使用默認初始容量爲 16 和加載因子 0.75。 
       */  
      public HashSet() {  
      map = new HashMap<E,Object>();  
      }
/** 
       * 構造一個包含指定 collection 中的元素的新 set。 
       * 
       * 實際底層使用默認的加載因子 0.75 和足以包含指定 
       * collection 中全部元素的初始容量來建立一個 HashMap。 
       * @param c 其中的元素將存放在此 set 中的 collection。 
       */  
      public HashSet(Collection<? extends E> c) {  
      map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));  
      addAll(c);  
      }  
    
      /** 
       * 以指定的 initialCapacity 和 loadFactor 構造一個空的 HashSet。 
       * 
       * 實際底層以相應的參數構造一個空的 HashMap。 
       * @param initialCapacity 初始容量。 
       * @param loadFactor 加載因子。 
       */  
      public HashSet(int initialCapacity, float loadFactor) {  
      map = new HashMap<E,Object>(initialCapacity, loadFactor);  
      }  
      /** 
       * 以指定的 initialCapacity 構造一個空的 HashSet。 
       * 
       * 實際底層以相應的參數及加載因子 loadFactor 爲 0.75 構造一個空的 HashMap。 
       * @param initialCapacity 初始容量。 
       */  
      public HashSet(int initialCapacity) {  
      map = new HashMap<E,Object>(initialCapacity);  
      }  
      /** 
       * 以指定的 initialCapacity 和 loadFactor 構造一個新的空連接哈希集合。 
       * 此構造函數爲包訪問權限，不對外公開，實際只是是對 LinkedHashSet 的支持。 
       * 
       * 實際底層會以指定的參數構造一個空 LinkedHashMap 實例來實現。 
       * @param initialCapacity 初始容量。 
       * @param loadFactor 加載因子。 
       * @param dummy 標記。 
       */  
      HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
      map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
      }  
      /** 
       * 返回對此 set 中元素進行迭代的迭代器。返回元素的順序並非特定的。 
       *  
       * 底層實際調用底層 HashMap 的 keySet 來返回全部的 key。 
       * 可見 HashSet 中的元素，只是存放在了底層 HashMap 的 key 上， 
       * value 使用一個 static final 的 Object 對象標識。 
       * @return 對此 set 中元素進行迭代的 Iterator。 
       */  
      public Iterator<E> iterator() {  
      return map.keySet().iterator();  
      }  
      /** 
       * 返回此 set 中的元素的數量（set 的容量）。 
       * 
       * 底層實際調用 HashMap 的 size()方法返回 Entry 的數量，就獲得該 Set 中元素的個數。  
       * @return 此 set 中的元素的數量（set 的容量）。 
       */  
      public int size() {  
      return map.size();  
      }  
      /** 
       * 若是此 set 不包含任何元素，則返回 true。 
       * 
       * 底層實際調用 HashMap 的 isEmpty()判斷該 HashSet 是否爲空。 
       * @return 若是此 set 不包含任何元素，則返回 true。 
       */  
      public boolean isEmpty() {  
      return map.isEmpty();  
      }  
      /** 
       * 若是此 set 包含指定元素，則返回 true。 
       * 更確切地講，當且僅當此 set 包含一個知足(o==null ? e==null : o.equals(e)) 
       * 的 e 元素時，返回 true。 
       * 
       * 底層實際調用 HashMap 的 containsKey 判斷是否包含指定 key。 
       * @param o 在此 set 中的存在已獲得測試的元素。 
       * @return 若是此 set 包含指定元素，則返回 true。 
       */  
      public boolean contains(Object o) {
      return map.containsKey(o);  
      }  
      /** 
       * 若是此 set 中還沒有包含指定元素，則添加指定元素。 
       * 更確切地講，若是此 set 沒有包含知足(e==null ? e2==null : e.equals(e2)) 
       * 的元素 e2，則向此 set 添加指定的元素 e。 
       * 若是此 set 已包含該元素，則該調用不更改 set 並返回 false。 
       * 
       * 底層實際將將該元素做爲 key 放入 HashMap。 
       * 因爲 HashMap 的 put()方法添加 key-value 對時，當新放入 HashMap 的 Entry 中 key 
       * 與集合中原有 Entry 的 key 相同（hashCode()返回值相等，經過 equals 比較也返回 t
rue）， 
       * 新添加的 Entry 的 value 會將覆蓋原來 Entry 的 value，但 key 不會有任何改變， 
       * 所以若是向 HashSet 中添加一個已經存在的元素時，新添加的集合元素將不會被放入 HashMap 中， 
       * 原來的元素也不會有任何改變，這也就知足了 Set 中元素不重複的特性。 
       * @param e 將添加到此 set 中的元素。 
       * @return 若是此 set 還沒有包含指定元素，則返回 true。 
       */  
      public boolean add(E e) {  
      return map.put(e, PRESENT)==null;  
      }  
     /** 
       * 若是指定元素存在於此 set 中，則將其移除。 
       * 更確切地講，若是此 set 包含一個知足(o==null ? e==null : o.equals(e))的元素
e， 
       * 則將其移除。若是此 set 已包含該元素，則返回 true 
       *  （或者：若是此 set 因調用而發生更改，則返回 true）。（一旦調用返回，則此 set 再也不
包含該元素）。 
       * 
       * 底層實際調用 HashMap 的 remove 方法刪除指定 Entry。 
       * @param o 若是存在於此 set 中則須要將其移除的對象。 
       * @return 若是 set 包含指定元素，則返回 true。 
       */  
      public boolean remove(Object o) {  
      return map.remove(o)==PRESENT;  
      }  
      /** 
       * 今後 set 中移除全部元素。此調用返回後，該 set 將爲空。 
       * 
       * 底層實際調用 HashMap 的 clear 方法清空 Entry 中全部元素。
       */  
      public void clear() {  
      map.clear();  
      }  
    
      /** 
       * 返回此 HashSet 實例的淺表副本：並無複製這些元素自己。 
       * 
       * 底層實際調用 HashMap 的 clone()方法，獲取 HashMap 的淺表副本，並設置到 HashSe
t 中。 
       */  
      public Object clone() {  
          try {  
              HashSet<E> newSet = (HashSet<E>) super.clone();  
              newSet.map = (HashMap<E, Object>) map.clone();  
              return newSet;  
          } catch (CloneNotSupportedException e) {  
              throw new InternalError();  
          }  
      }  
}

3.  相關說明
1) 相關 HashMap 的實現原理，請參考個人上一遍總結：深刻 Java 集合學習系列：HashMap 的實現原理。
2) 對於 HashSet 中保存的對象，請注意正確重寫其 equals 和 hashCode 方法，以保證放入的對象的惟一性。