TreeSet源码分析
TreeSet的结构图
TreeSet的属性
/**
* 底层map
* 维护一个NavigableMap型变量,NavigableMap是TreeMap的接口
* 序列化时,值被置为null
*/
private transient NavigableMap<E,Object> m;
// PRESENT定义为静态常量,用来填充map的value
private static final Object PRESENT = new Object();
TreeSet的构造方法
//包级私有构造器:根据指定参数m创建TreeSet的底层map
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
/**
* 构造一个新的,空的treeset,元素按自然排序.
* 插入set中的所有元素必须实现Comparable接口.
* 进一步讲,在set中的任何两个元素e1,e2在进行e1.compareTo(e2)相互比较时,都不能
* 抛出类型安全异常ClassCastException.
* 如果用户想要插入一个和规定冲突的元素(比如向set<String>集合中插入Integer对象),
* 则add方法会抛出异常ClassCastException.
*/
//公有构造器,调用上一个构造器方法,这里可以看出底层map为treemap.
public TreeSet() {
this(new TreeMap<E,Object>());
}
/**
* 构造一个新的,空的treeset,元素存储顺序和传入比较器一致.
* 所有被插入这个set的元素都应该可以使用这个比较器,
* 即在进行comparator.compare(e1,e2)的比较时,不能抛出类型安全异常
* ClassCastException.如果用户尝试添加一个和此约束冲突的元素,则add()方法的
* 调用者会抛出类型安全异常.
* 如果传入比较器为null,则使用自然排序.
*/
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
/**
* 构造一个新的但包含指定集合元素的treeset,元素顺序为自然排序.
* 插入set的所有元素必须实现Comparable接口.
*/
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
//创建一个新的,元素和给定参数的一致,并且排序和给定的有序set一致.
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
通过上面的源码可以看到,内部是通过操作TreeMap进行实现的。
TreeSet的迭代器
//迭代器,此处便可以发现,虽然底层用的是map,但是只是用了map的key对set的元素进行存储.
//因为这里返回的是keyset的迭代器.
public Iterator<E> iterator() {
return m.navigableKeySet().iterator();
}
//返回一个元素降序的迭代器.
public Iterator<E> descendingIterator() {
return m.descendingKeySet().iterator();
}
TreeSet的方法
descendingSet()
用来返回包含在这个组中的元素的逆顺序图
public NavigableSet<E> descendingSet() {
return new TreeSet<>(m.descendingMap());
}
其他方法
//用来添加元素,可见是通过操作内部成员变量m的put方法实现的,也就是调用TreeMap的put方法实现的。
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
//返回底层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);
}