TreeSet 源代码

1、介绍TreeSet前先介绍它实现的接口NavigableSet

/* * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * *//* * * * * * * Written by Doug Lea and Josh Bloch with assistance from members of JCP * JSR-166 Expert Group and released to the public domain, as explained at * http://creativecommons.org/publicdomain/zero/1.0/ */package java.util;/** * A {@link SortedSet} extended with navigation methods reporting * closest matches for given search targets. Methods {@code lower}, * {@code floor}, {@code ceiling}, and {@code higher} return elements * respectively less than, less than or equal, greater than or equal, * and greater than a given element, returning {@code null} if there * is no such element.  A {@code NavigableSet} may be accessed and * traversed in either ascending or descending order.  The {@code * descendingSet} method returns a view of the set with the senses of * all relational and directional methods inverted. The performance of * ascending operations and views is likely to be faster than that of * descending ones.  This interface additionally defines methods * {@code pollFirst} and {@code pollLast} that return and remove the * lowest and highest element, if one exists, else returning {@code * null}.  Methods {@code subSet}, {@code headSet}, * and {@code tailSet} differ from the like-named {@code * SortedSet} methods in accepting additional arguments describing * whether lower and upper bounds are inclusive versus exclusive. * Subsets of any {@code NavigableSet} must implement the {@code * NavigableSet} interface. * * <p> The return values of navigation methods may be ambiguous in * implementations that permit {@code null} elements. However, even * in this case the result can be disambiguated by checking * {@code contains(null)}. To avoid such issues, implementations of * this interface are encouraged to <em>not</em> permit insertion of * {@code null} elements. (Note that sorted sets of {@link * Comparable} elements intrinsically do not permit {@code null}.) * * <p>Methods * {@link #subSet(Object, Object) subSet(E, E)}, * {@link #headSet(Object) headSet(E)}, and * {@link #tailSet(Object) tailSet(E)} * are specified to return {@code SortedSet} to allow existing * implementations of {@code SortedSet} to be compatibly retrofitted to * implement {@code NavigableSet}, but extensions and implementations * of this interface are encouraged to override these methods to return * {@code NavigableSet}. * * <p>This interface is a member of the * <a href="{@docRoot}/../technotes/guides/collections/index.html"> * Java Collections Framework</a>. * * @author Doug Lea * @author Josh Bloch * @param <E> the type of elements maintained by this set * @since 1.6 *//*扩展的 SortedSet，具有了为给定搜索目标报告最接近匹配项的导航方法。方法 lower、floor、ceiling和 higher 分别返回小于、小于等于、大于等于、大于给定元素的元素，如果不存在这样的元素，则返回 null。可以按升序或降序访问和遍历 NavigableSet。descendingSet 方法返回 set 的一个视图，该视图表示的所有关系方法和方向方法都是逆向的。升序操作和视图的性能很可能比降序操作和视图的性能要好。此外，此接口还定义了 pollFirst 和 pollLast 方法，它们返回并移除最小和最大的元素（如果存在），否则返回 null。subSet、headSet 和 tailSet 方法与名称相似的 SortedSet 方法的不同之处在于：可以接受用于描述是否包括（或不包括）下边界和上边界的附加参数。任何 NavigableSet 的 Submap必须实现 NavigableSet 接口。导航方法的返回值在允许 null 元素的实现中可能是不确定的。不过，即使在这种情况下，也可以通过检查 contains(null) 来明确结果。为了避免这样的问题，建议在此接口的实现中不 允许插入 null 元素。 （注意，Comparable 元素的有序集本身不允许 null。）subSet(E, E)、headSet(E) 和 tailSet(E) 方法被指定为返回 SortedSet，以允许现有 SortedSet实现能相容地改进为实现 NavigableMap，但鼓励此接口的扩展和实现重写这些方法以返回 NavigableSet。 */public interface NavigableSet<E> extends SortedSet<E> {    /**     * Returns the greatest element in this set strictly less than the     * given element, or {@code null} if there is no such element.     *     * @param e the value to match     * @return the greatest element less than {@code e},     *         or {@code null} if there is no such element     * @throws ClassCastException if the specified element cannot be     *         compared with the elements currently in the set     * @throws NullPointerException if the specified element is null     *         and this set does not permit null elements     */    //返回小于e的元素    E lower(E e);    /**     * Returns the greatest element in this set less than or equal to     * the given element, or {@code null} if there is no such element.     *     * @param e the value to match     * @return the greatest element less than or equal to {@code e},     *         or {@code null} if there is no such element     * @throws ClassCastException if the specified element cannot be     *         compared with the elements currently in the set     * @throws NullPointerException if the specified element is null     *         and this set does not permit null elements     */    //返回小于或等于e的最大的元素    E floor(E e);    /**     * Returns the least element in this set greater than or equal to     * the given element, or {@code null} if there is no such element.     *     * @param e the value to match     * @return the least element greater than or equal to {@code e},     *         or {@code null} if there is no such element     * @throws ClassCastException if the specified element cannot be     *         compared with the elements currently in the set     * @throws NullPointerException if the specified element is null     *         and this set does not permit null elements     */    //返回大于或等于e的最小的元素    E ceiling(E e);    /**     * Returns the least element in this set strictly greater than the     * given element, or {@code null} if there is no such element.     *     * @param e the value to match     * @return the least element greater than {@code e},     *         or {@code null} if there is no such element     * @throws ClassCastException if the specified element cannot be     *         compared with the elements currently in the set     * @throws NullPointerException if the specified element is null     *         and this set does not permit null elements     */    //返回大于e的最小的元素    E higher(E e);    /**     * Retrieves and removes the first (lowest) element,     * or returns {@code null} if this set is empty.     *     * @return the first element, or {@code null} if this set is empty     */    //返回并移除掉第一个元素，即为最小的元素    E pollFirst();    /**     * Retrieves and removes the last (highest) element,     * or returns {@code null} if this set is empty.     *     * @return the last element, or {@code null} if this set is empty     */    //返回并移除掉最后一个元素，即为最大的元素    E pollLast();    /**     * Returns an iterator over the elements in this set, in ascending order.     *     * @return an iterator over the elements in this set, in ascending order     */    //返回容器的迭代器    Iterator<E> iterator();    /**     * Returns a reverse order view of the elements contained in this set.     * The descending set is backed by this set, so changes to the set are     * reflected in the descending set, and vice-versa.  If either set is     * modified while an iteration over either set is in progress (except     * through the iterator's own {@code remove} operation), the results of     * the iteration are undefined.     *     * <p>The returned set has an ordering equivalent to     * <tt>{@link Collections#reverseOrder(Comparator) Collections.reverseOrder}(comparator())</tt>.     * The expression {@code s.descendingSet().descendingSet()} returns a     * view of {@code s} essentially equivalent to {@code s}.     *     * @return a reverse order view of this set     */    //返回逆序的Set    NavigableSet<E> descendingSet();    /**     * Returns an iterator over the elements in this set, in descending order.     * Equivalent in effect to {@code descendingSet().iterator()}.     *     * @return an iterator over the elements in this set, in descending order     */    //返回逆序的迭代器    Iterator<E> descendingIterator();    /**     * Returns a view of the portion of this set whose elements range from     * {@code fromElement} to {@code toElement}.  If {@code fromElement} and     * {@code toElement} are equal, the returned set is empty unless {@code     * fromInclusive} and {@code toInclusive} are both true.  The returned set     * is backed by this set, so changes in the returned set are reflected in     * this set, and vice-versa.  The returned set supports all optional set     * operations that this set supports.     *     * <p>The returned set will throw an {@code IllegalArgumentException}     * on an attempt to insert an element outside its range.     *     * @param fromElement low endpoint of the returned set     * @param fromInclusive {@code true} if the low endpoint     *        is to be included in the returned view     * @param toElement high endpoint of the returned set     * @param toInclusive {@code true} if the high endpoint     *        is to be included in the returned view     * @return a view of the portion of this set whose elements range from     *         {@code fromElement}, inclusive, to {@code toElement}, exclusive     * @throws ClassCastException if {@code fromElement} and     *         {@code toElement} cannot be compared to one another using this     *         set's comparator (or, if the set has no comparator, using     *         natural ordering).  Implementations may, but are not required     *         to, throw this exception if {@code fromElement} or     *         {@code toElement} cannot be compared to elements currently in     *         the set.     * @throws NullPointerException if {@code fromElement} or     *         {@code toElement} is null and this set does     *         not permit null elements     * @throws IllegalArgumentException if {@code fromElement} is     *         greater than {@code toElement}; or if this set itself     *         has a restricted range, and {@code fromElement} or     *         {@code toElement} lies outside the bounds of the range.     */    //返回子Set fromInclusive表示是否包含fromElement，toInclusive表示是否包含toElement    NavigableSet<E> subSet(E fromElement, boolean fromInclusive,                           E toElement,   boolean toInclusive);    /**     * Returns a view of the portion of this set whose elements are less than     * (or equal to, if {@code inclusive} is true) {@code toElement}.  The     * returned set is backed by this set, so changes in the returned set are     * reflected in this set, and vice-versa.  The returned set supports all     * optional set operations that this set supports.     *     * <p>The returned set will throw an {@code IllegalArgumentException}     * on an attempt to insert an element outside its range.     *     * @param toElement high endpoint of the returned set     * @param inclusive {@code true} if the high endpoint     *        is to be included in the returned view     * @return a view of the portion of this set whose elements are less than     *         (or equal to, if {@code inclusive} is true) {@code toElement}     * @throws ClassCastException if {@code toElement} is not compatible     *         with this set's comparator (or, if the set has no comparator,     *         if {@code toElement} does not implement {@link Comparable}).     *         Implementations may, but are not required to, throw this     *         exception if {@code toElement} cannot be compared to elements     *         currently in the set.     * @throws NullPointerException if {@code toElement} is null and     *         this set does not permit null elements     * @throws IllegalArgumentException if this set itself has a     *         restricted range, and {@code toElement} lies outside the     *         bounds of the range     */    //返回子Set，    NavigableSet<E> headSet(E toElement, boolean inclusive);    /**     * Returns a view of the portion of this set whose elements are greater     * than (or equal to, if {@code inclusive} is true) {@code fromElement}.     * The returned set is backed by this set, so changes in the returned set     * are reflected in this set, and vice-versa.  The returned set supports     * all optional set operations that this set supports.     *     * <p>The returned set will throw an {@code IllegalArgumentException}     * on an attempt to insert an element outside its range.     *     * @param fromElement low endpoint of the returned set     * @param inclusive {@code true} if the low endpoint     *        is to be included in the returned view     * @return a view of the portion of this set whose elements are greater     *         than or equal to {@code fromElement}     * @throws ClassCastException if {@code fromElement} is not compatible     *         with this set's comparator (or, if the set has no comparator,     *         if {@code fromElement} does not implement {@link Comparable}).     *         Implementations may, but are not required to, throw this     *         exception if {@code fromElement} cannot be compared to elements     *         currently in the set.     * @throws NullPointerException if {@code fromElement} is null     *         and this set does not permit null elements     * @throws IllegalArgumentException if this set itself has a     *         restricted range, and {@code fromElement} lies outside the     *         bounds of the range     */    //返回子Set    NavigableSet<E> tailSet(E fromElement, boolean inclusive);    /**     * {@inheritDoc}     *     * <p>Equivalent to {@code subSet(fromElement, true, toElement, false)}.     *     * @throws ClassCastException       {@inheritDoc}     * @throws NullPointerException     {@inheritDoc}     * @throws IllegalArgumentException {@inheritDoc}     */    //返回排序的子Set [fromElement, toElement)    SortedSet<E> subSet(E fromElement, E toElement);    /**     * {@inheritDoc}     *     * <p>Equivalent to {@code headSet(toElement, false)}.     *     * @throws ClassCastException       {@inheritDoc}     * @throws NullPointerException     {@inheritDoc}     * @throws IllegalArgumentException {@inheritDoc}     */    //返回排序的子Set ( - , toElement)    SortedSet<E> headSet(E toElement);    /**     * {@inheritDoc}     *     * <p>Equivalent to {@code tailSet(fromElement, true)}.     *     * @throws ClassCastException       {@inheritDoc}     * @throws NullPointerException     {@inheritDoc}     * @throws IllegalArgumentException {@inheritDoc}     */    //返回排序的子Set [fromElement , -)    SortedSet<E> tailSet(E fromElement);}

2、TreeSet底层实现是NavigableMap，默认是TreeMap，很多方法都是调用底层的map对应的方法实现的

    //底层是NavigableMap实现的，默认是TreeMap    private transient NavigableMap<E,Object> m;    // Dummy value to associate with an Object in the backing Map    //设置为value的对象    private static final Object PRESENT = new Object();

3、TreeSet源代码

/* * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */package java.util;/** * A {@link NavigableSet} implementation based on a {@link TreeMap}. * The elements are ordered using their {@linkplain Comparable natural * ordering}, or by a {@link Comparator} provided at set creation * time, depending on which constructor is used. * * <p>This implementation provides guaranteed log(n) time cost for the basic * operations ({@code add}, {@code remove} and {@code contains}). * * <p>Note that the ordering maintained by a set (whether or not an explicit * comparator is provided) must be <i>consistent with equals</i> if it is to * correctly implement the {@code Set} interface.  (See {@code Comparable} * or {@code Comparator} for a precise definition of <i>consistent with * equals</i>.)  This is so because the {@code Set} interface is defined in * terms of the {@code equals} operation, but a {@code TreeSet} instance * performs all element comparisons using its {@code compareTo} (or * {@code compare}) method, so two elements that are deemed equal by this method * are, from the standpoint of the set, equal.  The behavior of a set * <i>is</i> well-defined even if its ordering is inconsistent with equals; it * just fails to obey the general contract of the {@code Set} interface. * * <p><strong>Note that this implementation is not synchronized.</strong> * If multiple threads access a tree set concurrently, and at least one * of the threads modifies the set, it <i>must</i> be synchronized * externally.  This is typically accomplished by synchronizing on some * object that naturally encapsulates the set. * If no such object exists, the set should be "wrapped" using the * {@link Collections#synchronizedSortedSet Collections.synchronizedSortedSet} * method.  This is best done at creation time, to prevent accidental * unsynchronized access to the set: <pre> *   SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));</pre> * * <p>The iterators returned by this class's {@code iterator} method are * <i>fail-fast</i>: if the set is modified at any time after the iterator is * created, in any way except through the iterator's own {@code remove} * method, the iterator will throw a {@link ConcurrentModificationException}. * Thus, in the face of concurrent modification, the iterator fails quickly * and cleanly, rather than risking arbitrary, non-deterministic behavior at * an undetermined time in the future. * * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed * as it is, generally speaking, impossible to make any hard guarantees in the * presence of unsynchronized concurrent modification.  Fail-fast iterators * throw {@code ConcurrentModificationException} on a best-effort basis. * Therefore, it would be wrong to write a program that depended on this * exception for its correctness:   <i>the fail-fast behavior of iterators * should be used only to detect bugs.</i> * * <p>This class is a member of the * <a href="{@docRoot}/../technotes/guides/collections/index.html"> * Java Collections Framework</a>. * * @param <E> the type of elements maintained by this set * * @author  Josh Bloch * @see     Collection * @see     Set * @see     HashSet * @see     Comparable * @see     Comparator * @see     TreeMap * @since   1.2 *//*基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。此实现为基本操作（add、remove 和 contains）提供受保证的 log(n) 时间开销。注意，如果要正确实现 Set 接口，则 set 维护的顺序（无论是否提供了显式比较器）必须与 equals 一致。（关于与 equals 一致 的精确定义，请参阅 Comparable 或 Comparator。）这是因为 Set 接口是按照 equals 操作定义的，但 TreeSet 实例使用它的 compareTo（或 compare）方法对所有元素进行比较，因此从 set 的观点来看，此方法认为相等的两个元素就是相等的。即使 set 的顺序与 equals 不一致，其行为也是 定义良好的；它只是违背了 Set 接口的常规协定。注意，此实现不是同步的。如果多个线程同时访问一个 TreeSet，而其中至少一个线程修改了该 set，那么它必须 外部同步。这一般是通过对自然封装该 set 的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSortedSet 方法来“包装”该 set。此操作最好在创建时进行，以防止对 set 的意外非同步访问：   SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));此类的 iterator方法返回的迭代器是快速失败 的：在创建迭代器之后，如果从结构上对 set 进行修改，除非通过迭代器自身的 remove 方法，否则在其他任何时间以任何方式进行修改都将导致迭代器抛出 ConcurrentModificationException。因此，对于并发的修改，迭代器很快就完全失败，而不会冒着在将来不确定的时间发生不确定行为的风险。注意，迭代器的快速失败行为无法得到保证，一般来说，存在不同步的并发修改时，不可能作出任何肯定的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。 */public class TreeSet<E> extends AbstractSet<E>    implements NavigableSet<E>, Cloneable, java.io.Serializable{    /**     * The backing map.     */    //底层是NavigableMap实现的，默认是TreeMap    private transient NavigableMap<E,Object> m;    // Dummy value to associate with an Object in the backing Map    //设置为value的对象    private static final Object PRESENT = new Object();    /**     * Constructs a set backed by the specified navigable map.     */    //构造器，传入底层map    TreeSet(NavigableMap<E,Object> m) {        this.m = m;    }    /**     * Constructs a new, empty tree set, sorted according to the     * natural ordering of its elements.  All elements inserted into     * the set must implement the {@link Comparable} interface.     * Furthermore, all such elements must be <i>mutually     * comparable</i>: {@code e1.compareTo(e2)} must not throw a     * {@code ClassCastException} for any elements {@code e1} and     * {@code e2} in the set.  If the user attempts to add an element     * to the set that violates this constraint (for example, the user     * attempts to add a string element to a set whose elements are     * integers), the {@code add} call will throw a     * {@code ClassCastException}.     */    //构造方法    public TreeSet() {        //默认底层map是TreeMap        this(new TreeMap<E,Object>());    }    /**     * Constructs a new, empty tree set, sorted according to the specified     * comparator.  All elements inserted into the set must be <i>mutually     * comparable</i> by the specified comparator: {@code comparator.compare(e1,     * e2)} must not throw a {@code ClassCastException} for any elements     * {@code e1} and {@code e2} in the set.  If the user attempts to add     * an element to the set that violates this constraint, the     * {@code add} call will throw a {@code ClassCastException}.     *     * @param comparator the comparator that will be used to order this set.     *        If {@code null}, the {@linkplain Comparable natural     *        ordering} of the elements will be used.     */    //构造方法，传入比较器    public TreeSet(Comparator<? super E> comparator) {        this(new TreeMap<>(comparator));    }    /**     * Constructs a new tree set containing the elements in the specified     * collection, sorted according to the <i>natural ordering</i> of its     * elements.  All elements inserted into the set must implement the     * {@link Comparable} interface.  Furthermore, all such elements must be     * <i>mutually comparable</i>: {@code e1.compareTo(e2)} must not throw a     * {@code ClassCastException} for any elements {@code e1} and     * {@code e2} in the set.     *     * @param c collection whose elements will comprise the new set     * @throws ClassCastException if the elements in {@code c} are     *         not {@link Comparable}, or are not mutually comparable     * @throws NullPointerException if the specified collection is null     */    //构造方法，传入容器    public TreeSet(Collection<? extends E> c) {        this();        addAll(c);    }    /**     * Constructs a new tree set containing the same elements and     * using the same ordering as the specified sorted set.     *     * @param s sorted set whose elements will comprise the new set     * @throws NullPointerException if the specified sorted set is null     */    //构造方法，传入排序的Set    public TreeSet(SortedSet<E> s) {        this(s.comparator());        addAll(s);    }    /**     * Returns an iterator over the elements in this set in ascending order.     *     * @return an iterator over the elements in this set in ascending order     */    //返回迭代器    public Iterator<E> iterator() {        //调用底层的map，返回map中的key组成的set的迭代器        return m.navigableKeySet().iterator();    }    /**     * Returns an iterator over the elements in this set in descending order.     *     * @return an iterator over the elements in this set in descending order     * @since 1.6     */    //返回逆序的迭代器    public Iterator<E> descendingIterator() {        //调用底层的map，返回map中的逆序的key组成的set的迭代器        return m.descendingKeySet().iterator();    }    /**     * @since 1.6     */    //返回逆序的TreeSet    public NavigableSet<E> descendingSet() {        //调用底层的map，获取逆序的map后创建TreeSet        return new TreeSet<>(m.descendingMap());    }    /**     * Returns the number of elements in this set (its cardinality).     *     * @return the number of elements in this set (its cardinality)     */    //获取TreeSet的容量    public int size() {        //调用底层map的size()        return m.size();    }    /**     * Returns {@code true} if this set contains no elements.     *     * @return {@code true} if this set contains no elements     */    //判断是否为空    public boolean isEmpty() {        return m.isEmpty();    }    /**     * Returns {@code true} if this set contains the specified element.     * More formally, returns {@code true} if and only if this set     * contains an element {@code e} such that     * <tt>(o==null ? e==null : o.equals(e))</tt>.     *     * @param o object to be checked for containment in this set     * @return {@code true} if this set contains the specified element     * @throws ClassCastException if the specified object cannot be compared     *         with the elements currently in the set     * @throws NullPointerException if the specified element is null     *         and this set uses natural ordering, or its comparator     *         does not permit null elements     */    //判断是否包含对象o    public boolean contains(Object o) {        //调用底层map的containsKey        return m.containsKey(o);    }    /**     * Adds the specified element to this set if it is not already present.     * More formally, adds the specified element {@code e} to this set if     * the set contains no element {@code e2} such that     * <tt>(e==null ? e2==null : e.equals(e2))</tt>.     * If this set already contains the element, the call leaves the set     * unchanged and returns {@code false}.     *     * @param e element to be added to this set     * @return {@code true} if this set did not already contain the specified     *         element     * @throws ClassCastException if the specified object cannot be compared     *         with the elements currently in this set     * @throws NullPointerException if the specified element is null     *         and this set uses natural ordering, or its comparator     *         does not permit null elements     */    //添加元素    public boolean add(E e) {        //将e设为key,PRESENT设为value        return m.put(e, PRESENT)==null;    }    /**     * Removes the specified element from this set if it is present.     * More formally, removes an element {@code e} such that     * <tt>(o==null ? e==null : o.equals(e))</tt>,     * if this set contains such an element.  Returns {@code true} if     * this set contained the element (or equivalently, if this set     * changed as a result of the call).  (This set will not contain the     * element once the call returns.)     *     * @param o object to be removed from this set, if present     * @return {@code true} if this set contained the specified element     * @throws ClassCastException if the specified object cannot be compared     *         with the elements currently in this set     * @throws NullPointerException if the specified element is null     *         and this set uses natural ordering, or its comparator     *         does not permit null elements     */    //移除调o    public boolean remove(Object o) {        return m.remove(o)==PRESENT;    }    /**     * Removes all of the elements from this set.     * The set will be empty after this call returns.     */    //清除掉容器中的元素    public void clear() {        m.clear();    }    /**     * Adds all of the elements in the specified collection to this set.     *     * @param c collection containing elements to be added to this set     * @return {@code true} if this set changed as a result of the call     * @throws ClassCastException if the elements provided cannot be compared     *         with the elements currently in the set     * @throws NullPointerException if the specified collection is null or     *         if any element is null and this set uses natural ordering, or     *         its comparator does not permit null elements     */    //将容器e中的元素添加到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))) {                //为TreeSet添加元素                map.addAllForTreeSet(set, PRESENT);                return true;            }        }        return super.addAll(c);    }    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if {@code fromElement} or {@code toElement}     *         is null and this set uses natural ordering, or its comparator     *         does not permit null elements     * @throws IllegalArgumentException {@inheritDoc}     * @since 1.6     */    //返回从fromElement 到 toElement 的元素    public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,                                  E toElement,   boolean toInclusive) {        //调用底层map的subMap方法        return new TreeSet<>(m.subMap(fromElement, fromInclusive,                                       toElement,   toInclusive));    }    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if {@code toElement} is null and     *         this set uses natural ordering, or its comparator does     *         not permit null elements     * @throws IllegalArgumentException {@inheritDoc}     * @since 1.6     */    //返回比toElement小的元素，如果inclusive为true，则toElement也包含    public NavigableSet<E> headSet(E toElement, boolean inclusive) {        //调用底层map的方法        return new TreeSet<>(m.headMap(toElement, inclusive));    }    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if {@code fromElement} is null and     *         this set uses natural ordering, or its comparator does     *         not permit null elements     * @throws IllegalArgumentException {@inheritDoc}     * @since 1.6     */    //返回比fromElement大（inclusive==true,则fromElement包含）的元素    public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {        //调用底层map的方法        return new TreeSet<>(m.tailMap(fromElement, inclusive));    }    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if {@code fromElement} or     *         {@code toElement} is null and this set uses natural ordering,     *         or its comparator does not permit null elements     * @throws IllegalArgumentException {@inheritDoc}     */    //返回[fromElement， toElement)的Set    public SortedSet<E> subSet(E fromElement, E toElement) {        return subSet(fromElement, true, toElement, false);    }    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if {@code toElement} is null     *         and this set uses natural ordering, or its comparator does     *         not permit null elements     * @throws IllegalArgumentException {@inheritDoc}     */    //返回比toElemeent小的元素组成的Set    public SortedSet<E> headSet(E toElement) {        return headSet(toElement, false);    }    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if {@code fromElement} is null     *         and this set uses natural ordering, or its comparator does     *         not permit null elements     * @throws IllegalArgumentException {@inheritDoc}     */    //返回大于等于fromElement的元素组成的Set    public SortedSet<E> tailSet(E fromElement) {        return tailSet(fromElement, true);    }    public Comparator<? super E> comparator() {        //返回比较器        return m.comparator();    }    /**     * @throws NoSuchElementException {@inheritDoc}     */    //返回第一个元素，即最小的元素    public E first() {        return m.firstKey();    }    /**     * @throws NoSuchElementException {@inheritDoc}     */    //返回最后一个元素，即最大的元素    public E last() {        return m.lastKey();    }    // NavigableSet API methods    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if the specified element is null     *         and this set uses natural ordering, or its comparator     *         does not permit null elements     * @since 1.6     */    //返回比e小的最大的元素    public E lower(E e) {        return m.lowerKey(e);    }    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if the specified element is null     *         and this set uses natural ordering, or its comparator     *         does not permit null elements     * @since 1.6     */    //返回小于等于e的最大的元素    public E floor(E e) {        return m.floorKey(e);    }    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if the specified element is null     *         and this set uses natural ordering, or its comparator     *         does not permit null elements     * @since 1.6     */    //返回大于等于e的最小的元素    public E ceiling(E e) {        return m.ceilingKey(e);    }    /**     * @throws ClassCastException {@inheritDoc}     * @throws NullPointerException if the specified element is null     *         and this set uses natural ordering, or its comparator     *         does not permit null elements     * @since 1.6     */    //返回大于e的最小的元素    public E higher(E e) {        return m.higherKey(e);    }    /**     * @since 1.6     */    //返回并移除掉第一个元素    public E pollFirst() {        Map.Entry<E,?> e = m.pollFirstEntry();        return (e == null) ? null : e.getKey();    }    /**     * @since 1.6     */    //返回并移除掉最后一个元素    public E pollLast() {        Map.Entry<E,?> e = m.pollLastEntry();        return (e == null) ? null : e.getKey();    }    /**     * Returns a shallow copy of this {@code TreeSet} instance. (The elements     * themselves are not cloned.)     *     * @return a shallow copy of this set     */    //克隆    @SuppressWarnings("unchecked")    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;    }    /**     * Save the state of the {@code TreeSet} instance to a stream (that is,     * serialize it).     *     * @serialData Emits the comparator used to order this set, or     *             {@code null} if it obeys its elements' natural ordering     *             (Object), followed by the size of the set (the number of     *             elements it contains) (int), followed by all of its     *             elements (each an Object) in order (as determined by the     *             set's Comparator, or by the elements' natural ordering if     *             the set has no Comparator).     */    //用于序列化的writeObject    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);    }    /**     * Reconstitute the {@code TreeSet} instance from a stream (that is,     * deserialize it).     */    //用于序列化的readObject    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        TreeMap<E,Object> tm = new TreeMap<>(c);        m = tm;        // Read in size        //读取大小        int size = s.readInt();        //初始化TreeSet        tm.readTreeSet(size, s, PRESENT);    }    /**     * Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>     * and <em>fail-fast</em> {@link Spliterator} over the elements in this     * set.     *     * <p>The {@code Spliterator} reports {@link Spliterator#SIZED},     * {@link Spliterator#DISTINCT}, {@link Spliterator#SORTED}, and     * {@link Spliterator#ORDERED}.  Overriding implementations should document     * the reporting of additional characteristic values.     *     * <p>The spliterator's comparator (see     * {@link java.util.Spliterator#getComparator()}) is {@code null} if     * the tree set's comparator (see {@link #comparator()}) is {@code null}.     * Otherwise, the spliterator's comparator is the same as or imposes the     * same total ordering as the tree set's comparator.     *     * @return a {@code Spliterator} over the elements in this set     * @since 1.8     */    public Spliterator<E> spliterator() {        return TreeMap.keySpliteratorFor(m);    }    private static final long serialVersionUID = -2479143000061671589L;}