ImmutableSortedSet (Guava: Google Core Libraries for Java 19.0 API)

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 and 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

Methods
Modifier and Type	Method and Description
`static <E> ImmutableSortedSet.Builder<E>`	`builder()` Deprecated. Use `naturalOrder()`, which offers better type-safety.
`E`	`ceiling(E e)`
`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> 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, 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, 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, Iterator<? extends E> elements)` Returns an immutable sorted set containing the given elements sorted by the given `Comparator`.
`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(Iterable<? extends E> elements)` Returns an immutable sorted set containing the given elements sorted by their natural ordering.
`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()`
`ImmutableSortedSet<E>`	`descendingSet()`
`E`	`first()`
`E`	`floor(E e)`
`ImmutableSortedSet<E>`	`headSet(E toElement)`
`ImmutableSortedSet<E>`	`headSet(E toElement, boolean inclusive)`
`E`	`higher(E e)`
`abstract UnmodifiableIterator<E>`	`iterator()` Returns an unmodifiable iterator across the elements in this collection.
`E`	`last()`
`E`	`lower(E e)`
`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 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 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 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 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 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.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.
`ImmutableSortedSet<E>`	`subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)`
`ImmutableSortedSet<E>`	`subSet(E fromElement, E toElement)`
`ImmutableSortedSet<E>`	`tailSet(E fromElement)`
`ImmutableSortedSet<E>`	`tailSet(E fromElement, boolean inclusive)`

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

Methods inherited from class com.google.common.collect.ImmutableCollection
add, addAll, asList, clear, contains, remove, removeAll, 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.Set
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, remove, removeAll, retainAll, size, toArray, toArray

- Method Detail
  - of
```
public static <E> ImmutableSortedSet<E> of()
```
    Returns the empty immutable sorted set.
  - of
```
public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E element)
```
    Returns an immutable sorted set containing a single 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.
    
    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.
    
    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.
    
    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.
    
    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.
    
    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.
    
    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>
  - 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 Iterable<E>
    
    Specified by:
    
    iterator in interface Collection<E>
    
    Specified by:
    
    iterator in interface NavigableSet<E>
    
    Specified by:
    
    iterator in interface Set<E>
    
    Specified by:
    
    iterator in class ImmutableSet<E>
  - headSet
```
public ImmutableSortedSet<E> headSet(E toElement)
```
    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>
  - headSet
```
@GwtIncompatible(value="NavigableSet")
public ImmutableSortedSet<E> headSet(E toElement,
                                                 boolean inclusive)
```
    Specified by:
    
    headSet in interface NavigableSet<E>
    
    Since:
    
    12.0
  - subSet
```
public ImmutableSortedSet<E> subSet(E fromElement,
                           E toElement)
```
    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>
  - subSet
```
@GwtIncompatible(value="NavigableSet")
public ImmutableSortedSet<E> subSet(E fromElement,
                                                boolean fromInclusive,
                                                E toElement,
                                                boolean toInclusive)
```
    Specified by:
    
    subSet in interface NavigableSet<E>
    
    Since:
    
    12.0
  - tailSet
```
public ImmutableSortedSet<E> tailSet(E fromElement)
```
    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>
  - tailSet
```
@GwtIncompatible(value="NavigableSet")
public ImmutableSortedSet<E> tailSet(E fromElement,
                                                 boolean inclusive)
```
    Specified by:
    
    tailSet in interface NavigableSet<E>
    
    Since:
    
    12.0
  - lower
```
@GwtIncompatible(value="NavigableSet")
public E lower(E e)
```
    Specified by:
    
    lower in interface NavigableSet<E>
    
    Since:
    
    12.0
  - floor
```
@GwtIncompatible(value="NavigableSet")
public E floor(E e)
```
    Specified by:
    
    floor in interface NavigableSet<E>
    
    Since:
    
    12.0
  - ceiling
```
@GwtIncompatible(value="NavigableSet")
public E ceiling(E e)
```
    Specified by:
    
    ceiling in interface NavigableSet<E>
    
    Since:
    
    12.0
  - higher
```
@GwtIncompatible(value="NavigableSet")
public E higher(E e)
```
    Specified by:
    
    higher in interface NavigableSet<E>
    
    Since:
    
    12.0
  - first
```
public E first()
```
    Specified by:
    
    first in interface SortedSet<E>
  - last
```
public E last()
```
    Specified by:
    
    last in interface SortedSet<E>
  - pollFirst
```
@Deprecated
@GwtIncompatible(value="NavigableSet")
public final E pollFirst()
```
    Deprecated. Unsupported operation.
    
    Guaranteed to throw an exception and leave the set unmodified.
    
    Specified by:
    
    pollFirst in interface NavigableSet<E>
    
    Throws:
    
    UnsupportedOperationException - always
    Since:
    
    12.0
  - pollLast
```
@Deprecated
@GwtIncompatible(value="NavigableSet")
public final E pollLast()
```
    Deprecated. Unsupported operation.
    
    Guaranteed to throw an exception and leave the set unmodified.
    
    Specified by:
    
    pollLast in interface NavigableSet<E>
    
    Throws:
    
    UnsupportedOperationException - always
    Since:
    
    12.0
  - descendingSet
```
@GwtIncompatible(value="NavigableSet")
public ImmutableSortedSet<E> descendingSet()
```
    Specified by:
    
    descendingSet in interface NavigableSet<E>
    
    Since:
    
    12.0
  - descendingIterator
```
@GwtIncompatible(value="NavigableSet")
public abstract UnmodifiableIterator<E> descendingIterator()
```
    Specified by:
    
    descendingIterator in interface NavigableSet<E>
    
    Since:
    
    12.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

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.Set

Method Detail

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

descendingIterator

builder