从源码理解HashSet.java

package java.util;import java.io.InvalidObjectException;/** * HashSet实现了Set接口，背后由一个哈希表支持（事实上是一个HashMap实例）。 * 不保证元素迭代顺序，更不保证顺序不会随时间变化，允许空值null * HashSet提供常数时间的基本操作add,remove,contains和size，假设哈希函数能够把元素均匀分配在哈希槽中 * 全set的迭代则与HashSet实例的size与背后HashMap实例的capacity之和成比例，所以不要把初始容量设的太高 * HashSet是非同步的，如果多个线程同时访问一个哈希Set，而其中至少一个线程修改了该Set，那么必须保持外部同步。 * 通常可以通过对自然封装该set的对象执行同步操作，如果不存在这样的对象，应该： * Set s = Collections.synchronizedSet(new HashSet(...)); * HashSet通过iterator()返回的迭代器是fail-fast的：同步访问后果未定义 */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;//HashMap实例    // Map中将所有关键字都关联在同一个对象上    private static final Object PRESENT = new Object();    /**     * 构造方法1：构造一个空的set，背后的HashMap实例默认容量16，装载因子0.75     */    public HashSet() {        map = new HashMap<>();    }    /**     * 构造方法2：构造一个set，该set包含指定集合中的所有元素。HashMap的默认装载因子是0.75，初始容量以足够装下集合中所有元素为准     * @param c the collection whose elements are to be placed into this set     * @throws NullPointerException if the specified collection is null     */    public HashSet(Collection<? extends E> c) {        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));        addAll(c);    }    /**     * 构造方法3：构造一个空set，背后的HashMap实例拥有指定的初始容量和指定的装载因子     * @param      initialCapacity   the initial capacity of the hash map     * @param      loadFactor        the load factor of the hash map     * @throws     IllegalArgumentException if the initial capacity is less     *             than zero, or if the load factor is nonpositive     */    public HashSet(int initialCapacity, float loadFactor) {        map = new HashMap<>(initialCapacity, loadFactor);    }    /**     * 构造方法4：构造一个空set，背后的HashMap实例拥有指定的初始容量和默认的装载因子     * @param      initialCapacity   the initial capacity of the hash table     * @throws     IllegalArgumentException if the initial capacity is less     *             than zero     */    public HashSet(int initialCapacity) {        map = new HashMap<>(initialCapacity);    }    /**     * 构造方法5：构造一个空的链式哈希set。（这个包内私有构造方法仅供LinkedHashSet使用）     * 背后的HashMap实例是一个具有指定初始容量和指定装载因子的LinkedHashMap     * @param      initialCapacity   the initial capacity of the hash map     * @param      loadFactor        the load factor of the hash map     * @param      dummy             ignored (distinguishes this     *             constructor from other int, float constructor.)     * @throws     IllegalArgumentException if the initial capacity is less     *             than zero, or if the load factor is nonpositive     */    HashSet(int initialCapacity, float loadFactor, boolean dummy) {        map = new LinkedHashMap<>(initialCapacity, loadFactor);    }    /**     * 返回一个set内所有元素的迭代器。元素返回没有特定顺序     * @return an Iterator over the elements in this set     * @see ConcurrentModificationException     */    public Iterator<E> iterator() {        return map.keySet().iterator();    }    /**     * 返回set中元素个数     */    public int size() {        return map.size();    }    /**     * Returns <tt>true</tt> if this set contains no elements.     *     * @return <tt>true</tt> if this set contains no elements     */    public boolean isEmpty() {        return map.isEmpty();    }    /**     * 如果set中包含指定元素则返回true     * @param o element whose presence in this set is to be tested     * @return <tt>true</tt> if this set contains the specified element     */    public boolean contains(Object o) {        return map.containsKey(o);    }    /**     * 如果指定元素不存在，添加进set，返回true，如果已经存在，不作修改，返回false     * @param e element to be added to this set     * @return <tt>true</tt> if this set did not already contain the specified     * element     */    public boolean add(E e) {        return map.put(e, PRESENT)==null;    }    /**     * 如果存在则删除指定元素     * @param o object to be removed from this set, if present     * @return <tt>true</tt> if the set contained the specified element     */    public boolean remove(Object o) {        return map.remove(o)==PRESENT;    }    /**     * 清空set     */    public void clear() {        map.clear();    }    /**     * Returns a shallow copy of this <tt>HashSet</tt> instance: the elements     * themselves are not cloned.     *     * @return a shallow copy of this set     */    @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);        }    }    /**     * Save the state of this <tt>HashSet</tt> instance to a stream (that is,     * serialize it).     *     * @serialData The capacity of the backing <tt>HashMap</tt> instance     *             (int), and its load factor (float) are emitted, followed by     *             the size of the set (the number of elements it contains)     *             (int), followed by all of its elements (each an Object) in     *             no particular order.     */    private void writeObject(java.io.ObjectOutputStream s)        throws java.io.IOException {        // Write out any hidden serialization magic        s.defaultWriteObject();        // Write out HashMap capacity and load factor        s.writeInt(map.capacity());        s.writeFloat(map.loadFactor());        // Write out size        s.writeInt(map.size());        // Write out all elements in the proper order.        for (E e : map.keySet())            s.writeObject(e);    }    /**     * Reconstitute the <tt>HashSet</tt> instance from a stream (that is,     * deserialize it).     */    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);        }    }    /**     * Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>     * and <em>fail-fast</em> {@link Spliterator} over the elements in this     * set.     *     * <p>The {@code Spliterator} reports {@link Spliterator#SIZED} and     * {@link Spliterator#DISTINCT}.  Overriding implementations should document     * the reporting of additional characteristic values.     *     * @return a {@code Spliterator} over the elements in this set     * @since 1.8     */    public Spliterator<E> spliterator() {        return new HashMap.KeySpliterator<E,Object>(map, 0, -1, 0, 0);    }}