Java集合之Set、HashSet、LinkedHashSet和TreeSet深度解析

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

Set set = Collections.synchronizedSet(new HashSet(...));

public HashSet()

public HashSet(int initialCapacity)

public HashSet(int initialCapacity, float loadFactor)

public boolean add(E e)

public void clear()

public boolean contains(Object o)

public boolean isEmpty()

public Iterator<E> iterator()

public boolean remove(Object o)

public int size()

    //HashSet集合中的内容是通过HashMap数据结构来存储的
    private transient HashMap<E,Object> map;
    //向HashSet中添加数据，数据在上面的map结构是作为key存在的，而value统一都是
    //PRESENT，这样做是因为Set只使用到了HashMap的key，所以此处定义一个静态的常
    //量Object类，来充当HashMap的value
    private static final Object PRESENT = new Object();

    //直接 new 一个HashMap对象出来，采用无参的 HashMap 构造函数，
    //HashMap对象具有默认初始容量（16）和加载因子（0.75）
    public HashSet() {
        map = new HashMap<>();
    }

//指定初始容量和加载因子，创建HashMap实例
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }

//指定初始容量，创建HashMap
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

//以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。 
    //此构造函数为包访问权限，不对外公开，实际只是对LinkedHashSet的支持。 
    //实际底层会以指定的参数构造一个空LinkedHashMap实例来实现。 
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

//将 e 作为 key，PRESENT 作为 value 插入到 map 集合中，如果 e 
	//不存在，则插入成功返回 true;如果存在，则返回false
	//本质上是调用HashMap的put方法来实现的
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

//删除成功返回 true，删除的元素不存在会返回 false
	//本质上是调用HashMap的remove方法来实现的
    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

//调用 HashMap 的 containsKey(Object o) 方法，找到了返回 true，找不到返回 false
	//因为HashSet的本质上是用HashMap来存储元素的，HashSet的值是HashMap中的key，所以
	//此处调用了HashMap的containsKey方法来判断
    public boolean contains(Object o) {
        return map.containsKey(o);
    }

//清空集合
    public void clear() {
        map.clear();
    }
	//判断是否为空
    public boolean isEmpty() {
        return map.isEmpty();
    }
	//获取集合元素个数
    public int size() {
        return map.size();
    }

//因为HashSet的本质上是用HashMap来存储元素的，HashSet的值是HashMap中的key，所以
	//此处调用了HashMap的keySet方法来遍历HashSet中的元素
    public Iterator<E> iterator() {
        return map.keySet().iterator();
    }

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable

    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

    public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }

public LinkedHashSet()

public HashSet(int initialCapacity)

public HashSet(int initialCapacity, float loadFactor)

    public LinkedHashSet(int initialCapacity, float loadFactor) {
    	//调用其父类HashSet的构造器，指定初始容量和增长因子，构造一个LinkedHashMap
        super(initialCapacity, loadFactor, true);
    }

    public LinkedHashSet(int initialCapacity) {
    	//调用其父类HashSet的构造器，指定初始容量，增长因子为0.75，构造一个LinkedHashMap
        super(initialCapacity, .75f, true);
    }

    public LinkedHashSet() {
    	//调用其父类HashSet的构造器，初始容量为16，增长因子为0.75，构造一个LinkedHashMap
        super(16, .75f, true);
    }

public class TreeSet<E> extends AbstractSet<E>
    	implements NavigableSet<E>, Cloneable, java.io.Serializable

//创建一个空的 TreeSet，使用自然排序
	public TreeSet()
	//指定比较器，如果比较器是 null 将使用自然排序
	public TreeSet(Comparator<? super E> comparator)

//添加一个元素
	public boolean add(E e)
	//添加集合中的元素
	public  boolean addAll(Collection<? extends E> c)

    public boolean remove(Object o)

    public boolean contains(Object o)

//获取TreeSet元素个数
    public int size()
	//判断TreeSet是否为空
    public boolean isEmpty()
	//清空TreeSet
    public void clear()

//返回此TreeSet中存在的最大元素
    public E last() {
        return m.lastKey();
    }
	//返回此TreeSet中存在的最小元素
    public E first() {
        return m.firstKey();
    } 

    public E lower(E e)

    public E higher(E e)

//返回在这个集合中小于或者等于给定元素的最大元素
    public E floor(E e)
	//返回在这个集合中大于或者等于给定元素的最小元素
    public E ceiling(E e)

    public E pollFirst()

    public E pollLast()

//存储数据的底层数据结构
    private transient NavigableMap<E,Object> m;
    //由于 TreeSet 只需要使用 Key 进行存储，因此 Value 存储的是一个虚拟值
    private static final Object PRESENT = new Object();

    //使用 TreeMap 创建一个空的 TreeSet，使用自然排序，
    //添加的元素需要实现 Comparable 接口，即是可比较的
    public TreeSet() {
        this(new TreeMap<E,Object>());
    }
    //指定比较器，如果比较器是 null 将使用自然排序
    public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }
    //构建一个treeSet，包含参数c中的元素，排序是基于元素的自然顺序
    public TreeSet(Collection<? extends E> c) {
        this();
        addAll(c);
    }

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

    public  boolean addAll(Collection<? extends E> c) {
        // Use linear-time version if applicable
        if (m.size()==0 && c.size() > 0 &&
            c instanceof SortedSet &&
            m instanceof TreeMap) {
            SortedSet<? extends E> set = (SortedSet<? extends E>) c;
            TreeMap<E,Object> map = (TreeMap<E, Object>) m;
            Comparator<?> cc = set.comparator();
            Comparator<? super E> mc = map.comparator();
            if (cc==mc || (cc != null && cc.equals(mc))) {
                map.addAllForTreeSet(set, PRESENT);
                return true;
            }
        }
        return super.addAll(c);
    }

    public boolean remove(Object o) {
        return m.remove(o)==PRESENT;
    }

    public boolean contains(Object o) {
        return m.containsKey(o);
    }

//获取TreeSet元素个数
    public int size() {
        return m.size();
    }
	//判断TreeSet是否为空
    public boolean isEmpty() {
        return m.isEmpty();
    }
	//清空TreeSet
    public void clear() {
        m.clear();
    }

//返回此TreeSet中存在的最大元素
    public E last() {
        return m.lastKey();
    }
	//返回此TreeSet中存在的最小元素
    public E first() {
        return m.firstKey();
    } 

    public E lower(E e) {
        return m.lowerKey(e);
    }

    public E higher(E e) {
        return m.higherKey(e);
    }

    public E floor(E e) {
        return m.floorKey(e);
    }
    public E ceiling(E e) {
        return m.ceilingKey(e);
    }

    public E pollFirst() {
        Map.Entry<E,?> e = m.pollFirstEntry();
        return (e == null) ? null : e.getKey();
    }

    public E pollLast() {
        Map.Entry<E,?> e = m.pollLastEntry();
        return (e == null) ? null : e.getKey();
    }