該類提供了Set介面的骨架實現，以最大限度地減少實現此介面所需的工作量。

通過擴充套件此類來實現集合的過程與通過擴充套件AbstractCollection實現集合的過程相同，除了此類的子類中的所有方法和建構函式都必須遵守由Set介面施加的附加約束（例如，新增方法不能允許將一個物件的多個例項新增到集合中）。

請注意，此類沒有覆蓋AbstractCollection類中的任何實現。它只是為equals和hashCode添加了實現。

public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {
    protected AbstractSet() {
    }
    //將指定的物件與此set進行比較以實現相等。 如果給定的物件也是一個set，則返回true，兩個set的大小相同，給定set的每個成員都包含在該set中。 這確保了equals方法在Set介面的不同實現中正常工作。
    //這個實現首先檢查指定的物件是否是該set; 如果是，則返回true。 然後，它檢查指定的物件是否是與該set的大小相同的set; 如果沒有，則返回false。 如果是這樣，它返回containsAll（（Collection）o）。
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof Set))
            return false;
        Collection<?> c = (Collection<?>) o;
        if (c.size() != size())
            return false;
        try {
            return containsAll(c);
        } catch (ClassCastException unused)   {
            return false;
        } catch (NullPointerException unused) {
            return false;
        }
    }
    //返回此set的雜湊碼值。 set的雜湊碼被定義為set中的元素的雜湊碼的和，其中空元素的雜湊碼被定義為零。 
    //這確保s1.equals（s2）意味著任何兩個set 中s1和s2的s1.hashCode（）== s2.hashCode（），如Object.hashCode（）的一般合同所要求的。
    //該實現遍歷set，在set中的每個元素上呼叫hashCode方法，並將結果相加。
    public int hashCode() {
        int h = 0;
        Iterator<E> i = iterator();
        while (i.hasNext()) {
            E obj = i.next();
            if (obj != null)
                h += obj.hashCode();
        }
        return h;
    }
    //從此set中刪除指定set中包含的所有元素（可選操作）。如果指定的collection也是一個set，則該操作有效地修改該set，使得其值是兩組的非對稱set差異。
    //該實現通過呼叫每個方法的size方法來確定該set和指定collection的哪一個。如果此set具有較少的元素，則該實現將遍歷此set，依次檢查迭代器返回的每個元素，以檢視它是否包含在指定的collection中。如果包含，它將使用迭代器的remove方法從該set中刪除。如果指定的collection具有較少的元素，則實現將遍歷指定的collection，從該set中刪除迭代器返回的每個元素，使用該set的remove方法。
    //總之就是將小的set的元素從大的set裡面刪除
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        if (size() > c.size()) {
            for (Iterator<?> i = c.iterator(); i.hasNext(); ) //此處定義i為collection的迭代器
                modified |= remove(i.next());
        } else {
            for (Iterator<?> i = iterator(); i.hasNext(); ) { //此處定義i為set的迭代器
                if (c.contains(i.next())) {
                    i.remove();
                    modified = true;
                }
            }
        }
        return modified;
    }
}
 

四、HashSet

通俗一點將HashSet借了HashMap的殼下了自己的蛋，HashSet將元素作為HashMap的key，然後呼叫HashMap中的方法進行操作。

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;
    private transient HashMap<E,Object> map;
    //與支援map中的物件相關聯的虛擬值
    private static final Object PRESENT = new Object();

    //構造一個新的，空的集合; 支援HashMap例項具有預設初始容量（16）和負載因子（0.75）。
    public HashSet() {
        map = new HashMap<>();
    }

    //構造一個包含指定集合中的元素的新集合。 
    //HashMap以預設負載因子（0.75）建立，初始容量足以包含指定集合中的元素。
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

    //構造一個新的，空的集合; 支援HashMap例項具有指定的初始容量和指定的負載因子。
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }

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

    //構造一個新的，空的連結雜湊集。 （此包私有建構函式僅由LinkedHashSet使用。）
    //字尾HashMap例項是具有指定初始容量和指定負載因子的LinkedHashMap。
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

    //返回此集合中元素的迭代器。 元素沒有特定的順序返回。
    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

    //返回此集合中的元素數（其基數）。
    public int size() {
        return map.size();
    }

    //如果此集合不包含元素，則返回true
    public boolean isEmpty() {
        return map.isEmpty();
    }

    //如果此集合包含指定的元素，則返回true。 
    //更正式地，當且僅當這個集合包含元素e使得（o == null？e == null：o.equals（e））時，才返回true。
    public boolean contains(Object o) {
        return map.containsKey(o);
    }

    //將指定的元素新增到此集合（如果尚未存在）。 更正式地，如果該集合不包含元素e2（e == null？e2 == null：e.equals（e2）），
    //則將指定的元素e新增到此集合中。 如果該集合已經包含該元素，則該呼叫將保留該集合並返回false。
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

    //如果存在，則從該集合中刪除指定的元素。 更正式地，刪除元素e，使得（o == null？e == null：o.equals（e）），如果此集合包含這樣的元素。
    //如果此集合包含元素（或等效地，如果此集合由於呼叫而更改），則返回true。 （一旦呼叫返回，此集合將不包含該元素。）
    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

    //從該集合中刪除所有元素。 此通話返回後，該設定將為空。
    public void clear() {
        map.clear();
    }

    //返回此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(e);
        }
    }

    //將這個HashSet例項的狀態儲存到一個流（即序列化它）。
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        //寫出任何隱藏的序列化魔法
        s.defaultWriteObject();

        //寫出HashMap容量和負載因子
        s.writeInt(map.capacity());
        s.writeFloat(map.loadFactor());

        //寫出大小
        s.writeInt(map.size());

        //按正確的順序寫出所有元素。
        for (E e : map.keySet())
            s.writeObject(e);
    }

    //從流中重構HashSet例項（即反序列化它）。
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        //閱讀任何隱藏的序列化魔法
        s.defaultReadObject();

        //讀取容量並驗證非負數。
        int capacity = s.readInt();
        if (capacity < 0) {
            throw new InvalidObjectException("Illegal capacity: " +
                                             capacity);
        }

        //讀取負載因子並驗證正和非NaN。
        float loadFactor = s.readFloat();
        if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
            throw new InvalidObjectException("Illegal load factor: " +
                                             loadFactor);
        }

        //讀取大小並驗證非負數。
        int size = s.readInt();
        if (size < 0) {
            throw new InvalidObjectException("Illegal size: " +
                                             size);
        }

        //根據大小和負載因子設定容量，確保HashMap至少滿25％，但要鉗位到最大容量。
        capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f),
                HashMap.MAXIMUM_CAPACITY);

        //建立支援HashMap
        map = (((HashSet<?>)this) instanceof LinkedHashSet ?
               new LinkedHashMap<E,Object>(capacity, loadFactor) :
               new HashMap<E,Object>(capacity, loadFactor));

        //以正確的順序讀入所有元素。
        for (int i=0; i<size; i++) {
            @SuppressWarnings("unchecked")
                E e = (E) s.readObject();
            map.put(e, PRESENT);
        }
    }

    //在此集合中的元素上建立一個後期繫結和故障切換的Spliterator。
    //Spliterator報告了Spliterator.SIZED和Spliterator.DISTINCT。 覆蓋實現應記錄其他特徵值的報告。
    public Spliterator<E> spliterator() {
        return new HashMap.KeySpliterator<E,Object>(map, 0, -1, 0, 0);
    }
}