Class ImmutableSortedSet<E>

All Implemented Interfaces:
SortedIterable<E>, Serializable, Iterable<E>, Collection<E>, NavigableSet<E>, SequencedCollection<E>, SequencedSet<E>, Set<E>, SortedSet<E>
Direct Known Subclasses:
ContiguousSet, DescendingImmutableSortedSet, ImmutableRangeSet.AsSet, RegularImmutableSortedSet

public abstract class ImmutableSortedSet<E> extends ImmutableSet.CachingAsList<E> implements NavigableSet<E>, SortedIterable<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)
See Also:
  • Field Details

  • Constructor Details

    • ImmutableSortedSet

      ImmutableSortedSet(Comparator<? super E> comparator)
  • Method Details

    • 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
    • emptySet

      static <E> RegularImmutableSortedSet<E> emptySet(Comparator<? super E> comparator)
    • of

      public static <E> ImmutableSortedSet<E> of()
      Returns the empty immutable sorted set.

      Performance note: the instance returned is a singleton.

    • of

      public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1)
      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
    • construct

      static <E> ImmutableSortedSet<E> construct(Comparator<? super E> comparator, int n, E... contents)
      Constructs an ImmutableSortedSet from the first n elements of contents. If k is the size of the returned ImmutableSortedSet, then the sorted unique elements are in the first k positions of contents, and contents[i] == null for k <= i < n.

      This method takes ownership of contents; do not modify contents after this returns.

      Throws:
      NullPointerException - if any of the first n elements of contents 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.
    • unsafeCompare

      int unsafeCompare(Object a, @CheckForNull Object b)
    • unsafeCompare

      static int unsafeCompare(Comparator<?> comparator, Object a, @CheckForNull Object b)
    • 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 SortedIterable<E>
      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 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 interface SortedIterable<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

      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

      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

      public ImmutableSortedSet<E> tailSet(E fromElement, boolean inclusive)
      Specified by:
      tailSet in interface NavigableSet<E>
      Since:
      12.0
    • headSetImpl

      abstract ImmutableSortedSet<E> headSetImpl(E toElement, boolean inclusive)
    • subSetImpl

      abstract ImmutableSortedSet<E> subSetImpl(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
    • tailSetImpl

      abstract ImmutableSortedSet<E> tailSetImpl(E fromElement, boolean inclusive)
    • lower

      @CheckForNull public E lower(E e)
      Specified by:
      lower in interface NavigableSet<E>
      Since:
      12.0
    • floor

      @CheckForNull public E floor(E e)
      Specified by:
      floor in interface NavigableSet<E>
      Since:
      12.0
    • ceiling

      @CheckForNull public E ceiling(E e)
      Specified by:
      ceiling in interface NavigableSet<E>
      Since:
      12.0
    • higher

      @CheckForNull 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 @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>
      Throws:
      UnsupportedOperationException - always
      Since:
      12.0
    • pollLast

      @Deprecated @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>
      Throws:
      UnsupportedOperationException - always
      Since:
      12.0
    • descendingSet

      public ImmutableSortedSet<E> descendingSet()
      Specified by:
      descendingSet in interface NavigableSet<E>
      Since:
      12.0
    • createDescendingSet

      abstract ImmutableSortedSet<E> createDescendingSet()
    • spliterator

      public Spliterator<E> spliterator()
      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>
    • descendingIterator

      public abstract UnmodifiableIterator<E> descendingIterator()
      Specified by:
      descendingIterator in interface NavigableSet<E>
      Since:
      12.0
    • indexOf

      abstract int indexOf(@CheckForNull Object target)
      Returns the position of an element within the set, or -1 if not present.
    • readObject

      private void readObject(ObjectInputStream unused) throws InvalidObjectException
      Throws:
      InvalidObjectException
    • writeReplace

      Object writeReplace()
      Overrides:
      writeReplace in class ImmutableSet.CachingAsList<E>
    • toImmutableSet

      @Deprecated public static <E> Collector<E,?,ImmutableSet<E>> toImmutableSet()
      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 e1)
      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.
      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.
      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.
      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.
      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.
      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.
      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.
      Throws:
      UnsupportedOperationException - always
    • copyOf

      @Deprecated public static <Z> ImmutableSortedSet<Z> copyOf(Z[] 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