<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">/*
 * @(#)SortedSet.java	1.15 00/02/02
 *
 * Copyright 1998-2000 Sun Microsystems, Inc. All Rights Reserved.
 * 
 * This software is the proprietary information of Sun Microsystems, Inc.  
 * Use is subject to license terms.
 * 
 */

package java.util;

/**
 * A set that further guarantees that its iterator will traverse the set in
 * ascending element order, sorted according to the &lt;i&gt;natural ordering&lt;/i&gt; of
 * its elements (see Comparable), or by a Comparator provided at sorted set
 * creation time.  Several additional operations are provided to take
 * advantage of the ordering.  (This interface is the set analogue of
 * SortedMap.)&lt;p&gt;
 *
 * All elements inserted into an sorted set must implement the Comparable
 * interface (or be accepted by the specified Comparator).  Furthermore, all
 * such elements must be &lt;i&gt;mutually comparable&lt;/i&gt;: &lt;tt&gt;e1.compareTo(e2)&lt;/tt&gt;
 * (or &lt;tt&gt;comparator.compare(e1, e2)&lt;/tt&gt;) must not throw a
 * &lt;tt&gt;ClassCastException&lt;/tt&gt; for any elements &lt;tt&gt;e1&lt;/tt&gt; and &lt;tt&gt;e2&lt;/tt&gt; in
 * the sorted set.  Attempts to violate this restriction will cause the
 * offending method or constructor invocation to throw a
 * &lt;tt&gt;ClassCastException&lt;/tt&gt;.&lt;p&gt;
 *
 * Note that the ordering maintained by a sorted set (whether or not an
 * explicit comparator is provided) must be &lt;i&gt;consistent with equals&lt;/i&gt; if
 * the sorted set is to correctly implement the &lt;tt&gt;Set&lt;/tt&gt; interface.  (See
 * the &lt;tt&gt;Comparable&lt;/tt&gt; interface or &lt;tt&gt;Comparator&lt;/tt&gt; interface for a
 * precise definition of &lt;i&gt;consistent with equals&lt;/i&gt;.)  This is so because
 * the &lt;tt&gt;Set&lt;/tt&gt; interface is defined in terms of the &lt;tt&gt;equals&lt;/tt&gt;
 * operation, but a sorted set performs all element comparisons using its
 * &lt;tt&gt;compareTo&lt;/tt&gt; (or &lt;tt&gt;compare&lt;/tt&gt;) method, so two elements that are
 * deemed equal by this method are, from the standpoint of the sorted set,
 * equal.  The behavior of a sorted set &lt;i&gt;is&lt;/i&gt; well-defined even if its
 * ordering is inconsistent with equals; it just fails to obey the general
 * contract of the &lt;tt&gt;Set&lt;/tt&gt; interface.&lt;p&gt;
 *
 * All general-purpose sorted set implementation classes should provide four
 * "standard" constructors: 1) A void (no arguments) constructor, which
 * creates an empty sorted set sorted according to the &lt;i&gt;natural order&lt;/i&gt; of
 * its elements.  2) A constructor with a single argument of type
 * &lt;tt&gt;Comparator&lt;/tt&gt;, which creates an empty sorted set sorted according to
 * the specified comparator.  3) A constructor with a single argument of type
 * &lt;tt&gt;Collection&lt;/tt&gt;, which creates a new sorted set with the same elements
 * as its argument, sorted according to the elements' natural ordering.  4) A
 * constructor with a single argument of type &lt;tt&gt;SortedSet&lt;/tt&gt;, which
 * creates a new sorted set with the same elements and the same ordering as
 * the input sorted set.  There is no way to enforce this recommendation (as
 * interfaces cannot contain constructors) but the SDK implementation (the
 * &lt;tt&gt;TreeSet&lt;/tt&gt; class) complies.
 *
 * @author  Josh Bloch
 * @version 1.15, 02/02/00
 * @see Set
 * @see TreeSet
 * @see SortedMap
 * @see Collection
 * @see Comparable
 * @see Comparator
 * @see java.lang.ClassCastException
 * @since 1.2
 */

public interface SortedSet extends Set {
    /**
     * Returns the comparator associated with this sorted set, or
     * &lt;tt&gt;null&lt;/tt&gt; if it uses its elements' natural ordering.
     *
     * @return the comparator associated with this sorted set, or
     * 	       &lt;tt&gt;null&lt;/tt&gt; if it uses its elements' natural ordering.
     */
    Comparator comparator();

    /**
     * Returns a view of the portion of this sorted set whose elements range
     * from &lt;tt&gt;fromElement&lt;/tt&gt;, inclusive, to &lt;tt&gt;toElement&lt;/tt&gt;, exclusive.
     * (If &lt;tt&gt;fromElement&lt;/tt&gt; and &lt;tt&gt;toElement&lt;/tt&gt; are equal, the returned
     * sorted set is empty.)  The returned sorted set is backed by this sorted
     * set, so changes in the returned sorted set are reflected in this sorted
     * set, and vice-versa.  The returned sorted set supports all optional set
     * operations that this sorted set supports.&lt;p&gt;
     *
     * The sorted set returned by this method will throw an
     * &lt;tt&gt;IllegalArgumentException&lt;/tt&gt; if the user attempts to insert a
     * element outside the specified range.&lt;p&gt;
     * 
     * Note: this method always returns a &lt;i&gt;half-open range&lt;/i&gt; (which
     * includes its low endpoint but not its high endpoint).  If you need a
     * &lt;i&gt;closed range&lt;/i&gt; (which includes both endpoints), and the element
     * type allows for calculation of the successor a given value, merely
     * request the subrange from &lt;tt&gt;lowEndpoint&lt;/tt&gt; to
     * &lt;tt&gt;successor(highEndpoint)&lt;/tt&gt;.  For example, suppose that &lt;tt&gt;s&lt;/tt&gt;
     * is a sorted set of strings.  The following idiom obtains a view
     * containing all of the strings in &lt;tt&gt;s&lt;/tt&gt; from &lt;tt&gt;low&lt;/tt&gt; to
     * &lt;tt&gt;high&lt;/tt&gt;, inclusive: &lt;pre&gt;
     * SortedSet sub = s.subSet(low, high+"\0");
     * &lt;/pre&gt;
     * 
     * A similar technique can be used to generate an &lt;i&gt;open range&lt;/i&gt; (which
     * contains neither endpoint).  The following idiom obtains a view
     * containing all of the Strings in &lt;tt&gt;s&lt;/tt&gt; from &lt;tt&gt;low&lt;/tt&gt; to
     * &lt;tt&gt;high&lt;/tt&gt;, exclusive: &lt;pre&gt;
     * SortedSet sub = s.subSet(low+"\0", high);
     * &lt;/pre&gt;
     *
     * @param fromElement low endpoint (inclusive) of the subSet.
     * @param toElement high endpoint (exclusive) of the subSet.
     * @return a view of the specified range within this sorted set.
     * 
     * @throws ClassCastException if &lt;tt&gt;fromElement&lt;/tt&gt; and
     *         &lt;tt&gt;toElement&lt;/tt&gt; 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 &lt;tt&gt;fromElement&lt;/tt&gt; or
     *         &lt;tt&gt;toElement&lt;/tt&gt; cannot be compared to elements currently in
     *         the set.
     * @throws IllegalArgumentException if &lt;tt&gt;fromElement&lt;/tt&gt; is greater than
     *         &lt;tt&gt;toElement&lt;/tt&gt;; or if this set is itself a subSet, headSet,
     *         or tailSet, and &lt;tt&gt;fromElement&lt;/tt&gt; or &lt;tt&gt;toElement&lt;/tt&gt; are
     *         not within the specified range of the subSet, headSet, or
     *         tailSet.
     * @throws NullPointerException if &lt;tt&gt;fromElement&lt;/tt&gt; or
     *	       &lt;tt&gt;toElement&lt;/tt&gt; is &lt;tt&gt;null&lt;/tt&gt; and this sorted set does
     *	       not tolerate &lt;tt&gt;null&lt;/tt&gt; elements.
     */
    SortedSet subSet(Object fromElement, Object toElement);

    /**
     * Returns a view of the portion of this sorted set whose elements are
     * strictly less than &lt;tt&gt;toElement&lt;/tt&gt;.  The returned sorted set is
     * backed by this sorted set, so changes in the returned sorted set are
     * reflected in this sorted set, and vice-versa.  The returned sorted set
     * supports all optional set operations.&lt;p&gt;
     *
     * The sorted set returned by this method will throw an
     * &lt;tt&gt;IllegalArgumentException&lt;/tt&gt; if the user attempts to insert a
     * element outside the specified range.&lt;p&gt;
     *
     * Note: this method always returns a view that does not contain its
     * (high) endpoint.  If you need a view that does contain this endpoint,
     * and the element type allows for calculation of the successor a given
     * value, merely request a headSet bounded by
     * &lt;tt&gt;successor(highEndpoint)&lt;/tt&gt;.  For example, suppose that &lt;tt&gt;s&lt;/tt&gt;
     * is a sorted set of strings.  The following idiom obtains a view
     * containing all of the strings in &lt;tt&gt;s&lt;/tt&gt; that are less than or equal
     * to &lt;tt&gt;high&lt;/tt&gt;:
     * 	    &lt;pre&gt;    SortedSet head = s.headSet(high+"\0");&lt;/pre&gt;
     *
     * @param toElement high endpoint (exclusive) of the headSet.
     * @return a view of the specified initial range of this sorted set.
     * @throws ClassCastException if &lt;tt&gt;toElement&lt;/tt&gt; is not compatible
     *         with this set's comparator (or, if the set has no comparator,
     *         if &lt;tt&gt;toElement&lt;/tt&gt; does not implement &lt;tt&gt;Comparable&lt;/tt&gt;).
     *         Implementations may, but are not required to, throw this
     *	       exception if &lt;tt&gt;toElement&lt;/tt&gt; cannot be compared to elements
     *         currently in the set.
     * @throws NullPointerException if &lt;tt&gt;toElement&lt;/tt&gt; is &lt;tt&gt;null&lt;/tt&gt; and
     *	       this sorted set does not tolerate &lt;tt&gt;null&lt;/tt&gt; elements.
     * @throws IllegalArgumentException if this set is itself a subSet,
     *         headSet, or tailSet, and &lt;tt&gt;toElement&lt;/tt&gt; is not within the
     *         specified range of the subSet, headSet, or tailSet.
     */
    SortedSet headSet(Object toElement);

    /**
     * Returns a view of the portion of this sorted set whose elements are
     * greater than or equal to &lt;tt&gt;fromElement&lt;/tt&gt;.  The returned sorted set
     * is backed by this sorted set, so changes in the returned sorted set are
     * reflected in this sorted set, and vice-versa.  The returned sorted set
     * supports all optional set operations.&lt;p&gt;
     *
     * The sorted set returned by this method will throw an
     * &lt;tt&gt;IllegalArgumentException&lt;/tt&gt; if the user attempts to insert a
     * element outside the specified range.&lt;p&gt;
     *
     * Note: this method always returns a view that contains its (low)
     * endpoint.  If you need a view that does not contain this endpoint, and
     * the element type allows for calculation of the successor a given value,
     * merely request a tailSet bounded by &lt;tt&gt;successor(lowEndpoint)&lt;/tt&gt;.
     * For example, suppose that &lt;tt&gt;s&lt;/tt&gt; is a sorted set of strings.  The
     * following idiom obtains a view containing all of the strings in
     * &lt;tt&gt;s&lt;/tt&gt; that are strictly greater than &lt;tt&gt;low&lt;/tt&gt;:
     * 
     * 	    &lt;pre&gt;    SortedSet tail = s.tailSet(low+"\0");&lt;/pre&gt;
     *
     * @param fromElement low endpoint (inclusive) of the tailSet.
     * @return a view of the specified final range of this sorted set.
     * @throws ClassCastException if &lt;tt&gt;fromElement&lt;/tt&gt; is not compatible
     *         with this set's comparator (or, if the set has no comparator,
     *         if &lt;tt&gt;fromElement&lt;/tt&gt; does not implement &lt;tt&gt;Comparable&lt;/tt&gt;).
     *         Implementations may, but are not required to, throw this
     *	       exception if &lt;tt&gt;fromElement&lt;/tt&gt; cannot be compared to elements
     *         currently in the set.
     * @throws NullPointerException if &lt;tt&gt;fromElement&lt;/tt&gt; is &lt;tt&gt;null&lt;/tt&gt;
     *	       and this sorted set does not tolerate &lt;tt&gt;null&lt;/tt&gt; elements.
     * @throws IllegalArgumentException if this set is itself a subSet,
     *         headSet, or tailSet, and &lt;tt&gt;fromElement&lt;/tt&gt; is not within the
     *         specified range of the subSet, headSet, or tailSet.
     */
    SortedSet tailSet(Object fromElement);

    /**
     * Returns the first (lowest) element currently in this sorted set.
     *
     * @return the first (lowest) element currently in this sorted set.
     * @throws    NoSuchElementException sorted set is empty.
     */
    Object first();

    /**
     * Returns the last (highest) element currently in this sorted set.
     *
     * @return the last (highest) element currently in this sorted set.
     * @throws    NoSuchElementException sorted set is empty.
     */
    Object last();
}
</pre></body></html>