TreeSet分析
TreeSet持有一个TreeMap,基于TreeMap实现
TreeSet特点
-
集合里不能存在重复元素(重复元素的判定:Comparator或者Comparable的比较方法返回0)
-
不允许添加空元素null
-
有序集合(要么元素实现Comparable接口,或者给TreeSet指定Comparator(优先级更高),否则会报classCastException)
TreeSet源码:
- 基于TreeMap,有序
- 其余特性与TreeMap保持一致
public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable {
private transient NavigableMap<E,Object> m;
private static final Object PRESENT = new Object();
public TreeSet() {
this(new TreeMap<E,Object>()); //m为TreeMap<E, Object>对象
}
TreeSet(NavigableMap<E,Object> m) { //
this.m = m;
}
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));//m为TreeMap<E, Object>对象
}
public TreeSet(Collection<? extends E> c) {
this();//m为TreeMap<E, Object>对象
addAll(c);
}
public TreeSet(SortedSet<E> s) {
this(s.comparator());//m为TreeMap<E, Object>对象
addAll(s);
}
public Iterator<E> iterator() {
return m.navigableKeySet().iterator();
}
public Iterator<E> descendingIterator() {
return m.descendingKeySet().iterator();
}
public NavigableSet<E> descendingSet() {
return new TreeSet<>(m.descendingMap());
}
public int size() {
return m.size();
}
public boolean isEmpty() {
return m.isEmpty();
}
public boolean contains(Object o) {
return m.containsKey(o);
}
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
public boolean remove(Object o) {
return m.remove(o)==PRESENT;
}
public void clear() {
m.clear();
}
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
E toElement, boolean toInclusive) {
return new TreeSet<>(m.subMap(fromElement, fromInclusive,
toElement, toInclusive));
}
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));
}
public SortedSet<E> subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
public SortedSet<E> headSet(E toElement) {
return headSet(toElement, false);
}
public SortedSet<E> tailSet(E fromElement) {
return tailSet(fromElement, true);
}
public Comparator<? super E> comparator() {
return m.comparator();
}
public E first() {
return m.firstKey();
}
public E last() {
return m.lastKey();
}
public E lower(E e) {
return m.lowerKey(e);
}
public E floor(E e) {
return m.floorKey(e);
}
public E ceiling(E e) {
return m.ceilingKey(e);
}
public E higher(E e) {
return m.higherKey(e);
}
public E pollFirst() {
Map.Entry<E,?> e = m.pollFirstEntry();
return (e == null) ? null : e.getKey();
}
public E pollLast() {
Map.Entry<E,?> e = m.pollLastEntry();
return (e == null) ? null : e.getKey();
}
private static final long serialVersionUID = -2479143000061671589L;
}
测试Demo:
- 要么Person元素实现Comparable接口,或者给TreeSet指定Comparator,否则会报classCastException
- AgeComparator的优先级比Comparable接口的优先级更高
- 对于重复元素,不允许重复添加
public class Person implements Comparable<Person> {
private String name;
protected int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person o) {
return o.age - this.age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class TreeSetTest {
static class AgeComparator implements Comparator<Person> {
@Override
public int compare(Person o1, Person o2) {
return o1.age - o2.age;
}
}
public static void main(String[] args) throws Exception {
Person person1 = new Person("A", 1);
Person person2 = new Person("B", 1);
Person person3 = new Person("C", 1);
TreeSet set = new TreeSet(new AgeComparator());
set.add(person3);
set.add(person2);
set.add(person1);
System.out.println(set);
}
}
输出结果:[Person{name=‘C’, age=1}]