HashSet源码

​ HashSet实现了Set接口，其内部是通过持有一个HashMap的实例实现的。HashSet内部的元素是无序的，同时hashset允许存放为null的元素。HashSet不是线程安全的，因此多个线程并发的访问同一个hashset实例的时候可能会存在线程安全问题，需要在外部使用一定的锁同步机制。

声明

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    //代码
}

​ HashSet继承自AbstractSet，并实现了Set接口，这就意味着所有的Set接口中规定的方法，HashSet都给予了实现。

成员变量

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    //用于序列化和反序列化
    static final long serialVersionUID = -5024744406713321676L;

    //内部持有一个hashmap的实例
    private transient HashMap<E,Object> map;

    // 所有的key所对应的value都是这个present，这个跟redis的set还是不大一样的，
    //那个是set对应的值为null。
    private static final Object PRESENT = new Object();    
}

构造方法

/**
 * 构造一个空的hashmap，其底层的hashmap使用初始容量为16，负载因子为0.75来初始化
 */
public HashSet() 
{
    map = new HashMap<>();
}

/**
 * 如何设置初始容量：(想要设置的初始容量/0.75)+1就可以了
 * 这样可以尽量少的避免rehash操作的发生。
 * 调用其顶层父类的addAll添加到集合中，顶层类又调用了子类重写的add方法。
 * addAll方法后面再看，它是通过遍历c中元素然后调用add方法插入到当前的set中的
 */
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。
 */
public HashSet(int initialCapacity) 
{
    map = new HashMap<>(initialCapacity);
}

/**
 * 创建一个空的linked hash set ,底层使用LinkedHashMap实现（因为它是Hashmap的子类）。
 * dummy只是用来区分其他的构造方法的，该方法并不是public的，通常使用用于LinkedHashSet。
 */
HashSet(int initialCapacity, float loadFactor, boolean dummy)
{
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

​ 可以发现HashSet的初始化基本上就是对底层使用的HashMap的初始化。这就是HashSet的构造方法完成的工作。

迭代器相关

iterator方法

public Iterator<E> iterator() 
{
    return map.keySet().iterator();
}

常用的方法

获取信息

size方法

/**
 * 返回set中的key的数量
 */
public int size() 
{
    return map.size();
}

isEmpty方法

/**
 * 判断set是否为空
 */
public boolean isEmpty() 
{
    return map.isEmpty();
}

contains方法

/**
 * 判断集合中是否有给定的值
 */
public boolean contains(Object o) 
{
    return map.containsKey(o);
}

添加元素

add方法

/**
 * 将元素e添加到集合中，实际上是添加到持有的map中，值为present
 */
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

删除元素

remove方法

/**
 * 将元素从集合中删除
 */
public boolean remove(Object o) 
{
    return map.remove(o)==PRESENT;
}

clear方法

/**
 * 清空整个集合，实际是清空底层的map
 */
public void clear()
{
    map.clear();
}

其他方法

/**
 * 返回该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);
    }
}

序列化

/**
 * 保存hashset的状态到流中
 */
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
 */
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);

    // Constructing the backing map will lazily create an array when the first element is
    // added, so check it before construction. Call HashMap.tableSizeFor to compute the
    // actual allocation size. Check Map.Entry[].class since it's the nearest public type to
    // what is actually created.

    SharedSecrets.getJavaOISAccess()
        .checkArray(s, Map.Entry[].class, HashMap.tableSizeFor(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);
    }
}

java8新增API

public Spliterator<E> spliterator()
{
    return new HashMap.KeySpliterator<E,Object>(map, 0, -1, 0, 0);
}

写在最后

​ HashSet的实现非常的简单，整个代码才不过三百多行，HashSet实现的关键是其内部持有的HashMap的实例，其所有主要的方法基本上都委托给了底层的HashMap的实例来完成。另外需要注意的是HashSet的所有的key均指向一个公共的称为present的实例，而不是null。