java.lang.Object
- java.util.AbstractCollection<E>
- - com.google.common.collect.ImmutableCollection<E>
  - - com.google.common.collect.ImmutableSet<E>
    - - com.google.common.collect.ImmutableSortedSet<E>

All Implemented Interfaces:

Serializable, Iterable<E>, Collection<E>, NavigableSet<E>, Set<E>, SortedSet<E>

Direct Known Subclasses:

ContiguousSet
```
@GwtCompatible(serializable=true,
               emulated=true)
public abstract class ImmutableSortedSet<E>
extends ImmutableSet<E>
implements NavigableSet<E>
```
A NavigableSet whose contents will never change, with many other important properties detailed at ImmutableCollection.
Warning: as with any sorted collection, you are strongly advised not to use a Comparator or Comparable type whose comparison behavior is inconsistent with equals. That is, a.compareTo(b) or comparator.compare(a, b) should equal zero if and only if a.equals(b). If this advice is not followed, the resulting collection will not correctly obey its specification.
See the Guava User Guide article on immutable collections.

Since:

2.0 (implements NavigableSet since 12.0)

Author:

Jared Levy, Louis Wasserman

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`ImmutableSortedSet.Builder<E>`	A builder for creating immutable sorted set instances, especially `public static final` sets ("constant sets"), with a given comparator.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`ImmutableList<E>`	`asList()`	Returns an `ImmutableList` containing the same elements, in the same order, as this collection.
`static <E> ImmutableSortedSet.Builder<E>`	`builder()`	Deprecated. Use `naturalOrder()`, which offers better type-safety.
`static <E> ImmutableSortedSet.Builder<E>`	`builderWithExpectedSize(int expectedSize)`	Deprecated. Not supported by ImmutableSortedSet.
`E`	`ceiling(E e)`	Returns the least element in this set greater than or equal to the given element, or `null` if there is no such element.
`Comparator<? super E>`	`comparator()`	Returns the comparator that orders the elements, which is `Ordering.natural()` when the natural ordering of the elements is used.
`static <E extends Comparable<? super E>> ImmutableSortedSet<E>`	`copyOf(E[] elements)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`copyOf(E[] elements)`	Deprecated. Pass parameters of type `Comparable` to use `copyOf(Comparable[])`.
`static <E> ImmutableSortedSet<E>`	`copyOf(Iterable<? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`copyOf(Collection<? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`copyOf(Comparator<? super E> comparator, Iterable<? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by the given `Comparator`.
`static <E> ImmutableSortedSet<E>`	`copyOf(Comparator<? super E> comparator, Collection<? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by the given `Comparator`.
`static <E> ImmutableSortedSet<E>`	`copyOf(Comparator<? super E> comparator, Iterator<? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by the given `Comparator`.
`static <E> ImmutableSortedSet<E>`	`copyOf(Iterator<? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`copyOfSorted(SortedSet<E> sortedSet)`	Returns an immutable sorted set containing the elements of a sorted set, sorted by the same `Comparator`.
`abstract UnmodifiableIterator<E>`	`descendingIterator()`	Returns an iterator over the elements in this set, in descending order.
`ImmutableSortedSet<E>`	`descendingSet()`	Returns a reverse order view of the elements contained in this set.
`E`	`first()`	Returns the first (lowest) element currently in this set.
`E`	`floor(E e)`	Returns the greatest element in this set less than or equal to the given element, or `null` if there is no such element.
`ImmutableSortedSet<E>`	`headSet(E toElement)`	Returns a view of the portion of this set whose elements are strictly less than `toElement`.
`ImmutableSortedSet<E>`	`headSet(E toElement, boolean inclusive)`	Returns a view of the portion of this set whose elements are less than (or equal to, if `inclusive` is true) `toElement`.
`E`	`higher(E e)`	Returns the least element in this set strictly greater than the given element, or `null` if there is no such element.
`abstract UnmodifiableIterator<E>`	`iterator()`	Returns an unmodifiable iterator across the elements in this collection.
`E`	`last()`	Returns the last (highest) element currently in this set.
`E`	`lower(E e)`	Returns the greatest element in this set strictly less than the given element, or `null` if there is no such element.
`static <E extends Comparable<?>> ImmutableSortedSet.Builder<E>`	`naturalOrder()`	Returns a builder that creates immutable sorted sets whose elements are ordered by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`of()`	Returns the empty immutable sorted set.
`static <E extends Comparable<? super E>> ImmutableSortedSet<E>`	`of(E element)`	Returns an immutable sorted set containing a single element.
`static <E> ImmutableSortedSet<E>`	`of(E element)`	Deprecated. Pass a parameter of type `Comparable` to use `of(Comparable)`.
`static <E extends Comparable<? super E>> ImmutableSortedSet<E>`	`of(E e1, E e2)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`of(E e1, E e2)`	Deprecated. Pass the parameters of type `Comparable` to use `of(Comparable, Comparable)`.
`static <E extends Comparable<? super E>> ImmutableSortedSet<E>`	`of(E e1, E e2, E e3)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`of(E e1, E e2, E e3)`	Deprecated. Pass the parameters of type `Comparable` to use `of(Comparable, Comparable, Comparable)`.
`static <E extends Comparable<? super E>> ImmutableSortedSet<E>`	`of(E e1, E e2, E e3, E e4)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`of(E e1, E e2, E e3, E e4)`	Deprecated. Pass the parameters of type `Comparable` to use `of(Comparable, Comparable, Comparable, Comparable)`.
`static <E extends Comparable<? super E>> ImmutableSortedSet<E>`	`of(E e1, E e2, E e3, E e4, E e5)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`of(E e1, E e2, E e3, E e4, E e5)`	Deprecated. Pass the parameters of type `Comparable` to use `of( Comparable, Comparable, Comparable, Comparable, Comparable)`.
`static <E extends Comparable<? super E>> ImmutableSortedSet<E>`	`of(E e1, E e2, E e3, E e4, E e5, E e6, E... remaining)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`of(E e1, E e2, E e3, E e4, E e5, E e6, E... remaining)`	Deprecated. Pass the parameters of type `Comparable` to use `of(Comparable, Comparable, Comparable, Comparable, Comparable, Comparable, Comparable...)`.
`static <E> ImmutableSortedSet.Builder<E>`	`orderedBy(Comparator<E> comparator)`	Returns a builder that creates immutable sorted sets with an explicit comparator.
`E`	`pollFirst()`	Deprecated. Unsupported operation.
`E`	`pollLast()`	Deprecated. Unsupported operation.
`static <E extends Comparable<?>> ImmutableSortedSet.Builder<E>`	`reverseOrder()`	Returns a builder that creates immutable sorted sets whose elements are ordered by the reverse of their natural ordering.
`Spliterator<E>`	`spliterator()`	Creates a `Spliterator` over the elements in this collection.
`ImmutableSortedSet<E>`	`subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)`	Returns a view of the portion of this set whose elements range from `fromElement` to `toElement`.
`ImmutableSortedSet<E>`	`subSet(E fromElement, E toElement)`	Returns a view of the portion of this set whose elements range from `fromElement`, inclusive, to `toElement`, exclusive.
`ImmutableSortedSet<E>`	`tailSet(E fromElement)`	Returns a view of the portion of this set whose elements are greater than or equal to `fromElement`.
`ImmutableSortedSet<E>`	`tailSet(E fromElement, boolean inclusive)`	Returns a view of the portion of this set whose elements are greater than (or equal to, if `inclusive` is true) `fromElement`.
`static <E> Collector<E,?,ImmutableSet<E>>`	`toImmutableSet()`	Deprecated. Use `toImmutableSortedSet(java.util.Comparator<? super E>)`.
`static <E> Collector<E,?,ImmutableSortedSet<E>>`	`toImmutableSortedSet(Comparator<? super E> comparator)`	Returns a `Collector` that accumulates the input elements into a new `ImmutableSortedSet`, ordered by the specified comparator.

Methods inherited from class com.google.common.collect.ImmutableSet
equals, hashCode

Methods inherited from class com.google.common.collect.ImmutableCollection
add, addAll, clear, contains, remove, removeAll, removeIf, retainAll, toArray, toArray

Methods inherited from class java.util.AbstractCollection
containsAll, isEmpty, size, toString

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream, toArray

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface java.util.Set
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, remove, removeAll, retainAll, size, toArray, toArray

- Method Detail
  - toImmutableSortedSet
```
public static <E> Collector<E,?,ImmutableSortedSet<E>> toImmutableSortedSet(Comparator<? super E> comparator)
```
    Returns a Collector that accumulates the input elements into a new ImmutableSortedSet, ordered by the specified comparator.
    If the elements contain duplicates (according to the comparator), only the first duplicate in encounter order will appear in the result.
    
    Since:
    
    21.0
  - of
```
public static <E> ImmutableSortedSet<E> of()
```
    Returns the empty immutable sorted set.
    Performance note: the instance returned is a singleton.
    
    Type Parameters:
    
    E - the Set's element type
    
    Returns:
    
    an empty Set
  - of
```
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E element)
```
    Returns an immutable sorted set containing a single element.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    element - the single element
    
    Returns:
    
    a Set containing the specified element
  - of
```
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1,
                                                                         E e2)
```
    Returns an immutable sorted set containing the given elements sorted by their natural ordering. When multiple elements are equivalent according to Comparable.compareTo(T), only the first one specified is included.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    NullPointerException - if any element is null
  - of
```
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1,
                                                                         E e2,
                                                                         E e3)
```
    Returns an immutable sorted set containing the given elements sorted by their natural ordering. When multiple elements are equivalent according to Comparable.compareTo(T), only the first one specified is included.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    e3 - the third element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    NullPointerException - if any element is null
  - of
```
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1,
                                                                         E e2,
                                                                         E e3,
                                                                         E e4)
```
    Returns an immutable sorted set containing the given elements sorted by their natural ordering. When multiple elements are equivalent according to Comparable.compareTo(T), only the first one specified is included.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    e3 - the third element
    
    e4 - the fourth element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    NullPointerException - if any element is null
  - of
```
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1,
                                                                         E e2,
                                                                         E e3,
                                                                         E e4,
                                                                         E e5)
```
    Returns an immutable sorted set containing the given elements sorted by their natural ordering. When multiple elements are equivalent according to Comparable.compareTo(T), only the first one specified is included.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    e3 - the third element
    
    e4 - the fourth element
    
    e5 - the fifth element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    NullPointerException - if any element is null
  - of
```
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1,
                                                                         E e2,
                                                                         E e3,
                                                                         E e4,
                                                                         E e5,
                                                                         E e6,
                                                                         E... remaining)
```
    Returns an immutable sorted set containing the given elements sorted by their natural ordering. When multiple elements are equivalent according to Comparable.compareTo(T), only the first one specified is included.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    e3 - the third element
    
    e4 - the fourth element
    
    e5 - the fifth element
    
    e6 - the sixth element
    
    remaining - the seventh element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    NullPointerException - if any element is null
    
    Since:
    
    3.0 (source-compatible since 2.0)
  - copyOf
```
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> copyOf(E[] elements)
```
    Returns an immutable sorted set containing the given elements sorted by their natural ordering. When multiple elements are equivalent according to Comparable.compareTo(T), only the first one specified is included.
    
    Throws:
    
    NullPointerException - if any of elements is null
    
    Since:
    
    3.0
  - copyOf
```
public static <E> ImmutableSortedSet<E> copyOf(Iterable<? extends E> elements)
```
    Returns an immutable sorted set containing the given elements sorted by their natural ordering. When multiple elements are equivalent according to compareTo(), only the first one specified is included. To create a copy of a SortedSet that preserves the comparator, call copyOfSorted(java.util.SortedSet<E>) instead. This method iterates over elements at most once.
    Note that if s is a Set<String>, then ImmutableSortedSet.copyOf(s) returns an ImmutableSortedSet<String> containing each of the strings in s, while ImmutableSortedSet.of(s) returns an ImmutableSortedSet<Set<String>> containing one element (the given set itself).
    Despite the method name, this method attempts to avoid actually copying the data when it is safe to do so. The exact circumstances under which a copy will or will not be performed are undocumented and subject to change.
    This method is not type-safe, as it may be called on elements that are not mutually comparable.
    
    Throws:
    
    ClassCastException - if the elements are not mutually comparable
    
    NullPointerException - if any of elements is null
  - copyOf
```
public static <E> ImmutableSortedSet<E> copyOf(Collection<? extends E> elements)
```
    Returns an immutable sorted set containing the given elements sorted by their natural ordering. When multiple elements are equivalent according to compareTo(), only the first one specified is included. To create a copy of a SortedSet that preserves the comparator, call copyOfSorted(java.util.SortedSet<E>) instead. This method iterates over elements at most once.
    Note that if s is a Set<String>, then ImmutableSortedSet.copyOf(s) returns an ImmutableSortedSet<String> containing each of the strings in s, while ImmutableSortedSet.of(s) returns an ImmutableSortedSet<Set<String>> containing one element (the given set itself).
    Note: Despite what the method name suggests, if elements is an ImmutableSortedSet, it may be returned instead of a copy.
    This method is not type-safe, as it may be called on elements that are not mutually comparable.
    This method is safe to use even when elements is a synchronized or concurrent collection that is currently being modified by another thread.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    elements - a Collection from which elements are drawn, must be non-null
    
    Returns:
    
    a Set containing the elements of the given Collection
    
    Throws:
    
    ClassCastException - if the elements are not mutually comparable
    
    NullPointerException - if any of elements is null
    
    Since:
    
    7.0 (source-compatible since 2.0)
  - copyOf
```
public static <E> ImmutableSortedSet<E> copyOf(Iterator<? extends E> elements)
```
    Returns an immutable sorted set containing the given elements sorted by their natural ordering. When multiple elements are equivalent according to compareTo(), only the first one specified is included.
    This method is not type-safe, as it may be called on elements that are not mutually comparable.
    
    Throws:
    
    ClassCastException - if the elements are not mutually comparable
    
    NullPointerException - if any of elements is null
  - copyOf
```
public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> comparator,
                                               Iterator<? extends E> elements)
```
    Returns an immutable sorted set containing the given elements sorted by the given Comparator. When multiple elements are equivalent according to compareTo(), only the first one specified is included.
    
    Throws:
    
    NullPointerException - if comparator or any of elements is null
  - copyOf
```
public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> comparator,
                                               Iterable<? extends E> elements)
```
    Returns an immutable sorted set containing the given elements sorted by the given Comparator. When multiple elements are equivalent according to compare(), only the first one specified is included. This method iterates over elements at most once.
    Despite the method name, this method attempts to avoid actually copying the data when it is safe to do so. The exact circumstances under which a copy will or will not be performed are undocumented and subject to change.
    
    Throws:
    
    NullPointerException - if comparator or any of elements is null
  - copyOf
```
public static <E> ImmutableSortedSet<E> copyOf(Comparator<? super E> comparator,
                                               Collection<? extends E> elements)
```
    Returns an immutable sorted set containing the given elements sorted by the given Comparator. When multiple elements are equivalent according to compareTo(), only the first one specified is included.
    Despite the method name, this method attempts to avoid actually copying the data when it is safe to do so. The exact circumstances under which a copy will or will not be performed are undocumented and subject to change.
    This method is safe to use even when elements is a synchronized or concurrent collection that is currently being modified by another thread.
    
    Throws:
    
    NullPointerException - if comparator or any of elements is null
    
    Since:
    
    7.0 (source-compatible since 2.0)
  - copyOfSorted
```
public static <E> ImmutableSortedSet<E> copyOfSorted(SortedSet<E> sortedSet)
```
    Returns an immutable sorted set containing the elements of a sorted set, sorted by the same Comparator. That behavior differs from copyOf(Iterable), which always uses the natural ordering of the elements.
    Despite the method name, this method attempts to avoid actually copying the data when it is safe to do so. The exact circumstances under which a copy will or will not be performed are undocumented and subject to change.
    This method is safe to use even when sortedSet is a synchronized or concurrent collection that is currently being modified by another thread.
    
    Throws:
    
    NullPointerException - if sortedSet or any of its elements is null
  - orderedBy
```
public static <E> ImmutableSortedSet.Builder<E> orderedBy(Comparator<E> comparator)
```
    Returns a builder that creates immutable sorted sets with an explicit comparator. If the comparator has a more general type than the set being generated, such as creating a SortedSet<Integer> with a Comparator<Number>, use the ImmutableSortedSet.Builder constructor instead.
    
    Throws:
    
    NullPointerException - if comparator is null
  - reverseOrder
```
public static <E extends Comparable<?>> ImmutableSortedSet.Builder<E> reverseOrder()
```
    Returns a builder that creates immutable sorted sets whose elements are ordered by the reverse of their natural ordering.
  - naturalOrder
```
public static <E extends Comparable<?>> ImmutableSortedSet.Builder<E> naturalOrder()
```
    Returns a builder that creates immutable sorted sets whose elements are ordered by their natural ordering. The sorted sets use Ordering.natural() as the comparator. This method provides more type-safety than builder(), as it can be called only for classes that implement Comparable.
  - comparator
```
public Comparator<? super E> comparator()
```
    Returns the comparator that orders the elements, which is Ordering.natural() when the natural ordering of the elements is used. Note that its behavior is not consistent with SortedSet.comparator(), which returns null to indicate natural ordering.
    
    Specified by:
    
    comparator in interface SortedSet<E>
    
    Returns:
    
    the comparator used to order the elements in this set, or null if this set uses the natural ordering of its elements
  - iterator
```
public abstract UnmodifiableIterator<E> iterator()
```
    Description copied from class: ImmutableCollection
    
    Returns an unmodifiable iterator across the elements in this collection.
    
    Specified by:
    
    iterator in interface Collection<E>
    
    Specified by:
    
    iterator in interface Iterable<E>
    
    Specified by:
    
    iterator in interface NavigableSet<E>
    
    Specified by:
    
    iterator in interface Set<E>
    
    Specified by:
    
    iterator in class ImmutableSet<E>
    
    Returns:
    
    an iterator over the elements contained in this collection
  - headSet
```
public ImmutableSortedSet<E> headSet(E toElement)
```
    Returns a view of the portion of this set whose elements are strictly less than 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.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    Equivalent to headSet(toElement, false).
    This method returns a serializable ImmutableSortedSet.
    The SortedSet.headSet(E) documentation states that a subset of a subset throws an IllegalArgumentException if passed a toElement greater than an earlier toElement. However, this method doesn't throw an exception in that situation, but instead keeps the original toElement.
    
    Specified by:
    
    headSet in interface NavigableSet<E>
    
    Specified by:
    
    headSet in interface SortedSet<E>
    
    Parameters:
    
    toElement - high endpoint (exclusive) of the returned set
    
    Returns:
    
    a view of the portion of this set whose elements are strictly less than toElement
  - headSet
```
public ImmutableSortedSet<E> headSet(E toElement,
                                     boolean inclusive)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a view of the portion of this set whose elements are less than (or equal to, if inclusive is true) 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.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    
    Specified by:
    
    headSet in interface NavigableSet<E>
    
    Parameters:
    
    toElement - high endpoint of the returned set
    
    inclusive - true if the high endpoint is to be included in the returned view
    
    Returns:
    
    a view of the portion of this set whose elements are less than (or equal to, if inclusive is true) toElement
    
    Since:
    
    12.0
  - subSet
```
public ImmutableSortedSet<E> subSet(E fromElement,
                                    E toElement)
```
    Returns a view of the portion of this set whose elements range from fromElement, inclusive, to toElement, exclusive. (If fromElement and toElement are equal, the returned set is empty.) 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.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    Equivalent to subSet(fromElement, true, toElement, false).
    This method returns a serializable ImmutableSortedSet.
    The SortedSet.subSet(E, E) documentation states that a subset of a subset throws an IllegalArgumentException if passed a fromElement smaller than an earlier fromElement. However, this method doesn't throw an exception in that situation, but instead keeps the original fromElement. Similarly, this method keeps the original toElement, instead of throwing an exception, if passed a toElement greater than an earlier toElement.
    
    Specified by:
    
    subSet in interface NavigableSet<E>
    
    Specified by:
    
    subSet in interface SortedSet<E>
    
    Parameters:
    
    fromElement - low endpoint (inclusive) of the returned set
    
    toElement - high endpoint (exclusive) of the returned set
    
    Returns:
    
    a view of the portion of this set whose elements range from fromElement, inclusive, to toElement, exclusive
  - subSet
```
@GwtIncompatible
public ImmutableSortedSet<E> subSet(E fromElement,
                                    boolean fromInclusive,
                                    E toElement,
                                    boolean toInclusive)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a view of the portion of this set whose elements range from fromElement to toElement. If fromElement and toElement are equal, the returned set is empty unless fromInclusive and 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.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    
    Specified by:
    
    subSet in interface NavigableSet<E>
    
    Parameters:
    
    fromElement - low endpoint of the returned set
    
    fromInclusive - true if the low endpoint is to be included in the returned view
    
    toElement - high endpoint of the returned set
    
    toInclusive - true if the high endpoint is to be included in the returned view
    
    Returns:
    
    a view of the portion of this set whose elements range from fromElement, inclusive, to toElement, exclusive
    
    Since:
    
    12.0
  - tailSet
```
public ImmutableSortedSet<E> tailSet(E fromElement)
```
    Returns a view of the portion of this set whose elements are greater than or equal to 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.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    Equivalent to tailSet(fromElement, true).
    This method returns a serializable ImmutableSortedSet.
    The SortedSet.tailSet(E) documentation states that a subset of a subset throws an IllegalArgumentException if passed a fromElement smaller than an earlier fromElement. However, this method doesn't throw an exception in that situation, but instead keeps the original fromElement.
    
    Specified by:
    
    tailSet in interface NavigableSet<E>
    
    Specified by:
    
    tailSet in interface SortedSet<E>
    
    Parameters:
    
    fromElement - low endpoint (inclusive) of the returned set
    
    Returns:
    
    a view of the portion of this set whose elements are greater than or equal to fromElement
  - tailSet
```
public ImmutableSortedSet<E> tailSet(E fromElement,
                                     boolean inclusive)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns a view of the portion of this set whose elements are greater than (or equal to, if inclusive is true) 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.
    The returned set will throw an IllegalArgumentException on an attempt to insert an element outside its range.
    
    Specified by:
    
    tailSet in interface NavigableSet<E>
    
    Parameters:
    
    fromElement - low endpoint of the returned set
    
    inclusive - true if the low endpoint is to be included in the returned view
    
    Returns:
    
    a view of the portion of this set whose elements are greater than or equal to fromElement
    
    Since:
    
    12.0
  - lower
```
@GwtIncompatible
@CheckForNull
public E lower(E e)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns the greatest element in this set strictly less than the given element, or null if there is no such element.
    
    Specified by:
    
    lower in interface NavigableSet<E>
    
    Parameters:
    
    e - the value to match
    
    Returns:
    
    the greatest element less than e, or null if there is no such element
    
    Since:
    
    12.0
  - floor
```
@CheckForNull
public E floor(E e)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns the greatest element in this set less than or equal to the given element, or null if there is no such element.
    
    Specified by:
    
    floor in interface NavigableSet<E>
    
    Parameters:
    
    e - the value to match
    
    Returns:
    
    the greatest element less than or equal to e, or null if there is no such element
    
    Since:
    
    12.0
  - ceiling
```
@CheckForNull
public E ceiling(E e)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns the least element in this set greater than or equal to the given element, or null if there is no such element.
    
    Specified by:
    
    ceiling in interface NavigableSet<E>
    
    Parameters:
    
    e - the value to match
    
    Returns:
    
    the least element greater than or equal to e, or null if there is no such element
    
    Since:
    
    12.0
  - higher
```
@GwtIncompatible
@CheckForNull
public E higher(E e)
```
    Description copied from interface: java.util.NavigableSet
    
    Returns the least element in this set strictly greater than the given element, or null if there is no such element.
    
    Specified by:
    
    higher in interface NavigableSet<E>
    
    Parameters:
    
    e - the value to match
    
    Returns:
    
    the least element greater than e, or null if there is no such element
    
    Since:
    
    12.0
  - first
```
public E first()
```
    Description copied from interface: java.util.SortedSet
    
    Returns the first (lowest) element currently in this set.
    
    Specified by:
    
    first in interface SortedSet<E>
    
    Returns:
    
    the first (lowest) element currently in this set
  - last
```
public E last()
```
    Description copied from interface: java.util.SortedSet
    
    Returns the last (highest) element currently in this set.
    
    Specified by:
    
    last in interface SortedSet<E>
    
    Returns:
    
    the last (highest) element currently in this set
  - pollFirst
```
@CanIgnoreReturnValue
@Deprecated
@GwtIncompatible
@CheckForNull
public final E pollFirst()
```
    Deprecated.
    Unsupported operation.
    
    Guaranteed to throw an exception and leave the set unmodified.
    
    Specified by:
    
    pollFirst in interface NavigableSet<E>
    
    Returns:
    
    the first element, or null if this set is empty
    
    Throws:
    
    UnsupportedOperationException - always
    
    Since:
    
    12.0
  - pollLast
```
@CanIgnoreReturnValue
@Deprecated
@GwtIncompatible
@CheckForNull
public final E pollLast()
```
    Deprecated.
    Unsupported operation.
    
    Guaranteed to throw an exception and leave the set unmodified.
    
    Specified by:
    
    pollLast in interface NavigableSet<E>
    
    Returns:
    
    the last element, or null if this set is empty
    
    Throws:
    
    UnsupportedOperationException - always
    
    Since:
    
    12.0
  - descendingSet
```
@GwtIncompatible
public ImmutableSortedSet<E> descendingSet()
```
    Description copied from interface: java.util.NavigableSet
    
    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 remove operation), the results of the iteration are undefined.
    The returned set has an ordering equivalent to Collections.reverseOrder(comparator()). The expression s.descendingSet().descendingSet() returns a view of s essentially equivalent to s.
    
    Specified by:
    
    descendingSet in interface NavigableSet<E>
    
    Returns:
    
    a reverse order view of this set
    
    Since:
    
    12.0
  - spliterator
```
public Spliterator<E> spliterator()
```
    Description copied from interface: java.util.Collection
    Creates a Spliterator over the elements in this collection. Implementations should document characteristic values reported by the spliterator. Such characteristic values are not required to be reported if the spliterator reports Spliterator.SIZED and this collection contains no elements.
    The default implementation should be overridden by subclasses that can return a more efficient spliterator. In order to preserve expected laziness behavior for the Collection.stream() and Collection.parallelStream() methods, spliterators should either have the characteristic of IMMUTABLE or CONCURRENT, or be late-binding. If none of these is practical, the overriding class should describe the spliterator's documented policy of binding and structural interference, and should override the Collection.stream() and Collection.parallelStream() methods to create streams using a Supplier of the spliterator, as in:
    Stream<E> s = StreamSupport.stream(() -> spliterator(), spliteratorCharacteristics)
    
    These requirements ensure that streams produced by the Collection.stream() and Collection.parallelStream() methods will reflect the contents of the collection as of initiation of the terminal stream operation.
    Specified by:
    
    spliterator in interface Collection<E>
    
    Specified by:
    
    spliterator in interface Iterable<E>
    
    Specified by:
    
    spliterator in interface Set<E>
    
    Specified by:
    
    spliterator in interface SortedSet<E>
    
    Overrides:
    
    spliterator in class ImmutableCollection<E>
    
    Returns:
    
    a Spliterator over the elements in this collection
  - descendingIterator
```
@GwtIncompatible
public abstract UnmodifiableIterator<E> descendingIterator()
```
    Description copied from interface: java.util.NavigableSet
    
    Returns an iterator over the elements in this set, in descending order. Equivalent in effect to descendingSet().iterator().
    
    Specified by:
    
    descendingIterator in interface NavigableSet<E>
    
    Returns:
    
    an iterator over the elements in this set, in descending order
    
    Since:
    
    12.0
  - toImmutableSet
```
@Deprecated
public static <E> Collector<E,?,ImmutableSet<E>> toImmutableSet()
```
    Deprecated.
    Use toImmutableSortedSet(java.util.Comparator<? super E>).
    
    Not supported. Use toImmutableSortedSet(java.util.Comparator<? super E>) instead. This method exists only to hide ImmutableSet.toImmutableSet() from consumers of ImmutableSortedSet.
    
    Throws:
    
    UnsupportedOperationException - always
    
    Since:
    
    21.0
  - builder
```
@Deprecated
public static <E> ImmutableSortedSet.Builder<E> builder()
```
    Deprecated.
    Use naturalOrder(), which offers better type-safety.
    
    Not supported. Use naturalOrder(), which offers better type-safety, instead. This method exists only to hide ImmutableSet.builder() from consumers of ImmutableSortedSet.
    
    Throws:
    
    UnsupportedOperationException - always
  - builderWithExpectedSize
```
@Deprecated
public static <E> ImmutableSortedSet.Builder<E> builderWithExpectedSize(int expectedSize)
```
    Deprecated.
    Not supported by ImmutableSortedSet.
    
    Not supported. This method exists only to hide ImmutableSet.builderWithExpectedSize(int) from consumers of ImmutableSortedSet.
    
    Throws:
    
    UnsupportedOperationException - always
  - of
```
@Deprecated
public static <E> ImmutableSortedSet<E> of(E element)
```
    Deprecated.
    Pass a parameter of type Comparable to use of(Comparable).
    
    Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    element - the single element
    
    Returns:
    
    a Set containing the specified element
    
    Throws:
    
    UnsupportedOperationException - always
  - of
```
@Deprecated
public static <E> ImmutableSortedSet<E> of(E e1,
                                           E e2)
```
    Deprecated.
    Pass the parameters of type Comparable to use of(Comparable, Comparable).
    
    Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    UnsupportedOperationException - always
  - of
```
@Deprecated
public static <E> ImmutableSortedSet<E> of(E e1,
                                           E e2,
                                           E e3)
```
    Deprecated.
    Pass the parameters of type Comparable to use of(Comparable, Comparable, Comparable).
    
    Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    e3 - the third element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    UnsupportedOperationException - always
  - of
```
@Deprecated
public static <E> ImmutableSortedSet<E> of(E e1,
                                           E e2,
                                           E e3,
                                           E e4)
```
    Deprecated.
    Pass the parameters of type Comparable to use of(Comparable, Comparable, Comparable, Comparable).
    
    Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    e3 - the third element
    
    e4 - the fourth element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    UnsupportedOperationException - always
  - of
```
@Deprecated
public static <E> ImmutableSortedSet<E> of(E e1,
                                           E e2,
                                           E e3,
                                           E e4,
                                           E e5)
```
    Deprecated.
    Pass the parameters of type Comparable to use of( Comparable, Comparable, Comparable, Comparable, Comparable).
    
    Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    e3 - the third element
    
    e4 - the fourth element
    
    e5 - the fifth element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    UnsupportedOperationException - always
  - of
```
@Deprecated
public static <E> ImmutableSortedSet<E> of(E e1,
                                           E e2,
                                           E e3,
                                           E e4,
                                           E e5,
                                           E e6,
                                           E... remaining)
```
    Deprecated.
    Pass the parameters of type Comparable to use of(Comparable, Comparable, Comparable, Comparable, Comparable, Comparable, Comparable...).
    
    Not supported. You are attempting to create a set that may contain a non-Comparable element. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
    
    Type Parameters:
    
    E - the Set's element type
    
    Parameters:
    
    e1 - the first element
    
    e2 - the second element
    
    e3 - the third element
    
    e4 - the fourth element
    
    e5 - the fifth element
    
    e6 - the sixth element
    
    remaining - the seventh element
    
    Returns:
    
    a Set containing the specified elements
    
    Throws:
    
    UnsupportedOperationException - always
  - copyOf
```
@Deprecated
public static <E> ImmutableSortedSet<E> copyOf(E[] elements)
```
    Deprecated.
    Pass parameters of type Comparable to use copyOf(Comparable[]).
    
    Not supported. You are attempting to create a set that may contain non-Comparable elements. Proper calls will resolve to the version in ImmutableSortedSet, not this dummy version.
    
    Throws:
    
    UnsupportedOperationException - always
  - asList
```
public ImmutableList<E> asList()
```
    Description copied from class: ImmutableCollection
    
    Returns an ImmutableList containing the same elements, in the same order, as this collection.
    Performance note: in most cases this method can return quickly without actually copying anything. The exact circumstances under which the copy is performed are undefined and subject to change.
    
    Overrides:
    
    asList in class ImmutableCollection<E>

Class ImmutableSortedSet<E>

Nested Class Summary

Method Summary

Methods inherited from class com.google.common.collect.ImmutableSet

Methods inherited from class com.google.common.collect.ImmutableCollection

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.Set

Method Detail

toImmutableSortedSet

of

of

of

of

of

of

of

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOf

copyOfSorted

orderedBy

reverseOrder

naturalOrder

comparator

iterator

headSet

headSet

subSet

subSet

tailSet

tailSet

lower

floor

ceiling

higher

first

last

pollFirst

pollLast

descendingSet

spliterator

descendingIterator

toImmutableSet

builder

builderWithExpectedSize

of

of

of

of

of

of

copyOf

asList