TreeSet源码分析

基于jdk1.8源码进行分析的。

之前已经对TreeMap的源码分析过了。

该类主要将Set中的元素按照一定的规则进行排序存储。在其源码的内部实现中(如下)，可以看到TreeSet时借助了TreeMap来实现的。

下面直接上TreeSet的源码。

继承结构

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

继承了AbstractSet<E>类，实现了NavigableSet<E>, Cloneable, java.io.Serializable接口。

成员属性

    //内部实现引用
    private transient NavigableMap<E,Object> m;

    //保存数据的PRESENT数组
    private static final Object PRESENT = new Object();

构造方法

    TreeSet(NavigableMap<E,Object> m) {
        this.m = m;
    }
    
    //默认构造方法
    public TreeSet() {
        //可以看见内部是通过TreeMap实现的
        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);
    }
    
    //创建一个新的,元素和给定参数的一致,并且排序和给定的有序set一致.
    public TreeSet(SortedSet<E> s) {
        this(s.comparator());
        addAll(s);
    }

通过上面的源码可以看到，内部是通过操作TreeMap进行实现的。

成员方法

add(E e)

用来添加元素，可见是通过操作内部成员变量m的put方法实现的，也就是调用TreeMap的put方法实现的。

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

TreeMap的put方法具体实现源码如下

底下是对一棵树的操作。要么是空树，创建根节点，如果不是空树，那么寻找他的位置，找到位置了插入即可。里面会涉及到一个问题，就是比较器的问题。具体还请移步TreeMap的源码分析那篇文章，此处不再赘述。

    public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

iterator()

没有提供get方法，提供有遍历的方法。可以看到iterator方法是通过TreeMap实现的。

    public Iterator<E> iterator() {
        return m.navigableKeySet().iterator();
    }

descendingIterator()

返回一个元素降序的迭代器 

    public Iterator<E> descendingIterator() {
        return m.descendingKeySet().iterator();
    }

descendingSet()

用来返回包含在这个组中的元素的逆顺序图。 

    public NavigableSet<E> descendingSet() {
        return new TreeSet<>(m.descendingMap());
    }

其他方法如下

    //返回底层treemap的size
    //通过TreeMap实现
    public int size() {
        return m.size();
    }

    //根据底层treemap,判定是否为空
    //通过TreeMap实现
    public boolean isEmpty() {
        return m.isEmpty();
    }

    //根据底层treemap,判定是否包含o对象.
    public boolean contains(Object o) {
        return m.containsKey(o);
    }

    //调用底层treemap的方法清空set中的元素
    //通过TreeMap实现
    public void clear() {
        m.clear();
    }

    //方法时间复杂度:线性
    public  boolean addAll(Collection<? extends E> c) {
        /**如果
         * 1.底层Map没有存储元素
         * 2.参数中包含元素
         * 3.参数类型为SortedSet
         * 4.底层map类型为TreeMap
         */
        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;
            //获取参数集合c的比较器.
            Comparator<?> cc = set.comparator();
            //获取底层treemap的比较器.
            Comparator<? super E> mc = map.comparator();
            //如果两个比较器等价,则进行插入操作;否则不插入.
            if (cc==mc || (cc != null && cc.equals(mc))) {
                map.addAllForTreeSet(set, PRESENT);
                return true;
            }
        }
        //调用AbstractCollection方法
        return super.addAll(c);
    }

    //根据key值范围,截取set.调用的是NavigableSet的方法
    public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                                  E toElement,   boolean toInclusive) {
        return new TreeSet<>(m.subMap(fromElement, fromInclusive,
                toElement,   toInclusive));
    }

    //返回视图中所有元素的值:<=toElement
    public NavigableSet<E> headSet(E toElement, boolean inclusive) {
        return new TreeSet<>(m.headMap(toElement, inclusive));
    }

   //返回视图中所有元素的值:>=toElement
    public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
        return new TreeSet<>(m.tailMap(fromElement, inclusive));
    }

    //参数为true,则包含等于;否则不包含等于.
    //因此本方中,返回key的范围为:[fromElement,toElement)
    public SortedSet<E> subSet(E fromElement, E toElement) {
        return subSet(fromElement, true, toElement, false);
    }

    //返回key的范围:[,toElement)
    public SortedSet<E> headSet(E toElement) {
        return headSet(toElement, false);
    }

    //返回key范围:[,fromElement]
    public SortedSet<E> tailSet(E fromElement) {
        return tailSet(fromElement, true);
    }

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

    //获取第一个key
    public E first() {
        return m.firstKey();
    }

    //获取最后一个key
    public E last() {
        return m.lastKey();
    }


    /*--------NavigableSet的API方法---------*/
    //返回比e小且和e的差最小的key
    public E lower(E e) {
        return m.lowerKey(e);
    }

    //返回<=e的最大key
    public E floor(E e) {
        return m.floorKey(e);
    }

   //返回>=e的最小key
    public E ceiling(E e) {
        return m.ceilingKey(e);
    }

    //返回>e的最小值
    public E higher(E e) {
        return m.higherKey(e);
    }

    //返回最小key;如果底层map为空,则返回null
    public E pollFirst() {
        Map.Entry<E,?> e = m.pollFirstEntry();
        return (e == null) ? null : e.getKey();
    }

   //返回最大key;如果底层map为空,则返回null
    public E pollLast() {
        Map.Entry<E,?> e = m.pollLastEntry();
        return (e == null) ? null : e.getKey();
    }

    
    /**
     * 创建key的分割器
     */
    public Spliterator<E> spliterator() {
        return TreeMap.keySpliteratorFor(m);
    }

以上是对于TreeSet的源码分析。如果有不足或者不对的地方，还请给出宝贵意见。