com.google.common.collect

## Class ContiguousSet<C extends java.lang.Comparable>

- java.lang.Object
- - java.util.AbstractCollection<E>
  - - com.google.common.collect.ImmutableCollection<E>
    - - com.google.common.collect.ImmutableSet<E>
      - - com.google.common.collect.ImmutableSortedSet<C>
        - - com.google.common.collect.ContiguousSet<C>

- All Implemented Interfaces:
    java.io.Serializable, java.lang.Iterable<C>, java.util.Collection<C>, java.util.NavigableSet<C>, java.util.Set<C>, java.util.SortedSet<C>

      @Beta
      @GwtCompatible(emulated=true)
      public abstract class ContiguousSet<C extends java.lang.Comparable>
      extends ImmutableSortedSet<C>

  A sorted set of contiguous values in a given `DiscreteDomain`.

  Warning: Be extremely careful what you do with conceptually large instances (such as `ContiguousSet.create(Range.greaterThan(0), DiscreteDomain.integers()`). Certain operations on such a set can be performed efficiently, but others (such as `Set.hashCode()` or `Collections.frequency(java.util.Collection<?>, java.lang.Object)`) can cause major performance problems.

  Since:
    10.0
  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class com.google.common.collect.ImmutableSortedSet

      `ImmutableSortedSet.Builder<E>`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <E> ImmutableSortedSet.Builder<E>` | `builder()` Deprecated. Use `create(com.google.common.collect.Range<C>, com.google.common.collect.DiscreteDomain<C>)`.
    `static <C extends java.lang.Comparable> ContiguousSet<C>` | `create(Range<C> range, DiscreteDomain<C> domain)` Returns a `ContiguousSet` containing the same values in the given domain contained by the range.
    `ContiguousSet<C>` | `headSet(C toElement)`
    `ContiguousSet<C>` | `headSet(C toElement, boolean inclusive)`
    `abstract ContiguousSet<C>` | `intersection(ContiguousSet<C> other)` Returns the set of values that are contained in both this set and the other.
    `abstract Range<C>` | `range()` Returns a range, closed on both ends, whose endpoints are the minimum and maximum values contained in this set.
    `abstract Range<C>` | `range(BoundType lowerBoundType, BoundType upperBoundType)` Returns the minimal range with the given boundary types for which all values in this set are contained within the range.
    `ContiguousSet<C>` | `subSet(C fromElement, boolean fromInclusive, C toElement, boolean toInclusive)`
    `ContiguousSet<C>` | `subSet(C fromElement, C toElement)`
    `ContiguousSet<C>` | `tailSet(C fromElement)`
    `ContiguousSet<C>` | `tailSet(C fromElement, boolean inclusive)`
    `java.lang.String` | `toString()` Returns a short-hand representation of the contents such as `"[1..100]"`.

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

      `ceiling, comparator, copyOf, copyOf, copyOf, copyOf, copyOf, copyOf, copyOf, copyOfSorted, descendingIterator, descendingSet, first, floor, higher, iterator, last, lower, naturalOrder, of, of, of, of, of, of, of, orderedBy, pollFirst, pollLast, reverseOrder`

    - ### 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`

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

    - #### create

          public static <C extends java.lang.Comparable> ContiguousSet<C> create(Range<C> range,
                                                                 DiscreteDomain<C> domain)

      Returns a `ContiguousSet` containing the same values in the given domain contained by the range.
      Throws:
        `java.lang.IllegalArgumentException` - if neither range nor the domain has a lower bound, or if neither has an upper bound
      Since:
        13.0

    - #### headSet

          public ContiguousSet<C> headSet(C toElement)

      Description copied from class: `ImmutableSortedSet`

      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<C extends java.lang.Comparable>`
      Specified by:
        `headSet` in interface `java.util.SortedSet<C extends java.lang.Comparable>`
      Overrides:
        `headSet` in class `ImmutableSortedSet<C extends java.lang.Comparable>`

    - #### headSet

          @GwtIncompatible(value="NavigableSet")
          public ContiguousSet<C> headSet(C toElement,
                                                      boolean inclusive)

      Specified by:
        `headSet` in interface `java.util.NavigableSet<C extends java.lang.Comparable>`
      Overrides:
        `headSet` in class `ImmutableSortedSet<C extends java.lang.Comparable>`
      Since:
        12.0

    - #### subSet

          public ContiguousSet<C> subSet(C fromElement,
                                C toElement)

      Description copied from class: `ImmutableSortedSet`

      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<C extends java.lang.Comparable>`
      Specified by:
        `subSet` in interface `java.util.SortedSet<C extends java.lang.Comparable>`
      Overrides:
        `subSet` in class `ImmutableSortedSet<C extends java.lang.Comparable>`

    - #### subSet

          @GwtIncompatible(value="NavigableSet")
          public ContiguousSet<C> subSet(C fromElement,
                                                     boolean fromInclusive,
                                                     C toElement,
                                                     boolean toInclusive)

      Specified by:
        `subSet` in interface `java.util.NavigableSet<C extends java.lang.Comparable>`
      Overrides:
        `subSet` in class `ImmutableSortedSet<C extends java.lang.Comparable>`
      Since:
        12.0

    - #### tailSet

          public ContiguousSet<C> tailSet(C fromElement)

      Description copied from class: `ImmutableSortedSet`

      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<C extends java.lang.Comparable>`
      Specified by:
        `tailSet` in interface `java.util.SortedSet<C extends java.lang.Comparable>`
      Overrides:
        `tailSet` in class `ImmutableSortedSet<C extends java.lang.Comparable>`

    - #### tailSet

          @GwtIncompatible(value="NavigableSet")
          public ContiguousSet<C> tailSet(C fromElement,
                                                      boolean inclusive)

      Specified by:
        `tailSet` in interface `java.util.NavigableSet<C extends java.lang.Comparable>`
      Overrides:
        `tailSet` in class `ImmutableSortedSet<C extends java.lang.Comparable>`
      Since:
        12.0

    - #### intersection

          public abstract ContiguousSet<C> intersection(ContiguousSet<C> other)

      Returns the set of values that are contained in both this set and the other.

      This method should always be used instead of `Sets.intersection(java.util.Set<E>, java.util.Set<?>)` for `ContiguousSet` instances.

    - #### range

          public abstract Range<C> range()

      Returns a range, closed on both ends, whose endpoints are the minimum and maximum values contained in this set. This is equivalent to `range(CLOSED, CLOSED)`.
      Throws:
        `java.util.NoSuchElementException` - if this set is empty

    - #### range

          public abstract Range<C> range(BoundType lowerBoundType,
                       BoundType upperBoundType)

      Returns the minimal range with the given boundary types for which all values in this set are contained within the range.

      Note that this method will return ranges with unbounded endpoints if `BoundType.OPEN` is requested for a domain minimum or maximum. For example, if `set` was created from the range `[1..Integer.MAX_VALUE]` then `set.range(CLOSED, OPEN)` must return `[1..∞)`.

      Throws:
        `java.util.NoSuchElementException` - if this set is empty

    - #### toString

          public java.lang.String toString()

      Returns a short-hand representation of the contents such as `"[1..100]"`.
      Overrides:
        `toString` in class `java.util.AbstractCollection<C extends java.lang.Comparable>`

    - #### builder

          @Deprecated
          public static <E> ImmutableSortedSet.Builder<E> builder()

      Deprecated. Use `create(com.google.common.collect.Range<C>, com.google.common.collect.DiscreteDomain<C>)`.
      Not supported. `ContiguousSet` instances are constructed with `create(com.google.common.collect.Range<C>, com.google.common.collect.DiscreteDomain<C>)`. This method exists only to hide `ImmutableSet.builder()` from consumers of `ContiguousSet`.
      Throws:
        `java.lang.UnsupportedOperationException` - always