基于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的源码分析。如果有不足或者不对的地方,还请给出宝贵意见。