简介

TreeSet在java集合体系中的继承实现关系。

TreeSet也叫树集，是一个有序的集合，这里的有序不是指List中按照元素的加入顺序存储的有序性，而是指它能够对集合中的元素按照某种规则进行排序，并且保持集合中元素的唯一性。

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

TreeSet继承至AbstractSet，并且实现了NavigableSet，Cloneable以及java.io.Serializable接口，所以它也是支持可复制以及序列化操作。
由于实现了NavigableSet接口，它也具有了为给定搜索目标报告最接近匹配项的导航方法。
NavigableSet解析：从源码分析SortedSet与NavigableSet

TreeSet内部是基于TreeMap实现的，它提供两种排序方式（取决与构造方法）：

• 自然排序
• 根据创建TreeSet 时提供的 Comparator 进行排序

TreeSet的元素有序及唯一

public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();

        set.add(4);
        set.add(2);
        set.add(1);
        set.add(4);
        set.add(42);
        set.add(33);
        set.add(76);
        set.add(67);

        System.out.println("set:" + set);
        System.out.println("==============================================");
        boolean temp = set.add(1);
        System.out.println("第二次添加元素1:" + temp);
        System.out.println("set:" + set);

    }

可以看到TreeSet中的元素经过排序，递增的打印在控制台，并且向HashSet中重复添加相同的元素时，并不能添加成功。

构造方法

构造由指定的可导航地图支持的集。

/** * Constructs a set backed by the specified navigable map. */
    TreeSet(NavigableMap<E,Object> m) {
        this.m = m;
    }

TreeSet 提供了四种TreeSet 的构造方式：

TreeSet()

构造一个新的，空的树集，根据其元素的自然排序进行排序。

public TreeSet() {
        this(new TreeMap<E,Object>());
    }

TreeSet(Comparator<? super E> comparator)

构造一个新的，空的树集，根据指定的比较器进行排序。

public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }

TreeSet(Collection<? extends E> c)

构造一个包含指定集合中的元素的新树集，根据其元素的自然排序进行排序。

public TreeSet(Collection<? extends E> c) {
        this();
        addAll(c);
    }

TreeSet(SortedSet s)

构造一个包含相同元素的新树，并使用与指定排序集相同的顺序。

public TreeSet(SortedSet<E> s) {
        this(s.comparator());
        addAll(s);
    }

常用方法

Iterator iterator()

以升序返回该集合中的元素的迭代器。

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

Iterator descendingIterator()

以降序返回该集合中的元素的迭代器。

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

int size()

返回此集合中的元素数。

public int size() {
        return m.size();
    }

boolean isEmpty()

如果此集合不包含元素，则返回 true 。

public boolean isEmpty() {
        return m.isEmpty();
    }

boolean contains(Object o)

如果此集合包含指定的元素，则返回true 。

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

boolean add(E e)

将指定的元素添加到此集合（如果尚未存在）。

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

boolean remove(Object o)

如果存在，则从该集合中删除指定的元素。

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

void clear()

清空集合中的元素

public void clear() {
        m.clear();
    }

boolean addAll(Collection<? extends E> c)

将指定集合中的所有元素添加到此集合中。

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);
    }

NavigableSet subSet(E fromElement, boolean fromInclusive,E toElement, boolean toInclusive)

该集合的部分的视图，其元素的范围从 fromElement （包括）到 toElement。

public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                                  E toElement,   boolean toInclusive) {
        return new TreeSet<>(m.subMap(fromElement, fromInclusive,
                                       toElement,   toInclusive));
    }

NavigableSet headSet(E toElement, boolean inclusive)

该集合的全部的视图。

public NavigableSet<E> headSet(E toElement, boolean inclusive) {
        return new TreeSet<>(m.headMap(toElement, inclusive));
    }

NavigableSet headSet(E toElement, boolean inclusive)

返回此集合的部分的视图，其元素小于（或等于，如果inclusive为真）toElement。

public NavigableSet<E> headSet(E toElement, boolean inclusive) {
        return new TreeSet<>(m.headMap(toElement, inclusive));
    }

NavigableSet tailSet(E fromElement, boolean inclusive)

返回此集合的部分的视图，其元素小于（或等于，如果inclusive为真）toElement。

public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
        return new TreeSet<>(m.tailMap(fromElement, inclusive));
    }

Comparator<? super E> comparator()

返回用于对该集合中的元素进行排序的比较器

public Comparator<? super E> comparator() {
        return m.comparator();
    }

E first()

返回此集合中当前的第一个（最低）元素。

public E first() {
        return m.firstKey();
    }

E last()

返回此集合中当前的最后（最高）元素。

public E last() {
        return m.lastKey();
    }

E lower(E e)

返回这个集合中最大的元素严格小于给定的元素，如果没有这样的元素，则返回 null 。

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

E floor(E e)

返回该集合中最大的元素小于或等于给定的元素，如果没有这样的元素，则返回 null 。

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

E ceiling(E e)

返回此集合中最小元素大于或等于给定元素，如果没有此元素则返回 null 。

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

E higher(E e)

返回此集中的最小元素严格大于给定元素，如果没有此元素，则返回 null 。

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

E pollFirst()

检索并删除第一个（最低）元素，如果此集合为空，则返回 null 。

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

E pollLast()

检索并删除最后一个（最高）元素，如果此集合为空，则返回 null 。

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

Object clone()

返回此TreeSet实例的浅拷贝。 （元素本身不被克隆。）

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;
    }