共同学习Java源代码-数据结构-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<?> 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读入所有元素。