概述
文章的內(nèi)容基于JDK1.7進行分析蝴光，之所以選用這個版本吭历，是因為1.8的有些類做了改動，增加了閱讀的難度呼渣，雖然是1.7棘伴，但是對于1.8做了重大改動的內(nèi)容，文章也會進行說明屁置。
TreeSet實現(xiàn)了SortedSet接口焊夸，它是一個有序的集合類，TreeSet的底層是通過TreeMap實現(xiàn)的蓝角。TreeSet并不是根據(jù)插入的順序來排序阱穗，而是根據(jù)實際的值的大小來排序饭冬。TreeSet也支持兩種排序方式：
- 自然排序
- 自定義排序
數(shù)據(jù)結構
繼承關系
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractSet<E>
java.util.TreeSet<E>
實現(xiàn)接口
Serializable, Cloneable, Iterable<E>, Collection<E>, NavigableSet<E>, Set<E>, SortedSet<E>
基本屬性
private transient NavigableMap<E,Object> m; //存放元素的集合
private static final Object PRESENT = new Object(); //m中key 對應的value
重要方法深度解析
構造方法
//相同包下可以訪問的構造方法，將指定的m賦值為m
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
//無參構造方法揪阶，創(chuàng)建一個空的TreeMap對象昌抠，并調(diào)用上面的構造方法
public TreeSet() {
this(new TreeMap<E,Object>());
}
//指定比較器，并用指定的比較器創(chuàng)建TreeMap對象
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
//將指定的集合C轉(zhuǎn)化為TreeSet
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
//將SortedMap中的元素轉(zhuǎn)化為TreeMap對象
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
通過上面的構造方法遣钳，可以看出TreeSet的底層是用TreeMap實現(xiàn)的扰魂。在構造方法中會創(chuàng)建一個TreeMap實例，用于存放元素蕴茴，另外TreeSet是有序的劝评，也提供了制定比較器的構造函數(shù)，如果沒有提供比較器倦淀，則采用key的自然順序進行比較大小蒋畜，如果指定的比較器，則采用指定的比較器撞叽，進行key值大小的比較姻成。
add()方法和remove()方法都比較的簡單都是調(diào)用TreeMap的方法進行實現(xiàn)。此處不在單獨列出
源碼解析
public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable
{
//存放元素的map對象
private transient NavigableMap<E,Object> m;
//key-value ,不同的鍵都會對象相同的value, value = PRESENT
private static final Object PRESENT = new Object();
//指定的map對象
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
//無參構造方法愿棋，初始化一個TreeMap對象
public TreeSet() {
this(new TreeMap<E,Object>());
}
//構造方法科展，指定比較器
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
//將集合中的元素轉(zhuǎn)化為TreeSet存儲
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
//構造方法，SortedSet轉(zhuǎn)化為TreeSet存儲糠雨，并使用SortedSet的比較器
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
//遍歷方法才睹，返回m.keyset集合
public Iterator<E> iterator() {
return m.navigableKeySet().iterator();
}
//逆序排序的迭代器
public Iterator<E> descendingIterator() {
return m.descendingKeySet().iterator();
}
/**
* @since 1.6
*/
public NavigableSet<E> descendingSet() {
return new TreeSet<>(m.descendingMap());
}
//返回 m 包含的鍵值對的數(shù)量
public int size() {
return m.size();
}
//是否為空
public boolean isEmpty() {
return m.isEmpty();
}
//是否包含指定的key
public boolean contains(Object o) {
return m.containsKey(o);
}
//添加元素，調(diào)用m.put方法實現(xiàn)
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
//刪除方法甘邀，調(diào)用m.remove()方法實現(xiàn)
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<E,Object> map = (TreeMap<E, Object>) 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()方法實現(xiàn)
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
E toElement, boolean toInclusive) {
return new TreeSet<>(m.subMap(fromElement, fromInclusive,
toElement, toInclusive));
}
//返回set的頭部
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));
}
//返回子Set
public SortedSet<E> subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
//返回set的頭部
public SortedSet<E> headSet(E toElement) {
return headSet(toElement, false);
}
//返回set的尾部
public SortedSet<E> 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,?> e = m.pollFirstEntry();
return (e == null) ? null : e.getKey();
}
//獲取TreeSet中最后一個元素松邪，并從Set中刪除該元素
public E pollLast() {
Map.Entry<E,?> e = m.pollLastEntry();
return (e == null) ? null : e.getKey();
}
//克隆方法
public Object clone() {
TreeSet<E> clone = null;
try {
clone = (TreeSet<E>) 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<E,Object> 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實現(xiàn)逗抑，支持兩種排序方式：自然排序和定制排序剧辐。
TreeSet是非同步的，線程不安全的锋八。
少年聽雨歌樓上浙于，紅燭昏羅帳。
壯年聽雨客舟中挟纱，江闊云低，斷雁叫西風腐宋。
感謝支持紊服！
---起個名忒難
