JDK源码之HashSet分析

1. HashSet简介

• 集合中元素是唯一的
• 集合中元素是无序的
• HashSet本质上是使用了HashMap，并将键值对中的值置为一个固定值，只使用键，起到了无序唯一的作用
• HashSet没有提供get()方法，和HashMap是一样的，因为内部是无序的，所以只能通过迭代的方式获得

2. 继承体系

• 继承了AbstractSet，该类实现了大量Set接口的方法，以减少HashSet实现Set接口的工作量
• 实现了Set接口，标志元素是无序的，且不允许重复
• 实现了Cloneable接口，具备了克隆的功能
• 实现了Serializable接口，具备了序列化和反序列化的功能

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

3. 成员变量

//HashSet内部本质是一个HashMap
private transient HashMap<E,Object> map;

//HashSet实际只用了键值对中的键，将值统一设为PRESENT（也就是说HashSet底层的值都是一样的PRESENT）
private static final Object PRESENT = new Object();

//序列化版本号
static final long serialVersionUID = -5024744406713321676L;

4. 构造方法

//无参的构造方法，本质还是调用HashMap的构造方法,会使用默认初始容量16和负载因子0.75
public HashSet() {
        map = new HashMap<>();
    }

//传入一个集合的构造方法
public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

//指定初始容量和负载因子的构造方法
public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }

//指定初始容量的构造方法
public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

//这个方法没有用public修饰，只允许在同一个包中访问，实际上只是对LinkedHashSet的支持
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

5. 成员方法

iterator()

//返回HashSet的迭代器，本质是返回键值对中的键的迭代器
public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

size()

//返回存储的元素数量
public int size() {
        return map.size();
    }

isEmpty()

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

contains(Object o)

//判断是否包含元素o
//底层实际是调用HashMap的判断是否存在指定的键的方法
public boolean contains(Object o) {
        return map.containsKey(o);
    }

add(E e)

//向HashSet中添加元素,本质是调用HashMap的put方法
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

remove(Object o)

//移除HashSet中的元素o，本质是调用HashMap的remove方法删除底层的键值对
public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

clear()

//清空HashSet，本质是调用HashMap的remove方法清空底层HashMap
public void clear() {
        map.clear();
    }

clone()

//克隆方法，本质是调用HashMap的clone方法
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 writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // Write out any hidden serialization magic
        s.defaultWriteObject();	//写出非static和非transient属性

        // 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())		//将HashSet中的元素一个一个写出
            s.writeObject(e);
    }

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();			//读入非static和非transient和属性

        // Read capacity and verify non-negative.
        int capacity = s.readInt();
        if (capacity < 0) {				//读入容量，并检查不能小于0
            throw new InvalidObjectException("Illegal capacity: " +
                                             capacity);
        }

        // Read load factor and verify positive and non NaN.
        float loadFactor = s.readFloat();//读入负载因子，并检查负载因子不能为0或为NaN
        if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
            throw new InvalidObjectException("Illegal load factor: " +
                                             loadFactor);
        }

        // Read size and verify non-negative.
        int size = s.readInt();				//读入元素个数并且不能小于0
        if (size < 0) {
            throw new InvalidObjectException("Illegal size: " +
                                             size);
        }
        //根据元素个数重新设置容量
        capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f),
                HashMap.MAXIMUM_CAPACITY);


        SharedSecrets.getJavaOISAccess()
                     .checkArray(s, Map.Entry[].class, HashMap.tableSizeFor(capacity));

        // Create backing HashMap
        //创建Map，检查是不是LinkedHashMap类型的
        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.
        //读入所有元素，并放入Map中
        for (int i=0; i<size; i++) {
            @SuppressWarnings("unchecked")
                E e = (E) s.readObject();
            map.put(e, PRESENT);
        }
    }

总结

• HashSet内部是使用HashMap的键来存储的，以此来保证元素不重复
• HashMap中的键是无序的，因此HashSet中的值也是无序的
• HashSe允许存储null值，但只允许有一个null值
• HashSet不是线程安全的
• HashSet没有get()方法，只能通过迭代方式获取