认真研究Java集合之HashSet 的实现原理

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<>();
    }
  /*
     构造一个包含指定collection 中的元素的新set。
     实际底层使用默认的加载因子0.75 和足以包含指定
     collection 中所有元素的初始容量来创建一个HashMap。
     @param c 其中的元素将存放在此set 中的collection。
     */
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }
    /*
     以指定的initialCapacity 和loadFactor 构造一个空的HashSet。
     实际底层以相应的参数构造一个空的HashMap。
     */
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
     /*
     以指定的initialCapacity 构造一个空的HashSet。
     实际底层以相应的参数及加载因子loadFactor 为0.75 构造一个空的HashMap。
     */
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }
     /*
     以指定的initialCapacity 和loadFactor 构造一个新的空链接哈希集合。
     此构造函数为包访问权限，不对外公开，实际只是是对LinkedHashSet 的支持。
     实际底层会以指定的参数构造一个空LinkedHashMap 实例来实现。
     */
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(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 中元素的个数。
     */
    public int size() {
        return map.size();
    }
     /*
     如果此set 不包含任何元素，则返回true。
     底层实际调用HashMap 的isEmpty()判断该HashSet 是否为空。
     */
    public boolean isEmpty() {
        return map.isEmpty();
    }
     /*
     如果此set 包含指定元素，则返回true。
     更确切地讲，当且仅当此set 包含一个满足(o==null ? e==null : o.equals(e))的
     e 元素时，返回true。
     底层实际调用HashMap 的containsKey 判断是否包含指定key。
     */
    public boolean contains(Object o) {
        return map.containsKey(o);
    }

@SuppressWarnings("unchecked")
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);
    }
}

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // Read in any hidden serialization magic
    s.defaultReadObject();
    // Read capacity and verify non-negative.
    int capacity = s.readInt();
    if (capacity < 0) {
        throw new InvalidObjectException("Illegal capacity: " +
                                         capacity);
    }
    // Read load factor and verify positive and non NaN.
    float loadFactor = s.readFloat();
    if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
        throw new InvalidObjectException("Illegal load factor: " +
                                         loadFactor);
    }
    // Read size and verify non-negative.
    int size = s.readInt();
    if (size < 0) {
        throw new InvalidObjectException("Illegal size: " +
                                         size);
    }
    // Set the capacity according to the size and load factor ensuring that
    // the HashMap is at least 25% full but clamping to maximum capacity.
    capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f),
            HashMap.MAXIMUM_CAPACITY);
    // Create backing HashMap
    map = (((HashSet<?>)this) instanceof LinkedHashSet ?
           new LinkedHashMap<E,Object>(capacity, loadFactor) :
           new HashMap<E,Object>(capacity, loadFactor));
    // Read in all elements in the proper order.
    for (int i=0; i<size; i++) {
        @SuppressWarnings("unchecked")
            E e = (E) s.readObject();
        map.put(e, PRESENT);
    }
}