Class ImmutableSortedSet<E>

    • Constructor Detail

      • ImmutableSortedSet

        ImmutableSortedSet​(java.util.Comparator<? super E> comparator)
    • Method Detail

      • toImmutableSortedSet

        @Beta
        public static <E> java.util.stream.Collector<E,​?,​ImmutableSortedSet<E>> toImmutableSortedSet​(java.util.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.
      • of

        public static <E extends java.lang.Comparable<? super E>> ImmutableSortedSet<E> of​(E element)
        Returns an immutable sorted set containing a single element.
      • of

        public static <E extends java.lang.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:
        java.lang.NullPointerException - if any element is null
      • of

        public static <E extends java.lang.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:
        java.lang.NullPointerException - if any element is null
      • of

        public static <E extends java.lang.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:
        java.lang.NullPointerException - if any element is null
      • of

        public static <E extends java.lang.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:
        java.lang.NullPointerException - if any element is null
      • of

        public static <E extends java.lang.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:
        java.lang.NullPointerException - if any element is null
        Since:
        3.0 (source-compatible since 2.0)
      • copyOf

        public static <E extends java.lang.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:
        java.lang.NullPointerException - if any of elements is null
        Since:
        3.0
      • copyOf

        public static <E> ImmutableSortedSet<E> copyOf​(java.lang.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:
        java.lang.ClassCastException - if the elements are not mutually comparable
        java.lang.NullPointerException - if any of elements is null
      • copyOf

        public static <E> ImmutableSortedSet<E> copyOf​(java.util.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:
        java.lang.ClassCastException - if the elements are not mutually comparable
        java.lang.NullPointerException - if any of elements is null
        Since:
        7.0 (source-compatible since 2.0)
      • copyOf

        public static <E> ImmutableSortedSet<E> copyOf​(java.util.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:
        java.lang.ClassCastException - if the elements are not mutually comparable
        java.lang.NullPointerException - if any of elements is null
      • copyOf

        public static <E> ImmutableSortedSet<E> copyOf​(java.util.Comparator<? super E> comparator,
                                                       java.util.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:
        java.lang.NullPointerException - if comparator or any of elements is null
      • copyOf

        public static <E> ImmutableSortedSet<E> copyOf​(java.util.Comparator<? super E> comparator,
                                                       java.lang.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:
        java.lang.NullPointerException - if comparator or any of elements is null
      • copyOf

        public static <E> ImmutableSortedSet<E> copyOf​(java.util.Comparator<? super E> comparator,
                                                       java.util.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:
        java.lang.NullPointerException - if comparator or any of elements is null
        Since:
        7.0 (source-compatible since 2.0)
      • copyOfSorted

        public static <E> ImmutableSortedSet<E> copyOfSorted​(java.util.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:
        java.lang.NullPointerException - if sortedSet or any of its elements is null
      • construct

        static <E> ImmutableSortedSet<E> construct​(java.util.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.

        If k == contents.length, then contents may no longer be safe for modification.

        Throws:
        java.lang.NullPointerException - if any of the first n elements of contents is null
      • orderedBy

        public static <E> ImmutableSortedSet.Builder<E> orderedBy​(java.util.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:
        java.lang.NullPointerException - if comparator is null
      • reverseOrder

        public static <E extends java.lang.Comparable<?>> ImmutableSortedSet.Builder<E> reverseOrder()
        Returns a builder that creates immutable sorted sets whose elements are ordered by the reverse of their natural ordering.
      • unsafeCompare

        int unsafeCompare​(java.lang.Object a,
                          java.lang.Object b)
      • unsafeCompare

        static int unsafeCompare​(java.util.Comparator<?> comparator,
                                 java.lang.Object a,
                                 java.lang.Object b)
      • comparator

        public java.util.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 java.util.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 java.util.Collection<E>
        Specified by:
        iterator in interface java.lang.Iterable<E>
        Specified by:
        iterator in interface java.util.NavigableSet<E>
        Specified by:
        iterator in interface java.util.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 java.util.NavigableSet<E>
        Specified by:
        headSet in interface java.util.SortedSet<E>
      • 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 java.util.NavigableSet<E>
        Specified by:
        subSet in interface java.util.SortedSet<E>
      • subSet

        @GwtIncompatible
        public ImmutableSortedSet<E> subSet​(E fromElement,
                                            boolean fromInclusive,
                                            E toElement,
                                            boolean toInclusive)
        Specified by:
        subSet in interface java.util.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 java.util.NavigableSet<E>
        Specified by:
        tailSet in interface java.util.SortedSet<E>
      • subSetImpl

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

        @GwtIncompatible
        public E lower​(E e)
        Specified by:
        lower in interface java.util.NavigableSet<E>
        Since:
        12.0
      • floor

        @GwtIncompatible
        public E floor​(E e)
        Specified by:
        floor in interface java.util.NavigableSet<E>
        Since:
        12.0
      • ceiling

        @GwtIncompatible
        public E ceiling​(E e)
        Specified by:
        ceiling in interface java.util.NavigableSet<E>
        Since:
        12.0
      • higher

        @GwtIncompatible
        public E higher​(E e)
        Specified by:
        higher in interface java.util.NavigableSet<E>
        Since:
        12.0
      • first

        public E first()
        Specified by:
        first in interface java.util.SortedSet<E>
      • last

        public E last()
        Specified by:
        last in interface java.util.SortedSet<E>
      • pollFirst

        @Deprecated
        @GwtIncompatible
        public final E pollFirst()
        Deprecated.
        Unsupported operation.
        Guaranteed to throw an exception and leave the set unmodified.
        Specified by:
        pollFirst in interface java.util.NavigableSet<E>
        Throws:
        java.lang.UnsupportedOperationException - always
        Since:
        12.0
      • pollLast

        @Deprecated
        @GwtIncompatible
        public final E pollLast()
        Deprecated.
        Unsupported operation.
        Guaranteed to throw an exception and leave the set unmodified.
        Specified by:
        pollLast in interface java.util.NavigableSet<E>
        Throws:
        java.lang.UnsupportedOperationException - always
        Since:
        12.0
      • spliterator

        public java.util.Spliterator<E> spliterator()
        Specified by:
        spliterator in interface java.util.Collection<E>
        Specified by:
        spliterator in interface java.lang.Iterable<E>
        Specified by:
        spliterator in interface java.util.Set<E>
        Specified by:
        spliterator in interface java.util.SortedSet<E>
        Overrides:
        spliterator in class ImmutableCollection<E>
      • indexOf

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

        private void readObject​(java.io.ObjectInputStream stream)
                         throws java.io.InvalidObjectException
        Throws:
        java.io.InvalidObjectException