- <E>
- - com.google.common.collect.ImmutableCollection<E>
  - - com.google.common.collect.ImmutableSet<E>
    - - com.google.common.collect.ImmutableSortedSet<E>

All Implemented Interfaces:

, <E>, <E>, <E>, <E>, <E>

Direct Known Subclasses:

ContiguousSet
```
@GwtCompatible(serializable=true,
               emulated=true)
public abstract class ImmutableSortedSet<E>
extends ImmutableSet<E>
implements <E>
```
A 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 or 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 .

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
`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.
`<? 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 <? 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>`	`<? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`<? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`<? super E> comparator, <? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by the given `Comparator`.
`static <E> ImmutableSortedSet<E>`	`<? super E> comparator, <? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by the given `Comparator`.
`static <E> ImmutableSortedSet<E>`	`<? super E> comparator, <? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by the given `Comparator`.
`static <E> ImmutableSortedSet<E>`	`<? extends E> elements)`	Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`static <E> ImmutableSortedSet<E>`	`<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 <?>> 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 <? 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 <? 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 <? 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 <? 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 <? 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 <? 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>`	`<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 <?>> ImmutableSortedSet.Builder<E>`	`reverseOrder()`	Returns a builder that creates immutable sorted sets whose elements are ordered by the reverse of their natural ordering.
`<E>`	`spliterator()`	Creates a 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> <E,?,ImmutableSet<E>>`	`toImmutableSet()`	Deprecated. Use `toImmutableSortedSet(java.util.Comparator<? super E>)`.
`static <E> <E,?,ImmutableSortedSet<E>>`	`<? 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
asList, 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.
, , ,

Methods inherited from class java.lang.
, , , , , , ,

Methods inherited from interface java.util.
, , ,

Methods inherited from interface java.lang.

Methods inherited from interface java.util.
, , , , , , , , , , , , ,

- Method Detail
  - toImmutableSortedSet
```
public static <E> <E,?,<? 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.
    
    Type Parameters:
    
    E - the Set's element type
    
    Returns:
    
    an empty Set
  - of
```
public static <E extends <? 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 <? 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 , 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:
    
    - if any element is null
  - of
```
public static <E extends <? 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 , 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:
    
    - if any element is null
  - of
```
public static <E extends <? 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 , 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:
    
    - if any element is null
  - of
```
public static <E extends <? 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 , 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:
    
    - if any element is null
  - of
```
public static <E extends <? 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 , 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:
    
    - if any element is null
    
    Since:
    
    3.0 (source-compatible since 2.0)
  - copyOf
```
public static <E extends <? 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 , only the first one specified is included.
    
    Throws:
    
    - if any of elements is null
    
    Since:
    
    3.0
  - copyOf
```
public static <E> <? 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:
    
    - if the elements are not mutually comparable
    
    - if any of elements is null
  - copyOf
```
public static <E> <? 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:
    
    - if the elements are not mutually comparable
    
    - if any of elements is null
    
    Since:
    
    7.0 (source-compatible since 2.0)
  - copyOf
```
public static <E> <? 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:
    
    - if the elements are not mutually comparable
    
    - if any of elements is null
  - copyOf
```
public static <E> <? super E> comparator,
                                               <? 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:
    
    - if comparator or any of elements is null
  - copyOf
```
public static <E> <? super E> comparator,
                                               <? 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:
    
    - if comparator or any of elements is null
  - copyOf
```
public static <E> <? super E> comparator,
                                               <? 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:
    
    - if comparator or any of elements is null
    
    Since:
    
    7.0 (source-compatible since 2.0)
  - copyOfSorted
```
public static <E> <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:
    
    - if sortedSet or any of its elements is null
  - orderedBy
```
public static <E> <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:
    
    - if comparator is null
  - reverseOrder
```
public static <E extends <?>> 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 <?>> 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 .
  - comparator
```
public <? 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 , which returns null to indicate natural ordering.
    
    Specified by:
    
    in interface <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:
    
    in interface <E>
    
    Specified by:
    
    in interface <E>
    
    Specified by:
    
    in interface <E>
    
    Specified by:
    
    in interface <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 documentation states that a subset of a subset throws an 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:
    
    in interface <E>
    
    Specified by:
    
    in interface <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:
    
    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:
    
    in interface <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 documentation states that a subset of a subset throws an 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:
    
    in interface <E>
    
    Specified by:
    
    in interface <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:
    
    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:
    
    in interface <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 documentation states that a subset of a subset throws an 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:
    
    in interface <E>
    
    Specified by:
    
    in interface <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:
    
    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:
    
    in interface <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
public E lower(E e)
```
    Description copied from interface:
    
    Returns the greatest element in this set strictly less than the given element, or null if there is no such element.
    
    Specified by:
    
    in interface <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
```
public E floor(E e)
```
    Description copied from interface:
    
    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:
    
    in interface <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
```
public E ceiling(E e)
```
    Description copied from interface:
    
    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:
    
    in interface <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
public E higher(E e)
```
    Description copied from interface:
    
    Returns the least element in this set strictly greater than the given element, or null if there is no such element.
    
    Specified by:
    
    in interface <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:
    
    Returns the first (lowest) element currently in this set.
    
    Specified by:
    
    in interface <E>
    
    Returns:
    
    the first (lowest) element currently in this set
  - last
```
public E last()
```
    Description copied from interface:
    
    Returns the last (highest) element currently in this set.
    
    Specified by:
    
    in interface <E>
    
    Returns:
    
    the last (highest) element currently in this set
  - pollFirst
```
@GwtIncompatible
public final E pollFirst()
```
    Deprecated.
    Unsupported operation.
    
    Guaranteed to throw an exception and leave the set unmodified.
    
    Specified by:
    
    in interface <E>
    
    Returns:
    
    the first element, or null if this set is empty
    
    Throws:
    
    - always
    
    Since:
    
    12.0
  - pollLast
```
@GwtIncompatible
public final E pollLast()
```
    Deprecated.
    Unsupported operation.
    
    Guaranteed to throw an exception and leave the set unmodified.
    
    Specified by:
    
    in interface <E>
    
    Returns:
    
    the last element, or null if this set is empty
    
    Throws:
    
    - always
    
    Since:
    
    12.0
  - descendingSet
```
@GwtIncompatible
public ImmutableSortedSet<E> descendingSet()
```
    Description copied from interface:
    
    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 (comparator()). The expression s.descendingSet().descendingSet() returns a view of s essentially equivalent to s.
    
    Specified by:
    
    in interface <E>
    
    Returns:
    
    a reverse order view of this set
    
    Since:
    
    12.0
  - spliterator
```
public <E> spliterator()
```
    Description copied from interface:
    Creates a 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 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 and 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 and 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 and methods will reflect the contents of the collection as of initiation of the terminal stream operation.
    Specified by:
    
    in interface <E>
    
    Specified by:
    
    in interface <E>
    
    Specified by:
    
    in interface <E>
    
    Specified by:
    
    in interface <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:
    
    Returns an iterator over the elements in this set, in descending order. Equivalent in effect to descendingSet().iterator().
    
    Specified by:
    
    in interface <E>
    
    Returns:
    
    an iterator over the elements in this set, in descending order
    
    Since:
    
    12.0
  - toImmutableSet
```
public static <E> <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:
    
    - always
    
    Since:
    
    21.0
  - builder
```
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:
    
    - always
  - builderWithExpectedSize
```
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:
    
    - always
  - of
```
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:
    
    - always
  - of
```
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:
    
    - always
  - of
```
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:
    
    - always
  - of
```
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:
    
    - always
  - of
```
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:
    
    - always
  - of
```
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:
    
    - always
  - copyOf
```
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:
    
    - always

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.

Methods inherited from class java.lang.

Methods inherited from interface java.util.

Methods inherited from interface java.lang.

Methods inherited from interface java.util.

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