Java基础之Collections框架Set实现类TreeSet及其源码分析

基于TreeMap的NavigableSet实现。 元素使用其自然顺序进行排序，或通过在设置创建时提供的Comparator进行排序，具体取决于所使用的构造函数.
TreeMap实现为基本操作（添加，删除和包含）提供了保证的log（n）时间成本.
请注意，如果要正确实现Set接口，则由集合（无论是否提供显式比较器）维护的顺序必须与equals一致。 （有关与equals一致的精确定义，请参见Comparable或Comparator）之所以这样，是因为Set接口是根据equals操作定义的，但是TreeSet实例使用其compareTo（或compare）方法执行所有元素比较，因此两个 从集合的角度来看，此方法认为相等的元素是相等的。
请注意，此实现未同步。 如果多个线程同时访问TreeSet，并且至少有一个线程修改了该TreeSet，则必须在外部对其进行同步。 通常，通过对自然封装了该集合的某个对象进行同步来完成此操作.

SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));

TreeSet的简单使用

 Set<String> setStr = new TreeSet<String>();
 //添加元素
 setStr.add("tony");
 setStr.add("Shanghai");
 System.out.println(setStr.toString());
  //移除元素
 setStr.remove("tony");
 System.out.println(setStr.toString());
 
 List<String> listStr = new ArrayList<String>();
 listStr.add("Tony");
 listStr.add("One");
 //将指定集合中的元素添加到Set中
 setStr.addAll(listStr);
 System.out.println(setStr.toString());
 //将指定集合中的元素从Set中移除
 setStr.removeAll(listStr);
 System.out.println(setStr.toString());
 ......

TreeSet源码分析

集合中有很多的方法，但是具体的流程不知道，看看源码了解相关操作的具体流程和相关的操作。

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable
{
    /**
     * NavigableMap对象，该对象不被序列化
     */
    private transient NavigableMap<E,Object> m;

    // 虚拟值与m中的对象相关联
    private static final Object PRESENT = new Object();

    /**
     * 构造一个由指定的NavigableMap支持的集合
     */
    TreeSet(NavigableMap<E,Object> m) {
        this.m = m;
    }

    /**
    构造一个新的空树集，根据其元素的自然排序,  所有元素插入该集合必须实现 Comparable接口。
     */
    public TreeSet() {
        this(new TreeMap<E,Object>());
    }

    /**
     *构造一个新的TreeSet，根据指定的树排序比较器
     */
    public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }

    /**
     构造一个包含指定元素的新TreeSet集合，根据其自然顺序排序元素
     */
    public TreeSet(Collection<? extends E> c) {
        this();
        addAll(c);
    }

    /**
     构造一个包含相同元素的新树集，并使用与指定排序集相同的顺序。
     */
    public TreeSet(SortedSet<E> s) {
        this(s.comparator());
        addAll(s);
    }

    /**
     以升序返回此集合中元素的迭代器
     */
    public Iterator<E> iterator() {
        return m.navigableKeySet().iterator();
    }

    /**
     以降序返回此集合中元素的迭代器
     */
    public Iterator<E> descendingIterator() {
        return m.descendingKeySet().iterator();
    }

    /**
     * 返回此映射中包含的映射的逆序视图。
     */
    public NavigableSet<E> descendingSet() {
        return new TreeSet<>(m.descendingMap());
    }

    /**
     * 返回此集合中的元素数
     */
    public int size() {
        return m.size();
    }

    /**
     * 返回集合是否为空
     */
    public boolean isEmpty() {
        return m.isEmpty();
    }

    /**
     * 返回集合是否包含指定元素
     */
    public boolean contains(Object o) {
        return m.containsKey(o);
    }

    /**
     * 如果指定的元素尚不存在，则将其添加到该集合中
     */
    public boolean add(E e) {
        return m.put(e, PRESENT)==null;
    }

    /**
     * 从集合中移除指定元素
     */
    public boolean remove(Object o) {
        return m.remove(o)==PRESENT;
    }

    /**
     移除所有的元素
     */
    public void clear() {
        m.clear();
    }

    /**
     * 将指定集合中的所有元素添加到该集合中。
     */
    public  boolean addAll(Collection<? extends E> c) {
        // 使用线性时间，判断相关的数据的大小同时判断集合的类型
        //如果满足条件将使用线性时间
        if (m.size()==0 && c.size() > 0 &&
            c instanceof SortedSet &&
            m instanceof TreeMap) {
            //sortSet是排好序的set，后面我们在研究  哈哈
            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 NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                                  E toElement,   boolean toInclusive) {
        return new TreeSet<>(m.subMap(fromElement, fromInclusive,
                                       toElement,   toInclusive));
    }

    /**
     获取前面子集合
     */
    public NavigableSet<E> headSet(E toElement, boolean inclusive) {
        return new TreeSet<>(m.headMap(toElement, inclusive));
    }

    /**
    获取尾部的子集合
     */
    public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
        return new TreeSet<>(m.tailMap(fromElement, inclusive));
    }

    /**
    获取集合中的子集
     */
    public SortedSet<E> subSet(E fromElement, E toElement) {
        return subSet(fromElement, true, toElement, false);
    }

    /**
     获取前面子集合
     */
    public SortedSet<E> headSet(E toElement) {
        return headSet(toElement, false);
    }

    /**
    获取尾部的子集合
     */
    public SortedSet<E> tailSet(E fromElement) {
        return tailSet(fromElement, true);
    }

	/***
	获取比较器
	**/
    public Comparator<? super E> comparator() {
        return m.comparator();
    }

    /**
     * @throws NoSuchElementException {@inheritDoc}
     */
    public E first() {
        return m.firstKey();
    }

    /**
     * 获得最后的元素
     */
    public E last() {
        return m.lastKey();
    }
    /**
    NavigableSet 方法，讲解NavigableSet细说
     */
    public E lower(E e) {
        return m.lowerKey(e);
    }

    /**
      NavigableSet 方法，讲解NavigableSet细说
     */
    public E floor(E e) {
        return m.floorKey(e);
    }

    /**
     NavigableSet 方法，讲解NavigableSet细说
     */
    public E ceiling(E e) {
        return m.ceilingKey(e);
    }

    /**
    NavigableSet 方法，讲解NavigableSet细说
     */
    public E higher(E e) {
        return m.higherKey(e);
    }

    /**
     NavigableSet 方法，讲解NavigableSet细说
     */
    public E pollFirst() {
        Map.Entry<E,?> e = m.pollFirstEntry();
        return (e == null) ? null : e.getKey();
    }

    /**
      NavigableSet 方法，讲解NavigableSet细说
     */
    public E pollLast() {
        Map.Entry<E,?> e = m.pollLastEntry();
        return (e == null) ? null : e.getKey();
    }

    /**
     对集合进行浅复制
     */
    @SuppressWarnings("unchecked")
    public Object clone() {
        TreeSet<E> clone;
        try {
            clone = (TreeSet<E>) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e);
        }

        clone.m = new TreeMap<>(m);
        return clone;
    }

    /**
    序列化集合
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // Write out any hidden stuff
        s.defaultWriteObject();

        // Write out Comparator
        s.writeObject(m.comparator());

        // Write out size
        s.writeInt(m.size());

        // Write out all elements in the proper order.
        for (E e : m.keySet())
            s.writeObject(e);
    }

    /**
     * 反序列化集合
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden stuff
        s.defaultReadObject();

        // Read in Comparator
        @SuppressWarnings("unchecked")
            Comparator<? super E> c = (Comparator<? super E>) s.readObject();

        // Create backing TreeMap
        TreeMap<E,Object> tm = new TreeMap<>(c);
        m = tm;

        // Read in size
        int size = s.readInt();

        tm.readTreeSet(size, s, PRESENT);
    }

    /**
     返回一个Spliterator
     */
    public Spliterator<E> spliterator() {
        return TreeMap.keySpliteratorFor(m);
    }

    private static final long serialVersionUID = -2479143000061671589L;	
}

我们从源码中可以看出，TreeSet和HashSet都是的用Map接口的不通实现类的相关方法进行操作的，HashSet -> HashMap，TreeSet ->NavigableMap，详细的NavigableMap相关说明看看NavigableMap的讲解。我们知道TreeSet是依靠NavigableMap进行实现的。private transient NavigableMap<E,Object> m。