## 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: 18231 $
Author:
  James Strachan

Field Summary

Fields inherited from class java.util.AbstractList
`modCount`

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

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

Copyright © 2003-2009 The Codehaus. All rights reserved.