Java-HashSet源码

package java.util;

import java.io.InvalidObjectException;

/**
 * HashSet继承了AbstractSet类，实现了Set接口，由Hash表支持(实际上就是一个HashMap的实例)。HashSet不保证该类中
 * set的遍历顺序，也并不保证set中数据顺序的永久不变。HashSet允许存储空值，如果有空值，有且仅有一个。
 * 注意，Hashset没有实现同步，即不是线程安全的，如果多个线程同时访问一个哈希集合，并且至少有一个线程修改的话，
 * 必须要在外部进行同步；这通常是通过对自然封装该set的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSet 方法来封装set。最好在创建时完成这一操作，以防止对该set进行意外的不同步访问：
 * Set s = Collections.synchronizedSet(new HashSet(...));
 * <p>
 * 注意Hash Set的remove操作，如果在遍历的时候进行删除操作，可能会发生ConcurrentModificationException异常；
 * 所以进行remove的时候，尽量使用Hashset自己的迭代器进行删除，即Iterator；在并发修改的情况下，迭代器将会很快失败；
 */

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;
    
    // HashSet的底层是通过HashMap来实现的，并且该HashMap字段是transient类型的， 无法序列化
    private transient HashMap<E,Object> map;

    /**
     * 定义该HashMap的value为一个静态无法被修改的虚拟值，因为HashSet中只需要用到key，而HashMap是key-value键值对.所以，向map中添加键值对时，键值对的值固定是PRESENT
     */
    private static final Object PRESENT = new Object();

    /**
     * 默认构造函数，底层初始化一个HashMap，hashMap的初始容量是16，负载因子是0.75
     */
    public HashSet() {
        map = new HashMap<>();
    }

  /**
     * 集合转换为HashSet的构造函数, 分为两步操作：
     * 
     * 1. 返回(c.size()/.75f) + 1 和 16两者比较大的数字，为什么呢？
     * 因为HashMap的默认初始容量是16，而负载因子是0.75，HashMap什么时候会扩容呢，是当HashMap
     * 的阈值即(初始容量*负载因子) 大于HashMap实际大小的时候，HashMap就会扩容，所以(c.size()/.75f) +1即是实际的大小；
     * 
     * 2. 将集合c的元素全部添加到HashSet中；
     * 
     * 如果参数c为null，将会抛出空指针异常；
     */
    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

   /**
     * 构造一个指定容量和负载因子的hashMap,
     * 如果初始容量或者负载因子小于0，则抛出IllegalArgumentException异常
     */
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }

    /**
     * 构造一个指定容量的HashMap,默认负载因子是0.75
     * 如果初始容量小于0，则抛出IllegalArgumentException异常
     */
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

  /**
     * 构造一个置顶容量和负载因子的HashSet，使用LinkedHashMap实现，这个方法不对外，只是应用于 LinkedHashSet 。
     * 其中参数dummy无实际意义，只是一个标志而已，请忽略。
     */
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

    /**
     * 返回迭代器，使用HashMap的keySet方法来返回，这也验证了HashSet的值确实只存放在了HashMap的key上
     */
    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

    /**
     * 大小也是通过HashMap的size方法
     */
    public int size() {
        return map.size();
    }

   /**
     * 判断是否为空，也是通过HashMap的isEmpty方法来判断
     */
    public boolean isEmpty() {
        return map.isEmpty();
    }

    /**
     * 如果HashSet包含某一个元素，则返回true
     * 更确切的讲，当且仅当HashSet满足Objects.equals方法的时候才返回true；
     * Objects是JDK1.7新增的类，用来完善Object的相关方法，比如equals的时候避免空指针异常等，全是static方法；
     * 同样，底层是通过HashMap的containsKey来实现的；
     */
    public boolean contains(Object o) {
        return map.containsKey(o);
    }

    /**
     * 如果HashSet没有指定元素，则添加这个指定元素。
     * 更确切的讲，是没有满足Objects.equals方法的元素，再添加。如果已经有了，则返回false；
     */
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

     /**
     * 如果HashSet中有指定元素，则删除。更确切的讲，是有满足Objects.equals方法的元素。
     * 如果HashSet包含该元素，则返回true 。或者，如果此set因调用而发生更改，则返回true
     */
    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

    /**
     * 调用HashMap的clear方法清空
     */
    public void clear() {
        map.clear();
    }

  /**
     * 浅复制操作，调用HashMap的clone方法来实现
     */
    @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);
        }
    }

    /**
     * 序列化私有写入方法，将HashSet总的容量，负载因子，实际容量，元素写入输出流ObjectOutputStream中，JVM序列化时通过反射调用
     */
    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);
    }

    /**
     * 反序列化私有读取方法，将HashSet总的容量，负载因子，实际容量，元素通过ObjectInputStream流依次读取，同样，JVM反射调用；
     */
    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<>(capacity, loadFactor) :
               new HashMap<>(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);
        }
    }

   /**
     * JDK1.8新增的方法，返回迭代器，但该迭代器并不是原先那种单线程访问的，而是属于一种分割的迭代器，即可以通过多线程
     * 并行的形式访问元素；
     */
    public Spliterator<E> spliterator() {
        return new HashMap.KeySpliterator<>(map, 0, -1, 0, 0);
    }
}