Package: groovy.lang

## [Java] Class IntRange

- groovy.lang.IntRange

- All Implemented Interfaces and Traits:
    Range, Serializable

      public class IntRange
      extends AbstractList
      implements Range, Serializable

  Represents a list of Integer objects starting at and potentially including a specified `from` value up (or down) to and potentially including a given `to` value.

  Instances of this class may be either inclusive aware or non-inclusive aware. See the relevant constructors for creating each type. Inclusive aware IntRange instances are suitable for use with Groovy's range indexing - in particular if the from or to values might be negative. This normally happens underneath the covers but is worth keeping in mind if creating these ranges yourself explicitly.

  Note: the design of this class might seem a little strange at first. It contains Boolean flags, `inclusiveLeft` and `inclusiveRight`, which can be `true`, `false` or `null`. This design is for backwards compatibility reasons. Groovy uses this class under the covers to represent range indexing, e.g. `someList[x..y]` and `someString[x..<y]`. In early versions of Groovy the ranges in these expressions were represented under the covers by the `new IntRange(x, y)` and `new IntRange(x, y-1)`. This turns out to be a lossy abstraction when x and/or y are negative values. Now the latter case is represented by `new IntRange(false, x, y)`.

  Note: This class is a copy of ObjectRange optimized for `int`. If you make any changes to this class, you might consider making parallel changes to ObjectRange.

- - ### Constructor Summary

    Constructors
    Constructor and description
    `IntRange(int from, int to)` Creates a new non-inclusive aware `IntRange`.
    `protected IntRange(int from, int to, boolean reverse)` Creates a new non-inclusive aware `IntRange`.
    `IntRange(boolean inclusiveRight, int from, int to)` Creates a new inclusive aware `IntRange`.
    `IntRange(boolean inclusiveLeft, boolean inclusiveRight, int from, int to)` Creates a new inclusive aware `IntRange`

  - ### Methods Summary

    Methods
    Type Params | Return Type | Name and description
    --- | --- | ---
    `<T extends Number & Comparable>` | `public NumberRange` | `by(T stepSize)` Creates a new NumberRange with the same `from` and `to` as this IntRange but with a step size of `stepSize`.
    `` | `public boolean` | `contains(Object value)`
    `` | `public boolean` | `containsAll(Collection other)`
    `` | `public boolean` | `containsWithinBounds(Object o)`
    `` | `public boolean` | `equals(Object that)` Determines if this object is equal to another object.
    `` | `public boolean` | `equals(IntRange that)` Compares an IntRange to another IntRange.
    `` | `public Integer` | `get(int index)`
    `` | `public Integer` | `getFrom()`
    `` | `public int` | `getFromInt()` Gets the 'from' value as a primitive integer.
    `` | `public Boolean` | `getInclusive()` Returns the same as `getInclusiveRight`, kept here for backwards compatibility.
    `` | `public Boolean` | `getInclusiveLeft()` Returns the inclusiveLeft flag.
    `` | `public Boolean` | `getInclusiveRight()` Returns the inclusiveRight flag.
    `` | `public Integer` | `getTo()`
    `` | `public int` | `getToInt()` Gets the 'to' value as a primitive integer.
    `` | `public int` | `hashCode()`
    `` | `public String` | `inspect()`
    `` | `public boolean` | `isReverse()`
    `` | `public Iterator<Integer>` | `iterator()`
    `` | `public int` | `size()`
    `` | `public void` | `step(int step, Closure closure)`
    `` | `public List<Integer>` | `step(int step)`
    `` | `public List<Integer>` | `subList(int fromIndex, int toIndex)`
    `` | `public RangeInfo` | `subListBorders(int size)` A method for determining from and to information when using this IntRange to index an aggregate object of the specified size.
    `` | `public String` | `toString()`

  - ### Inherited Methods Summary

    Inherited Methods
    Methods inherited from class | Name
    --- | ---
    `class AbstractList` | `add, add, addAll, addAll, clear, contains, containsAll, equals, forEach, get, getClass, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, notify, notifyAll, parallelStream, remove, remove, removeAll, removeIf, replaceAll, retainAll, set, size, sort, spliterator, stream, subList, toArray, toArray, toArray, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### public IntRange(int from, int to)

      Creates a new non-inclusive aware `IntRange`. If `from` is greater than `to`, a reverse range is created with `from` and `to` swapped.

      throws:
        IllegalArgumentException if the range would contain more than Integer.MAX_VALUE values.
      Parameters:
        `from` - the first number in the range.
        `to` - the last number in the range.

    - #### protected IntRange(int from, int to, boolean reverse)

      Creates a new non-inclusive aware `IntRange`.

      throws:
        IllegalArgumentException if `from` is greater than `to`.
      Parameters:
        `from` - the first value in the range.
        `to` - the last value in the range.
        `reverse` - `true` if the range should count from `to` to `from`.

    - #### public IntRange(boolean inclusiveRight, int from, int to)

      Creates a new inclusive aware `IntRange`.

      Parameters:
        `from` - the first value in the range.
        `to` - the last value in the range.
        `inclusiveRight` - `true` if the to value is included in the range.

    - #### public IntRange(boolean inclusiveLeft, boolean inclusiveRight, int from, int to)

      Creates a new inclusive aware `IntRange`

      Parameters:
        `inclusiveLeft` - `true` if the from value is included in the range.
        `inclusiveRight` - `true` if the to value is included in the range.
        `from` - the first value in the range.
        `to` - the last value in the range.

  - ### Method Detail

    - #### <T extends Number & Comparable> public NumberRange by(T stepSize)

      Creates a new NumberRange with the same `from` and `to` as this IntRange but with a step size of `stepSize`.

      Parameters:
        `stepSize` - the desired step size
      Returns:
        a new NumberRange
      Since:
        2.5.0

    - #### @Override
      public boolean contains(Object value)

    - #### @Override
      public boolean containsAll(Collection other)

    - #### @Override
      public boolean containsWithinBounds(Object o)

    - #### @Override
      public boolean equals(Object that)

      Determines if this object is equal to another object. Delegates to AbstractList.equals if `that` is anything other than an IntRange.

      It is not necessary to override `hashCode`, as AbstractList.hashCode provides a suitable hash code.

      Note that equals is generally handled by DefaultGroovyMethods.equals instead of this method.

      Parameters:
        `that` - the object to compare
      Returns:
        `true` if the objects are equal

    - #### public boolean equals(IntRange that)

      Compares an IntRange to another IntRange.

      Parameters:
        `that` - the object to compare for equality
      Returns:
        `true` if the ranges are equal

    - #### @Override
      public Integer get(int index)

    - #### @Override
      public Integer getFrom()

    - #### public int getFromInt()

      Gets the 'from' value as a primitive integer.

      Returns:
        the 'from' value as a primitive integer.

    - #### public Boolean getInclusive()

      Returns the same as `getInclusiveRight`, kept here for backwards compatibility.

    - #### public Boolean getInclusiveLeft()

      Returns the inclusiveLeft flag. Null for non-inclusive aware ranges or non-null for inclusive aware ranges.

    - #### public Boolean getInclusiveRight()

      Returns the inclusiveRight flag. Null for non-inclusive aware ranges or non-null for inclusive aware ranges.

    - #### @Override
      public Integer getTo()

    - #### public int getToInt()

      Gets the 'to' value as a primitive integer.

      Returns:
        the 'to' value as a primitive integer.

    - #### @Override
      public int hashCode()

    - #### @Override
      public String inspect()

    - #### @Override
      public boolean isReverse()

    - #### @Override
      public Iterator<Integer> iterator()

    - #### @Override
      public int size()

    - #### @Override
      public void step(int step, Closure closure)

    - #### @Override
      public List<Integer> step(int step)

    - #### @Override
      public List<Integer> subList(int fromIndex, int toIndex)

    - #### public RangeInfo subListBorders(int size)

      A method for determining from and to information when using this IntRange to index an aggregate object of the specified size. Normally only used internally within Groovy but useful if adding range indexing support for your own aggregates.

      Parameters:
        `size` - the size of the aggregate being indexed
      Returns:
        the calculated range information (with 1 added to the to value, ready for providing to subList

    - #### @Override
      public String toString()