深入理解TreeSet

1，认识TreeSet

• TreeSet 实现了NavigableSet接口，意味着它支持一系列的导航方法。比如查找与指定目标最匹配项
• 保存无重复的数据，并且对数据进行了排序
• TreeSet是基于TreeMap的NavigableSet实现
• 底层是基于红黑树实现的
• 线程不安全

2，类图关系

3，走进源码

• 数据结构

//底图
 private transient NavigableMap<E,Object> m;
 //虚拟对象
 private static final Object PRESENT = new Object();

3.1构造函数

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

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

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

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

• 将Collection中的元素附加到TreeSet中

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

• 将SortedSet中的元素附加到TreeSet中

//s 排序后的集合，其元素将组成新集合
  public TreeSet(SortedSet<E> s) {
        this(s.comparator());
        addAll(s);
    }

3.1添加元素

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

3.2删除元素

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

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

-获取第一个元素，并将该元素从TreeMap中删除。

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

3.3子集操作

• 返回从fromElement到toElement的子集

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

 public SortedSet<E> subSet(E fromElement, E toElement) {
        return subSet(fromElement, true, toElement, false);
    }

• 返回从头部到toElemen的子集

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

-返回从fromElement到结尾(不包括)的子集

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

3.4比较

• 返回Set中小于e的最大元素

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

• 返回Set中小于/等于e的最大元素

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

• 返回Set中大于/等于e的最小元素

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

• 返回Set中大于e的最小元素

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