ImmutableSortedMultiset
Date: 2016-05-24

com.google.common.collect

## Class ImmutableSortedMultiset<E>

- java.lang.Object
- - java.util.AbstractCollection<E>
  - - com.google.common.collect.ImmutableCollection<E>
    - - com.google.common.collect.ImmutableMultiset<E>
      - - com.google.common.collect.ImmutableSortedMultiset<E>

- All Implemented Interfaces:
    Multiset<E>, SortedMultiset<E>, java.io.Serializable, java.lang.Iterable<E>, java.util.Collection<E>

      @Beta
      @GwtIncompatible(value="hasn\'t been tested yet")
      public abstract class ImmutableSortedMultiset<E>
      extends ImmutableMultiset<E>
      implements SortedMultiset<E>

  A `SortedMultiset` 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:
    12.0
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `ImmutableSortedMultiset.Builder<E>` A builder for creating immutable multiset instances, especially `public static final` multisets ("constant multisets").

    - ### Nested classes/interfaces inherited from interface com.google.common.collect.Multiset

      `Multiset.Entry<E>`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <E> ImmutableSortedMultiset.Builder<E>` | `builder()` Deprecated. Use `naturalOrder()`, which offers better type-safety.
    `java.util.Comparator<? super E>` | `comparator()` Returns the comparator that orders this multiset, or `Ordering.natural()` if the natural ordering of the elements is used.
    `static <E> ImmutableSortedMultiset<E>` | `copyOf(java.util.Comparator<? super E> comparator, java.lang.Iterable<? extends E> elements)` Returns an immutable sorted multiset containing the given elements sorted by the given `Comparator`.
    `static <E> ImmutableSortedMultiset<E>` | `copyOf(java.util.Comparator<? super E> comparator, java.util.Iterator<? extends E> elements)` Returns an immutable sorted multiset containing the given elements sorted by the given `Comparator`.
    `static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E>` | `copyOf(E[] elements)` Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
    `static <E> ImmutableSortedMultiset<E>` | `copyOf(java.lang.Iterable<? extends E> elements)` Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
    `static <E> ImmutableSortedMultiset<E>` | `copyOf(java.util.Iterator<? extends E> elements)` Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
    `static <E> ImmutableSortedMultiset<E>` | `copyOfSorted(SortedMultiset<E> sortedMultiset)` Returns an immutable sorted multiset containing the elements of a sorted multiset, sorted by the same `Comparator`.
    `ImmutableSortedMultiset<E>` | `descendingMultiset()` Returns a descending view of this multiset.
    `abstract ImmutableSortedSet<E>` | `elementSet()` Returns a `NavigableSet` view of the distinct elements in this multiset.
    `abstract ImmutableSortedMultiset<E>` | `headMultiset(E upperBound, BoundType boundType)` Returns a view of this multiset restricted to the elements less than `upperBound`, optionally including `upperBound` itself.
    `static <E extends java.lang.Comparable<?>> ImmutableSortedMultiset.Builder<E>` | `naturalOrder()` Returns a builder that creates immutable sorted multisets whose elements are ordered by their natural ordering.
    `static <E> ImmutableSortedMultiset<E>` | `of()` Returns the empty immutable sorted multiset.
    `static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E>` | `of(E element)` Returns an immutable sorted multiset containing a single element.
    `static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E>` | `of(E e1, E e2)` Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
    `static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E>` | `of(E e1, E e2, E e3)` Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
    `static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E>` | `of(E e1, E e2, E e3, E e4)` Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
    `static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E>` | `of(E e1, E e2, E e3, E e4, E e5)` Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
    `static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E>` | `of(E e1, E e2, E e3, E e4, E e5, E e6, E... remaining)` Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
    `static <E> ImmutableSortedMultiset.Builder<E>` | `orderedBy(java.util.Comparator<E> comparator)` Returns a builder that creates immutable sorted multisets with an explicit comparator.
    `Multiset.Entry<E>` | `pollFirstEntry()` Deprecated. Unsupported operation.
    `Multiset.Entry<E>` | `pollLastEntry()` Deprecated. Unsupported operation.
    `static <E extends java.lang.Comparable<?>> ImmutableSortedMultiset.Builder<E>` | `reverseOrder()` Returns a builder that creates immutable sorted multisets whose elements are ordered by the reverse of their natural ordering.
    `ImmutableSortedMultiset<E>` | `subMultiset(E lowerBound, BoundType lowerBoundType, E upperBound, BoundType upperBoundType)` Returns a view of this multiset restricted to the range between `lowerBound` and `upperBound`.
    `abstract ImmutableSortedMultiset<E>` | `tailMultiset(E lowerBound, BoundType boundType)` Returns a view of this multiset restricted to the elements greater than `lowerBound`, optionally including `lowerBound` itself.

    - ### Methods inherited from class com.google.common.collect.ImmutableMultiset

      `add, contains, entrySet, equals, hashCode, iterator, remove, setCount, setCount, toString`

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

      `add, addAll, asList, clear, remove, removeAll, retainAll, toArray, toArray`

    - ### Methods inherited from class java.util.AbstractCollection

      `containsAll, isEmpty, size`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface com.google.common.collect.SortedMultiset

      `entrySet, firstEntry, iterator, lastEntry`

    - ### Methods inherited from interface com.google.common.collect.Multiset

      `add, add, contains, containsAll, count, equals, hashCode, remove, remove, removeAll, retainAll, setCount, setCount, toString`

    - ### Methods inherited from interface java.util.Collection

      `addAll, clear, isEmpty, size, toArray, toArray`

- - ### Method Detail

    - #### of

          public static <E> ImmutableSortedMultiset<E> of()

      Returns the empty immutable sorted multiset.

    - #### of

          public static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E> of(E element)

      Returns an immutable sorted multiset containing a single element.

    - #### of

          public static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E> of(E e1,
                                                                                  E e2)

      Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
      Throws:
        `java.lang.NullPointerException` - if any element is null

    - #### of

          public static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E> of(E e1,
                                                                                  E e2,
                                                                                  E e3)

      Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
      Throws:
        `java.lang.NullPointerException` - if any element is null

    - #### of

          public static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E> of(E e1,
                                                                                  E e2,
                                                                                  E e3,
                                                                                  E e4)

      Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
      Throws:
        `java.lang.NullPointerException` - if any element is null

    - #### of

          public static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E> of(E e1,
                                                                                  E e2,
                                                                                  E e3,
                                                                                  E e4,
                                                                                  E e5)

      Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
      Throws:
        `java.lang.NullPointerException` - if any element is null

    - #### of

          public static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E> of(E e1,
                                                                                  E e2,
                                                                                  E e3,
                                                                                  E e4,
                                                                                  E e5,
                                                                                  E e6,
                                                                                  E... remaining)

      Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
      Throws:
        `java.lang.NullPointerException` - if any element is null

    - #### copyOf

          public static <E extends java.lang.Comparable<? super E>> ImmutableSortedMultiset<E> copyOf(E[] elements)

      Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.
      Throws:
        `java.lang.NullPointerException` - if any of `elements` is null

    - #### copyOf

          public static <E> ImmutableSortedMultiset<E> copyOf(java.lang.Iterable<? extends E> elements)

      Returns an immutable sorted multiset containing the given elements sorted by their natural ordering. To create a copy of a `SortedMultiset` that preserves the comparator, call `copyOfSorted(com.google.common.collect.SortedMultiset<E>)` instead. This method iterates over `elements` at most once.

      Note that if `s` is a `multiset<String>`, then `ImmutableSortedMultiset.copyOf(s)` returns an `ImmutableSortedMultiset<String>` containing each of the strings in `s`, while `ImmutableSortedMultiset.of(s)` returns an `ImmutableSortedMultiset<multiset<String>>` containing one element (the given multiset 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> ImmutableSortedMultiset<E> copyOf(java.util.Iterator<? extends E> elements)

      Returns an immutable sorted multiset containing the given elements sorted by their natural ordering.

      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> ImmutableSortedMultiset<E> copyOf(java.util.Comparator<? super E> comparator,
                                              java.util.Iterator<? extends E> elements)

      Returns an immutable sorted multiset containing the given elements sorted by the given `Comparator`.
      Throws:
        `java.lang.NullPointerException` - if `comparator` or any of `elements` is null

    - #### copyOf

          public static <E> ImmutableSortedMultiset<E> copyOf(java.util.Comparator<? super E> comparator,
                                              java.lang.Iterable<? extends E> elements)

      Returns an immutable sorted multiset containing the given elements sorted by the given `Comparator`. 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

    - #### copyOfSorted

          public static <E> ImmutableSortedMultiset<E> copyOfSorted(SortedMultiset<E> sortedMultiset)

      Returns an immutable sorted multiset containing the elements of a sorted multiset, 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 `sortedMultiset` is a synchronized or concurrent collection that is currently being modified by another thread.

      Throws:
        `java.lang.NullPointerException` - if `sortedMultiset` or any of its elements is null

    - #### comparator

          public final java.util.Comparator<? super E> comparator()

      Description copied from interface: `SortedMultiset`
      Returns the comparator that orders this multiset, or `Ordering.natural()` if the natural ordering of the elements is used.
      Specified by:
        `comparator` in interface `SortedMultiset<E>`

    - #### elementSet

          public abstract ImmutableSortedSet<E> elementSet()

      Description copied from interface: `SortedMultiset`
      Returns a `NavigableSet` view of the distinct elements in this multiset.
      Specified by:
        `elementSet` in interface `Multiset<E>`
      Specified by:
        `elementSet` in interface `SortedMultiset<E>`
      Returns:
        a view of the set of distinct elements in this multiset

    - #### descendingMultiset

          public ImmutableSortedMultiset<E> descendingMultiset()

      Description copied from interface: `SortedMultiset`
      Returns a descending view of this multiset. Modifications made to either map will be reflected in the other.
      Specified by:
        `descendingMultiset` in interface `SortedMultiset<E>`

    - #### pollFirstEntry

          @Deprecated
          public final Multiset.Entry<E> pollFirstEntry()

      Deprecated. Unsupported operation.
      Returns and removes the entry associated with the lowest element in this multiset, or returns `null` if this multiset is empty.

      This implementation is guaranteed to throw an `UnsupportedOperationException`.

      Specified by:
        `pollFirstEntry` in interface `SortedMultiset<E>`
      Throws:
        `java.lang.UnsupportedOperationException` - always

    - #### pollLastEntry

          @Deprecated
          public final Multiset.Entry<E> pollLastEntry()

      Deprecated. Unsupported operation.
      Returns and removes the entry associated with the greatest element in this multiset, or returns `null` if this multiset is empty.

      This implementation is guaranteed to throw an `UnsupportedOperationException`.

      Specified by:
        `pollLastEntry` in interface `SortedMultiset<E>`
      Throws:
        `java.lang.UnsupportedOperationException` - always

    - #### headMultiset

          public abstract ImmutableSortedMultiset<E> headMultiset(E upperBound,
                                                BoundType boundType)

      Description copied from interface: `SortedMultiset`
      Returns a view of this multiset restricted to the elements less than `upperBound`, optionally including `upperBound` itself. The returned multiset is a view of this multiset, so changes to one will be reflected in the other. The returned multiset supports all operations that this multiset supports.

      The returned multiset will throw an `IllegalArgumentException` on attempts to add elements outside its range.

      Specified by:
        `headMultiset` in interface `SortedMultiset<E>`

    - #### subMultiset

          public ImmutableSortedMultiset<E> subMultiset(E lowerBound,
                                               BoundType lowerBoundType,
                                               E upperBound,
                                               BoundType upperBoundType)

      Description copied from interface: `SortedMultiset`
      Returns a view of this multiset restricted to the range between `lowerBound` and `upperBound`. The returned multiset is a view of this multiset, so changes to one will be reflected in the other. The returned multiset supports all operations that this multiset supports.

      The returned multiset will throw an `IllegalArgumentException` on attempts to add elements outside its range.

      This method is equivalent to `tailMultiset(lowerBound, lowerBoundType).headMultiset(upperBound, upperBoundType)`.

      Specified by:
        `subMultiset` in interface `SortedMultiset<E>`

    - #### tailMultiset

          public abstract ImmutableSortedMultiset<E> tailMultiset(E lowerBound,
                                                BoundType boundType)

      Description copied from interface: `SortedMultiset`
      Returns a view of this multiset restricted to the elements greater than `lowerBound`, optionally including `lowerBound` itself. The returned multiset is a view of this multiset, so changes to one will be reflected in the other. The returned multiset supports all operations that this multiset supports.

      The returned multiset will throw an `IllegalArgumentException` on attempts to add elements outside its range.

      Specified by:
        `tailMultiset` in interface `SortedMultiset<E>`

    - #### orderedBy

          public static <E> ImmutableSortedMultiset.Builder<E> orderedBy(java.util.Comparator<E> comparator)

      Returns a builder that creates immutable sorted multisets with an explicit comparator. If the comparator has a more general type than the set being generated, such as creating a `SortedMultiset<Integer>` with a `Comparator<Number>`, use the `ImmutableSortedMultiset.Builder` constructor instead.
      Throws:
        `java.lang.NullPointerException` - if `comparator` is null

    - #### reverseOrder

          public static <E extends java.lang.Comparable<?>> ImmutableSortedMultiset.Builder<E> reverseOrder()

      Returns a builder that creates immutable sorted multisets whose elements are ordered by the reverse of their natural ordering.

      Note: the type parameter `E` extends `Comparable<?>` rather than `Comparable<? super E>` as a workaround for javac bug 6468354.

    - #### naturalOrder

          public static <E extends java.lang.Comparable<?>> ImmutableSortedMultiset.Builder<E> naturalOrder()

      Returns a builder that creates immutable sorted multisets whose elements are ordered by their natural ordering. The sorted multisets 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`.

      Note: the type parameter `E` extends `Comparable<?>` rather than `Comparable<? super E>` as a workaround for javac bug 6468354.

    - #### builder

          @Deprecated
          public static <E> ImmutableSortedMultiset.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 `ImmutableMultiset.builder()` from consumers of `ImmutableSortedMultiset`.
      Throws:
        `java.lang.UnsupportedOperationException` - always