概述

文章的内容基于JDK1.7进行分析，之所以选用这个版本，是因为1.8的有些类做了改动，增加了阅读的难度，虽然是1.7，但是对于1.8做了重大改动的内容，文章也会进行说明。

TreeSet实现了SortedSet接口，它是一个有序的集合类，TreeSet的底层是通过TreeMap实现的。TreeSet并不是根据插入的顺序来排序，而是根据实际的值的大小来排序。TreeSet也支持两种排序方式：

自然排序

自定义排序

数据结构

继承关系

java.lang.Object

java.util.AbstractCollection

java.util.AbstractSet

java.util.TreeSet

实现接口

Serializable, Cloneable, Iterable, Collection, NavigableSet, Set, SortedSet

基本属性

private transient NavigableMap m; //存放元素的集合

private static final Object PRESENT = new Object(); //m中key 对应的value

重要方法深度解析

构造方法

//相同包下可以访问的构造方法，将指定的m赋值为m

TreeSet(NavigableMap m) {

this.m = m;

}

//无参构造方法，创建一个空的TreeMap对象，并调用上面的构造方法

public TreeSet() {

this(new TreeMap());

}

//指定比较器，并用指定的比较器创建TreeMap对象

public TreeSet(Comparator super E> comparator) {

this(new TreeMap<>(comparator));

}

//将指定的集合C转化为TreeSet

public TreeSet(Collection extends E> c) {

this();

addAll(c);

}

//将SortedMap中的元素转化为TreeMap对象

public TreeSet(SortedSet s) {

this(s.comparator());

addAll(s);

}

通过上面的构造方法，可以看出TreeSet的底层是用TreeMap实现的。在构造方法中会创建一个TreeMap实例，用于存放元素，另外TreeSet是有序的，也提供了制定比较器的构造函数，如果没有提供比较器，则采用key的自然顺序进行比较大小，如果指定的比较器，则采用指定的比较器，进行key值大小的比较。

add()方法和remove()方法都比较的简单都是调用TreeMap的方法进行实现。此处不在单独列出

源码解析

public class TreeSet extends AbstractSet

implements NavigableSet, Cloneable, java.io.Serializable

{

//存放元素的map对象

private transient NavigableMap m;

//key-value ,不同的键都会对象相同的value, value = PRESENT

private static final Object PRESENT = new Object();

//指定的map对象

TreeSet(NavigableMap m) {

this.m = m;

}

//无参构造方法，初始化一个TreeMap对象

public TreeSet() {

this(new TreeMap());

}

//构造方法，指定比较器

public TreeSet(Comparator super E> comparator) {

this(new TreeMap<>(comparator));

}

//将集合中的元素转化为TreeSet存储

public TreeSet(Collection extends E> c) {

this();

addAll(c);

}

//构造方法，SortedSet转化为TreeSet存储，并使用SortedSet的比较器

public TreeSet(SortedSet s) {

this(s.comparator());

addAll(s);

}

//遍历方法，返回m.keyset集合

public Iterator iterator() {

return m.navigableKeySet().iterator();

}

//逆序排序的迭代器

public Iterator descendingIterator() {

return m.descendingKeySet().iterator();

}

/**

* @since 1.6

*/

public NavigableSet descendingSet() {

return new TreeSet<>(m.descendingMap());

}

//返回 m 包含的键值对的数量

public int size() {

return m.size();

}

//是否为空

public boolean isEmpty() {

return m.isEmpty();

}

//是否包含指定的key

public boolean contains(Object o) {

return m.containsKey(o);

}

//添加元素，调用m.put方法实现

public boolean add(E e) {

return m.put(e, PRESENT)==null;

}

//删除方法，调用m.remove()方法实现

public boolean remove(Object o) {

return m.remove(o)==PRESENT;

}

//清除集合

public void clear() {

m.clear();

}

//将一个集合中的所有元素添加到TreeSet中

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 map = (TreeMap) m;

Comparator super E> cc = (Comparator super E>) 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);

}

//返回子集合，通过 m.subMap()方法实现

public NavigableSet subSet(E fromElement, boolean fromInclusive,

E toElement, boolean toInclusive) {

return new TreeSet<>(m.subMap(fromElement, fromInclusive,

toElement, toInclusive));

}

//返回set的头部

public NavigableSet headSet(E toElement, boolean inclusive) {

return new TreeSet<>(m.headMap(toElement, inclusive));

}

//返回尾部

public NavigableSet tailSet(E fromElement, boolean inclusive) {

return new TreeSet<>(m.tailMap(fromElement, inclusive));

}

//返回子Set

public SortedSet subSet(E fromElement, E toElement) {

return subSet(fromElement, true, toElement, false);

}

//返回set的头部

public SortedSet headSet(E toElement) {

return headSet(toElement, false);

}

//返回set的尾部

public SortedSet tailSet(E fromElement) {

return tailSet(fromElement, true);

}

//返回m使用的比较器

public Comparator super E> comparator() {

return m.comparator();

}

//返回第一个元素

public E first() {

return m.firstKey();

}

//返回最后一个元素

public E last() {

return m.lastKey();

}

//返回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);

}

//获取TreeSet中第一个元素，并从Set中删除该元素

public E pollFirst() {

Map.Entry e = m.pollFirstEntry();

return (e == null) ? null : e.getKey();

}

//获取TreeSet中最后一个元素，并从Set中删除该元素

public E pollLast() {

Map.Entry e = m.pollLastEntry();

return (e == null) ? null : e.getKey();

}

//克隆方法

public Object clone() {

TreeSet clone = null;

try {

clone = (TreeSet) super.clone();

} catch (CloneNotSupportedException e) {

throw new InternalError();

}

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

Comparator super E> c = (Comparator super E>) s.readObject();

// Create backing TreeMap

TreeMap tm;

if (c==null)

tm = new TreeMap<>();

else

tm = new TreeMap<>(c);

m = tm;

// Read in size

int size = s.readInt();

tm.readTreeSet(size, s, PRESENT);

}

//序列化版本号

private static final long serialVersionUID = -2479143000061671589L;

}

总结

TreeSet是一个有序的集合，基于TreeMap实现，支持两种排序方式：自然排序和定制排序。

TreeSet是非同步的，线程不安全的。

少年听雨歌楼上，红烛昏罗帐。

壮年听雨客舟中，江阔云低，断雁叫西风。

感谢支持！

---起个名忒难