在寫這篇部落格之前，本人已經介紹了HashMap（HashMap內部儲存實現及HashTable比較）、LinkedHashMap（LinkedHashMap內部實現）、TreeMap（TreeMap內部實現簡介）。考慮到即將介紹的三種Set型別是基於上述Map型別的，於是直接歸納其關聯，這樣簡潔明瞭。

1、HashSet繼承AbstractSet類，實現了Set等介面，但最重要的是HashSet是基於HashMap來實現的。先看建構函式：

/**
         * 預設建構函式
         * 初始化一個空的HashMap，並使用預設初始容量為16和載入因子0.75。
         */
        public HashSet() {
            map = new HashMap<>();
        }

        /**
         * 構造一個包含指定 collection 中的元素的新 set。
         */
        public HashSet(Collection<? extends E> c) {
            map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
            addAll(c);
        }

        /**
         * 構造一個新的空 set，其底層 HashMap 例項具有指定的初始容量和指定的載入因子
         */
        public HashSet(int initialCapacity, float loadFactor) {
            map = new HashMap<>(initialCapacity, loadFactor);
        }

        /**
         * 構造一個新的空 set，其底層 HashMap 例項具有指定的初始容量和預設的載入因子（0.75）。
         */
        public HashSet(int initialCapacity) {
           map = new HashMap<>(initialCapacity);
        }

        /**
         * 以指定的initialCapacity和loadFactor構造一個新的空連結雜湊集合。
         * dummy 為標識 該建構函式主要作用是對LinkedHashSet起到一個支援作用
         */
        HashSet(int initialCapacity, float loadFactor, boolean dummy) {
           map = new LinkedHashMap<>(initialCapacity, loadFactor);
        }
 

/** 
     * 返回對此set中元素進行迭代的迭代器。返回元素的順序並不是特定的。 
     * @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比較也返回true）， 
     * 新新增的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的淺表副本，並設定到HashSet中。 
     */  
    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();  
        }  
    }  
}
 

2、LinkedHashSet

LinkedHashSet繼承了HashSet，又基於LinkedHashMap來實現。LinkedHashSet底層使用LinkedHashMap的key來儲存所有元素，從而維護著一個運行於所有元素的雙向連結串列。該雙向連結串列定義了迭代順序，該順序分為插入順序和訪問順序（具體請看：LinkedHashMap內部實現）。因為它繼承了父類HashSet，所以它的所有操作方法都與HashSet相同，直接呼叫父類的方法即可。其中，HashSet還專為LinkedHashSet提供了構造方法，由於包訪問許可權，並未對外公開。程式碼如下：

/** 
     * 以指定的initialCapacity和loadFactor構造一個新的空連結雜湊集合。  
     * 
     * 實際底層會以指定的引數構造一個空LinkedHashMap例項來實現。 
     * @param initialCapacity 初始容量。 
     * @param loadFactor 載入因子。 
     * @param dummy 標記。 
     */  
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
    map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);  
    }  
 

TreeSet繼承自AbstractSet，又基於TreeMap實現，因為TreeSet底層使用一個TreeMap，它的元素儲存在TreeMap的key中，保證了不可重複性。同時，TreeSet中的元素也是排好序的，操作的時間複雜度也與TreeMap相同。與HashSet類似的是，TreeSet的大部分方法也是直接呼叫TreeMap中的方法。（關於TreeMap，請看：TreeMap內部實現）。其中，TreeSet的建構函式程式碼如下所示：

public class TreeSet<E> extends AbstractSet<E> 
    implements NavigableSet<E>, Cloneable, java.io.Serializable 
 { 
    // 使用 NavigableMap 的 key 來儲存 Set 集合的元素
    private transient NavigableMap<E,Object> m; 
    // 使用一個 PRESENT 作為 Map 集合的所有 value。
    private static final Object PRESENT = new Object(); 
    // 包訪問許可權的構造器，以指定的 NavigableMap 物件建立 Set 集合
    TreeSet(NavigableMap<E,Object> m) 
    { 
        this.m = m; 
    } 
    public TreeSet()                                      // 預設建構函式
    { 
        // 以自然排序方式建立一個新的 TreeMap，
        // 根據該 TreeSet 建立一個 TreeSet，
        // 使用該 TreeMap 的 key 來儲存 Set 集合的元素
        this(new TreeMap<E,Object>()); 
    } 
    public TreeSet(Comparator<? super E> comparator) 
    { 
        // 以定製排序方式建立一個新的 TreeMap，
        // 根據該 TreeSet 建立一個 TreeSet，
        // 使用該 TreeMap 的 key 來儲存 Set 集合的元素
        this(new TreeMap<E,Object>(comparator)); 
    } 
    public TreeSet(Collection<? extends E> c) 
    { 
        // 呼叫預設建構函式建立一個 TreeSet，底層以 TreeMap 儲存集合元素
        this(); 
        // 向 TreeSet 中新增 Collection 集合 c 裡的所有元素
        addAll(c); 
    } 
    public TreeSet(SortedSet<E> s) 
    { 
        //呼叫含有比較器引數的建構函式
        this(s.comparator()); 
        // 向 TreeSet 中新增 SortedSet 集合 s 裡的所有元素
        addAll(s); 
    } 
    //TreeSet 的其他方法都只是直接呼叫 TreeMap 的方法來提供實現
    ... 
}