groovy.lang

## Class IntRange

- java.lang.Object
- - java.util.AbstractCollection<E>
  - - java.util.AbstractList<Integer>
    - - groovy.lang.IntRange

All Implemented Interfaces:
  Range<Integer>, Iterable<Integer>, Collection<Integer>, List<Integer>

    public class IntRange
    extends AbstractList<Integer>
    implements Range<Integer>

Represents a list of Integer objects from a specified int up (or down) to and including a given to.

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

Version:
  $Revision: 20589 $
Author:
  James Strachan

### Field Summary

### Fields inherited from class java.util.AbstractList

`modCount`

### Constructor Summary

Constructors
`` `IntRange(int from, int to)` Creates a new `IntRange`.
`protected` `IntRange(int from, int to, boolean reverse)` Creates a new `IntRange`.

### Method Summary

Methods
`boolean` `contains(Object value)`
`boolean` `containsAll(Collection other)`
`boolean` `containsWithinBounds(Object o)` Indicates whether an object is greater than or equal to the `from` value for the range and less than or equal to the `to` value.
`boolean` `equals(IntRange that)` Compares an `IntRange` to another `IntRange`.
`boolean` `equals(Object that)` Determines if this object is equal to another object.
`Integer` `get(int index)`
`Comparable` `getFrom()` The lower value in the range.
`int` `getFromInt()` Gets the 'from' value as an integer.
`Comparable` `getTo()` The upper value in the range.
`int` `getToInt()` Gets the 'to' value as an integer.
`String` `inspect()`
`boolean` `isReverse()` Indicates whether this is a reverse range which iterates backwards starting from the to value and ending on the from value
`Iterator<Integer>` `iterator()`
`int` `size()`
`List<Integer>` `step(int step)` Forms a list by stepping through the range by the indicated interval.
`void` `step(int step, Closure closure)` Steps through the range, calling a closure for each number.
`List<Integer>` `subList(int fromIndex, int toIndex)`
`String` `toString()`

### Methods inherited from class java.util.AbstractList

`add, add, addAll, clear, hashCode, indexOf, lastIndexOf, listIterator, listIterator, remove, removeRange, set`

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

`addAll, isEmpty, remove, removeAll, retainAll, toArray, toArray`

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

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

### Methods inherited from interface java.util.List

`add, add, addAll, addAll, clear, hashCode, indexOf, isEmpty, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, retainAll, set, toArray, toArray`

### Constructor Detail

#### IntRange

    public IntRange(int from,
            int to)

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

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

#### IntRange

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

Creates a new `IntRange`.

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`.
Throws:
  `IllegalArgumentException` - if `from` is greater than `to`.

### Method Detail

#### equals

    public boolean equals(Object that)

Determines if this object is equal to another object. Delegates to `AbstractList.equals(Object)` if `that` is anthing 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(List,List)` instead of this method.

Specified by:
  `equals` in interface `Collection<Integer>`
Specified by:
  `equals` in interface `List<Integer>`
Overrides:
  `equals` in class `AbstractList<Integer>`
Parameters:
  `that` - the object to compare
Returns:
  `true` if the objects are equal

#### equals

    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

#### getFrom

    public Comparable getFrom()

The lower value in the range.

Specified by:
  `getFrom` in interface `Range<Integer>`
Returns:
  the lower value in the range.

#### getTo

    public Comparable getTo()

The upper value in the range.

Specified by:
  `getTo` in interface `Range<Integer>`
Returns:
  the upper value in the range

#### getFromInt

    public int getFromInt()

Gets the 'from' value as an integer.

Returns:
  the 'from' value as an integer.

#### getToInt

    public int getToInt()

Gets the 'to' value as an integer.

Returns:
  the 'to' value as an integer.

#### isReverse

    public boolean isReverse()

Indicates whether this is a reverse range which iterates backwards starting from the to value and ending on the from value

Specified by:
  `isReverse` in interface `Range<Integer>`
Returns:
  `true` if this is a reverse range

#### containsWithinBounds

    public boolean containsWithinBounds(Object o)

Description copied from interface: `Range`
Indicates whether an object is greater than or equal to the `from` value for the range and less than or equal to the `to` value.

Specified by:
  `containsWithinBounds` in interface `Range<Integer>`
Parameters:
  `o` - the object to check against the boundaries of the range
Returns:
  `true` if the object is between the from and to values

#### get

    public Integer get(int index)

Specified by:
  `get` in interface `List<Integer>`
Specified by:
  `get` in class `AbstractList<Integer>`

#### size

    public int size()

Specified by:
  `size` in interface `Collection<Integer>`
Specified by:
  `size` in interface `List<Integer>`
Specified by:
  `size` in class `AbstractCollection<Integer>`

#### iterator

    public Iterator<Integer> iterator()

Specified by:
  `iterator` in interface `Iterable<Integer>`
Specified by:
  `iterator` in interface `Collection<Integer>`
Specified by:
  `iterator` in interface `List<Integer>`
Overrides:
  `iterator` in class `AbstractList<Integer>`

#### subList

    public List<Integer> subList(int fromIndex,
                        int toIndex)

Specified by:
  `subList` in interface `List<Integer>`
Overrides:
  `subList` in class `AbstractList<Integer>`

#### toString

    public String toString()

Overrides:
  `toString` in class `AbstractCollection<Integer>`

#### inspect

    public String inspect()

Specified by:
  `inspect` in interface `Range<Integer>`
Returns:
  the verbose `String` representation of this `Range` as would be typed into a console to create the `Range` instance

#### contains

    public boolean contains(Object value)

Specified by:
  `contains` in interface `Collection<Integer>`
Specified by:
  `contains` in interface `List<Integer>`
Overrides:
  `contains` in class `AbstractCollection<Integer>`

#### containsAll

    public boolean containsAll(Collection other)

Specified by:
  `containsAll` in interface `Collection<Integer>`
Specified by:
  `containsAll` in interface `List<Integer>`
Overrides:
  `containsAll` in class `AbstractCollection<Integer>`

#### step

    public void step(int step,
            Closure closure)

Steps through the range, calling a closure for each number.

Specified by:
  `step` in interface `Range<Integer>`
Parameters:
  `step` - the amount by which to step. If negative, steps through the range backwards.
  `closure` - the `Closure` to call

#### step

    public List<Integer> step(int step)

Forms a list by stepping through the range by the indicated interval.

Specified by:
  `step` in interface `Range<Integer>`
Parameters:
  `step` - the amount by which to step. If negative, steps through the range backwards.
Returns:
  the list formed by stepping through the range by the indicated interval.