// 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<?> cc = 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);
}
这个方法是将参数集合的所有元素添加进本集合的方法。
首先判断如果本集合为空,且参数集合不为空,且参数集合属于SortedSet,且底层map属于TreeMap,如果有一个条件不成立,就调用父类AbstractCollection的方法添加所有元素。
如果都成立,先将参数集合强转至SortedSet接口实现类,将底层map强转至TreeMap,然后分别获取强转后的SortedSet的Comparator和强转后的TreeMap的Comparator。
然后再判断两个Comparator是否是同一对象,或是否equals方法返回true。如果成立,则调用强转后的TreeMap的方法将强转后的SortedSet全部添加进去。
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
E toElement, boolean toInclusive) {
return new TreeSet<>(m.subMap(fromElement, fromInclusive,
toElement, toInclusive));
}
这个方法是截取集合的方法,返回一个新TreeSet对象,调用底层map的截取map方法,将四个参数都传入,然后将结果传给新的TreeSet。
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));
}
这两个个方法是截取比参数元素小或大的所有元素的方法,和上面类似,都是新建一个TreeSet,然后执行底层map的相关方法,将结果给新TreeSet。
public SortedSet<E> subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
这个方法调用上面的subSet方法,但将两个boolean参数都为true,表示截取集合时包含参数元素。
public SortedSet<E> headSet(E toElement) {
return headSet(toElement, false);
}
这个方法调用上面的headSet方法,但将boolean参数设为false,就是截取集合时不包含参数元素。
public SortedSet<E> tailSet(E fromElement) {
return tailSet(fromElement, true);
}
这个方法调用上面的tailSet方法,但将boolean参数设为true,就是截取集合时包含参数元素,很奇怪和上面那个headSet方法不一致。
public E first() {
return m.firstKey();
}
public E last() {
return m.lastKey();
}
这两个方法分别返回集合第一个和最后一个元素,都是通过底层map来返回的。
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();
}
这两个方法分别返回第一个元素和最后一个元素,会删掉相关键值对。
public Object clone() {
TreeSet<E> clone;
try {
clone = (TreeSet<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
clone.m = new TreeMap<>(m);
return clone;
}
这个方法是克隆的方法。
调用的是父类的克隆方法。然后新建一个TreeMap传入原本的底层map,再赋引用给克隆体的底层map。
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);
}
这个是序列化输出的方法,先调用参数的默认输出方法,然后写出底层map的Comparator,然后写出底层map的size,然后依次写出底层map的键也就是集合元素。
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden stuff
s.defaultReadObject();
// Read in Comparator
@SuppressWarnings("unchecked")
Comparator<? super E> c = (Comparator<? super E>) s.readObject();
// Create backing TreeMap
TreeMap<E,Object> tm = new TreeMap<>(c);
m = tm;
// Read in size
int size = s.readInt();
tm.readTreeSet(size, s, PRESENT);
}
这个方法是序列化输入的方法。
首先调用参数的默认读入方法。然后读入Comparator,然后读入size,然后创建封装了Comparator的TreeMap并赋引用给底层map。最后底层map读入所有元素。