Set集合详解(参照源码)

打开jdk1.8官方文档：

public interface Set<E> extends Collection<E> {
}
public interface Collection<E> extends Iterable<E> {
}

Set接口继承了Collection接口，和List一样是Collection接口的子类。
Set集合的特点：

1. 无序；存放的顺序和取出的顺序不同
2. 不能存放重复元素
3. 只能存放一个null值

主要实现类：

• HashSet
• TreeSet
  HashSet详解
  源码均来自于JDK1.8

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;
	private static final Object PRESENT = new Object();
    private transient HashMap<E,Object> map;
	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 boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }
}

构造方法解析
根据源码发现：其实HashSet里面维护了一个HashMap。
想要了解HashMap可以参照我的另一篇博客：HashMap详解
当调用默认构造函数的时候就直接给维护的HashMap进行new(内部调用了HashMap的构造方法，就是进行初始化操作，默认初始容量是16)；调用构造函数参数是Collection集合类的时候，就是初始化map的容量，并将集合类里面的数调用add方法添加到map中；当构造函数参数是int的一个参数时，就初始化
HashMap的时候传入int参数即可(参数是初始容量)；当构造函数是一个int，一个float的时候，就是初始化HashMap的时候传入即可(int是初始容量，float是加载因子)。

	public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

其他方法解析
add方法：可以看到底层调用的是HashMap的put方法。传入的key是要保存的值和一个维护的固定value；其实HashMap就是用key的扰动方法找到要存放的位置，利用节点存储。
remove方法：可以看到底层调用的是HashMap的remove方法；HashMap底层分为两部分，先找到要删除的位置，在删除。
HashSet特点：不能存放重复值，只能有存放一个null值。(底层利用了HashMap的key不能重复的原因)

TreeSet详解
源码均来自于JDK1.8

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable
{
    /**
     * The backing map.
     */
    private transient NavigableMap<E,Object> m;

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

    /**
     * Constructs a set backed by the specified navigable map.
     */
    TreeSet(NavigableMap<E,Object> m) {
        this.m = m;
    }
	public TreeSet() {
        this(new TreeMap<>());
    }
	public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }
    public TreeSet(Collection<? extends E> c) {
        this();
        addAll(c);
    }
    public TreeSet(SortedSet<E> s) {
        this(s.comparator());
        addAll(s);
    }
}
public interface NavigableMap<K,V> extends SortedMap<K,V> {
}
public interface SortedMap<K,V> extends Map<K,V> {
	Comparator<? super K> comparator();
}

构造方法解析
参照源码发现：TreeSet里面维护了一个NavigableMap，也是Map的一个子类，当调用默认构造方法的时候，调用了一个传入NavigableMap参数的构造方法，内部进行给维护的NavigableMap进行赋值操作；当调用参数是comparator的构造方法的时候，内部调用了一个传入NavigableMap参数的构造方法，但是实际传入的是TreeMap，将comparator参数传入(当排序的时候按照自定义的comparator接口实现)；当调用参数是SortedMap的时候(NavigableMap是SortedMap的子类)，调用了一个传入NavigableMap参数的构造方法，并将内部元素添加到TreeSet中。

	public boolean add(E e) {
        return m.put(e, PRESENT)==null;
    }
    public boolean remove(Object o) {
        return m.remove(o)==PRESENT;
    }

其他方法解析
内部和HashSet类似，只不过维护的map对象不同，都是最终调用维护对象的添加删除方法。
TreeSet特点：查询快(因为底层存放的值是有序的)