Java-Collection源碼分析（十二）——Set、AbstractSet、HashSet和LinkedHashSet

一、set的集合框架

二、Set接口

Set接口除了從Collection接口繼承之外，還添加了所有構造函數的約定以及add，equals和hashCode方法的約定。

public interface Set<E> extends Collection<E> {
    //返回此集合中的元素數（其基數）。
    int size();
    //如果此集合不包含元素，則返回true。
    boolean isEmpty();
    //如果此集合包含指定的元素，則返回true。
    boolean contains(Object o);
    //返回此集合中元素的迭代器。
    Iterator<E> iterator();
    //返回一個包含此集合中所有元素的數組。
    Object[] toArray();
    //返回一個包含此集合中所有元素的數組; 返回的數組的運行時類型是指定數組的運行時類型。
    <T> T[] toArray(T[] a);
    //將指定的元素添加到此集合（如果尚未存在）（可選操作）。
    boolean add(E e);
    //如果存在，則從該集合中刪除指定的元素（可選操作）。
    boolean remove(Object o);
    //如果此集合包含指定集合的所有元素，則返回true。
    boolean containsAll(Collection<?> c);
    //將指定集合中的所有元素添加到此集合（如果尚未存在）（可選操作）。
    boolean addAll(Collection<? extends E> c);
    //僅保留該集合中包含在指定集合中的元素（可選操作）。
    boolean retainAll(Collection<?> c);
    //從此集合中刪除指定集合中包含的所有元素（可選操作）。
    boolean removeAll(Collection<?> c);
    //從此集合中刪除所有元素（可選操作）。
    void clear();
    //將指定的對象與此集合進行比較以實現相等。
    boolean equals(Object o);
    //返回此集合的哈希碼值。
    int hashCode();
    //在此集合中的元素上創建一個Spliterator。
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.DISTINCT);
    }
}

三、AbstractSet抽象類

該類提供了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);
    }
}

五、LinkedHashSet

Linked主要是繼承了父類中的 HashSet(int initialCapacity, float loadFactor, boolean dummy) 方法，來建立一個LinkedHashMap，來實現功能。

public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = -2851667679971038690L;

    //構造一個具有指定的初始容量和負載因子的新的，空的鏈接散列集。
    public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);
    }

    //構造具有指定的初始容量和默認負載因子（0.75）的新的，空的鏈接散列集。
    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }

    //構造一個具有默認初始容量（16）和負載因子（0.75）的新的，空的鏈接散列集。
    public LinkedHashSet() {
        super(16, .75f, true);
    }

    //構造與指定集合相同的元素的新的鏈接散列集。
    public LinkedHashSet(Collection<? extends E> c) {
        super(Math.max(2*c.size(), 11), .75f, true);
        addAll(c);
    }

    public Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.DISTINCT | Spliterator.ORDERED);
    }
}