共同学习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读入所有元素。