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。