Interval (Eclipse Collections

java.lang.Object
- org.eclipse.collections.impl.AbstractRichIterable<T>
- - org.eclipse.collections.impl.lazy.AbstractLazyIterable<Integer>
  - - org.eclipse.collections.impl.list.Interval

All Implemented Interfaces:

Serializable, Iterable<Integer>, Collection<Integer>, List<Integer>, RandomAccess, InternalIterable<Integer>, LazyIterable<Integer>, RichIterable<Integer>
```
public final class Interval
extends AbstractLazyIterable<Integer>
implements List<Integer>, Serializable, RandomAccess
```
An Interval is a range of integers that may be iterated over using a step value. Interval is an OO implementation of a for-loop.

See Also:

Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(Integer integer)`
`void`	`add(int index, Integer element)`
`boolean`	`addAll(Collection<? extends Integer> collection)`
`boolean`	`addAll(int index, Collection<? extends Integer> collection)`
`<R extends Collection<Integer>> R`	`addAllTo(R targetCollection)`
`Interval`	`by(int newStep)` This instance `by` method allows Interval to act as a fluent builder for itself.
`void`	`clear()`
`<T,R extends Collection<T>> R`	`collect(Function<? super Integer,? extends T> function, R target)`
`boolean`	`contains(int value)` Returns true if the Interval contains the specified int value.
`boolean`	`contains(Object object)`
`boolean`	`containsAll(int... values)` Returns true if the Interval contains all the specified int values.
`boolean`	`containsNone(int... values)` Returns true if the Interval contains none of the specified int values.
`LazyIterable<Integer>`	`distinct()`
`LazyIterable<Integer>`	`drop(int count)`
`void`	`each(Procedure<? super Integer> procedure)`
`boolean`	`equals(Object otherList)`
`static Interval`	`evensFromTo(int from, int to)` Returns an Interval representing the even values from the value from to the value to.
`Number`	`factorial()` Returns the Number result of calculating factorial for the range.
`void`	`forEach(IntProcedure procedure)`
`void`	`forEach(Procedure<? super Integer> procedure, Executor executor)` This method executes a void procedure against an executor, passing the current index of the interval.
`void`	`forEach(Procedure<? super Integer> procedure, int startIndex, int endIndex)`
`<P> void`	`forEachWith(IntObjectProcedure<? super P> procedure, P parameter)`
`<P> void`	`forEachWith(Procedure2<? super Integer,? super P> procedure, P parameter)`
`void`	`forEachWithIndex(IntIntProcedure procedure)`
`void`	`forEachWithIndex(ObjectIntProcedure<? super Integer> objectIntProcedure)`
`void`	`forEachWithIndex(ObjectIntProcedure<? super Integer> objectIntProcedure, int startIndex, int endIndex)`
`static Interval`	`from(int newFrom)` This static `from` method allows Interval to act as a fluent builder for itself.
`static Interval`	`fromTo(int from, int to)` Returns an Interval starting from the value from to the specified value to with a step value of 1.
`static Interval`	`fromToBy(int from, int to, int stepBy)` Returns an Interval for the range of integers inclusively between from and to with the specified stepBy value.
`static Interval`	`fromToExclusive(int from, int to)` Returns an Interval starting from the value from until the specified value to (exclusive) with a step value of 1
`Integer`	`get(int index)`
`Integer`	`getFirst()`
`Integer`	`getLast()`
`int`	`hashCode()`
`int`	`indexOf(Object object)`
`double`	`injectInto(double injectedValue, DoubleObjectToDoubleFunction<? super Integer> function)`
`int`	`injectInto(int injectedValue, IntObjectToIntFunction<? super Integer> function)`
`long`	`injectInto(long injectedValue, LongObjectToLongFunction<? super Integer> function)`
`<R> R`	`injectInto(R injectValue, Function2<? super R,? super Integer,? extends R> function)`
`Iterator<Integer>`	`iterator()`
`int`	`lastIndexOf(Object object)`
`ListIterator<Integer>`	`listIterator()`
`ListIterator<Integer>`	`listIterator(int index)`
`static Interval`	`oddsFromTo(int from, int to)` Returns an Interval representing the odd values from the value from to the value to.
`static Interval`	`oneTo(int count)` Returns an Interval starting from 1 to the specified count value with a step value of 1.
`static Interval`	`oneToBy(int count, int step)` Returns an Interval starting from 1 to the specified count value with a step value of step.
`Number`	`product()` Returns the Number result of calculating product for the range.
`<R extends Collection<Integer>> R`	`reject(Predicate<? super Integer> predicate, R target)`
`Integer`	`remove(int index)`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> collection)`
`boolean`	`retainAll(Collection<?> collection)`
`void`	`reverseForEach(Procedure<? super Integer> procedure)`
`<R> R`	`reverseInjectInto(R injectValue, Function2<? super R,Integer,? extends R> function)`
`Interval`	`reverseThis()` Returns a new interval with the from and to values reversed and the step value negated.
`void`	`run(Runnable runnable)` This method runs a runnable a specified number of times against on the current thread.
`void`	`run(Runnable runnable, Executor executor)` This method runs a runnable a specified number of times against an executor.
`<R extends Collection<Integer>> R`	`select(Predicate<? super Integer> predicate, R target)`
`Integer`	`set(int index, Integer element)`
`int`	`size()` Returns the size of the interval.
`Interval`	`subList(int fromIndex, int toIndex)`
`LazyIterable<Integer>`	`take(int count)`
`Interval`	`to(int newTo)` This instance `to` method allows Interval to act as a fluent builder for itself.
`Integer[]`	`toArray()`
`static Integer[]`	`toArray(int from, int to)` Returns an Integer array with the values inclusively between from and to.
`MutableBag<Integer>`	`toBag()`
`int[]`	`toIntArray()` Converts the interval to an Integer array.
`MutableList<Integer>`	`toList()`
`static Integer[]`	`toReverseArray(int from, int to)`
`static MutableList<Integer>`	`toReverseList(int from, int to)` Returns a MutableList representing the Integer values from the value from to the value to in reverse.
`MutableSet<Integer>`	`toSet()`
`static MutableSet<Integer>`	`toSet(int from, int to)` Returns a Set representing the Integer values from the value from to the value to.
`String`	`toString()` Returns a string with the elements of the iterable separated by commas with spaces and enclosed in square brackets.
`static Interval`	`zero()` Returns an Interval starting at zero.
`static Interval`	`zeroTo(int count)` Returns an Interval starting from 0 to the specified count value with a step value of 1.
`static Interval`	`zeroToBy(int count, int step)` Returns an Interval starting from 0 to the specified count value with a step value of step.

Methods inherited from class org.eclipse.collections.impl.lazy.AbstractLazyIterable
asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, concatenate, dropWhile, flatCollect, getOnly, groupBy, groupByEach, groupByUniqueKey, into, isEmpty, maxByOptional, maxOptional, maxOptional, minByOptional, minOptional, minOptional, partition, partitionWith, reject, rejectWith, select, selectInstancesOf, selectWith, sumByDouble, sumByFloat, sumByInt, sumByLong, takeWhile, tap, toArray, toStack, zip, zipWithIndex

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, collectIf, collectWith, containsAll, containsAllArguments, containsAllIterable, count, countByEach, countWith, detect, detectOptional, detectWith, detectWithIfNone, detectWithOptional, flatCollect, forEach, groupBy, groupByEach, groupByUniqueKey, injectInto, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, rejectWith, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBiMap, toMap, toSortedBag, toSortedBag, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndex

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.List
containsAll, isEmpty, replaceAll, sort, spliterator, toArray

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface org.eclipse.collections.api.LazyIterable
flatCollectWith

Methods inherited from interface org.eclipse.collections.api.RichIterable
aggregateBy, aggregateBy, aggregateInPlaceBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, containsAll, containsAllArguments, containsAllIterable, containsAny, containsAnyIterable, containsBy, containsNone, containsNoneIterable, count, countBy, countBy, countByEach, countByEach, countByWith, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, flatCollect, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, flatCollectWith, forEach, getAny, groupBy, groupByAndCollect, groupByEach, groupByUniqueKey, injectInto, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, makeString, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, reduce, reduceInPlace, reduceInPlace, rejectWith, selectWith, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBiMap, toImmutableBag, toImmutableBiMap, toImmutableList, toImmutableMap, toImmutableSet, toImmutableSortedBag, toImmutableSortedBag, toImmutableSortedBagBy, toImmutableSortedList, toImmutableSortedList, toImmutableSortedListBy, toImmutableSortedSet, toImmutableSortedSet, toImmutableSortedSetBy, toMap, toMap, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndex

Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach

- Method Detail
  - from
```
public static Interval from(int newFrom)
```
    This static from method allows Interval to act as a fluent builder for itself. It works in conjunction with the instance methods to(int) and by(int).
    Usage Example:
```
 Interval interval1 = Interval.from(1).to(5);         // results in: 1, 2, 3, 4, 5.
 Interval interval2 = Interval.from(1).to(10).by(2);  // results in: 1, 3, 5, 7, 9.
 
```
  - to
```
public Interval to(int newTo)
```
    This instance to method allows Interval to act as a fluent builder for itself. It works in conjunction with the static method from(int) and instance method by(int).
    Usage Example:
```
 Interval interval1 = Interval.from(1).to(5);         // results in: 1, 2, 3, 4, 5.
 Interval interval2 = Interval.from(1).to(10).by(2);  // results in: 1, 3, 5, 7, 9.
 
```
  - by
```
public Interval by(int newStep)
```
    This instance by method allows Interval to act as a fluent builder for itself. It works in conjunction with the static method from(int) and instance method to(int).
    Usage Example:
```
 Interval interval1 = Interval.from(1).to(5);         // results in: 1, 2, 3, 4, 5.
 Interval interval2 = Interval.from(1).to(10).by(2);  // results in: 1, 3, 5, 7, 9.
 
```
  - zero
```
public static Interval zero()
```
    Returns an Interval starting at zero.
    Usage Example:
```
 Interval interval1 = Interval.zero().to(5);         // results in: 0, 1, 2, 3, 4, 5.
 Interval interval2 = Interval.zero().to(10).by(2);  // results in: 0, 2, 4, 6, 8, 10.
 
```
  - oneTo
```
public static Interval oneTo(int count)
```
    Returns an Interval starting from 1 to the specified count value with a step value of 1.
  - oneToBy
```
public static Interval oneToBy(int count,
                               int step)
```
    Returns an Interval starting from 1 to the specified count value with a step value of step.
  - zeroTo
```
public static Interval zeroTo(int count)
```
    Returns an Interval starting from 0 to the specified count value with a step value of 1.
  - zeroToBy
```
public static Interval zeroToBy(int count,
                                int step)
```
    Returns an Interval starting from 0 to the specified count value with a step value of step.
  - fromTo
```
public static Interval fromTo(int from,
                              int to)
```
    Returns an Interval starting from the value from to the specified value to with a step value of 1.
  - fromToExclusive
```
public static Interval fromToExclusive(int from,
                                       int to)
```
    Returns an Interval starting from the value from until the specified value to (exclusive) with a step value of 1
  - evensFromTo
```
public static Interval evensFromTo(int from,
                                   int to)
```
    Returns an Interval representing the even values from the value from to the value to.
  - oddsFromTo
```
public static Interval oddsFromTo(int from,
                                  int to)
```
    Returns an Interval representing the odd values from the value from to the value to.
  - toSet
```
public static MutableSet<Integer> toSet(int from,
                                        int to)
```
    Returns a Set representing the Integer values from the value from to the value to.
  - toReverseList
```
public static MutableList<Integer> toReverseList(int from,
                                                 int to)
```
    Returns a MutableList representing the Integer values from the value from to the value to in reverse.
  - toArray
```
public static Integer[] toArray(int from,
                                int to)
```
    Returns an Integer array with the values inclusively between from and to.
  - toReverseArray
```
public static Integer[] toReverseArray(int from,
                                       int to)
```
  - fromToBy
```
public static Interval fromToBy(int from,
                                int to,
                                int stepBy)
```
    Returns an Interval for the range of integers inclusively between from and to with the specified stepBy value.
  - containsAll
```
public boolean containsAll(int... values)
```
    Returns true if the Interval contains all the specified int values.
  - containsNone
```
public boolean containsNone(int... values)
```
    Returns true if the Interval contains none of the specified int values.
  - contains
```
public boolean contains(Object object)
```
    Specified by:
    
    contains in interface Collection<Integer>
    
    Specified by:
    
    contains in interface List<Integer>
    
    Specified by:
    
    contains in interface RichIterable<Integer>
    
    Overrides:
    
    contains in class AbstractRichIterable<Integer>
  - contains
```
public boolean contains(int value)
```
    Returns true if the Interval contains the specified int value.
  - factorial
```
public Number factorial()
```
    Returns the Number result of calculating factorial for the range.
  - product
```
public Number product()
```
    Returns the Number result of calculating product for the range.
  - forEachWithIndex
```
public void forEachWithIndex(IntIntProcedure procedure)
```
  - forEachWithIndex
```
public void forEachWithIndex(ObjectIntProcedure<? super Integer> objectIntProcedure)
```
    Specified by:
    
    forEachWithIndex in interface InternalIterable<Integer>
    
    Overrides:
    
    forEachWithIndex in class AbstractRichIterable<Integer>
  - forEachWith
```
public <P> void forEachWith(IntObjectProcedure<? super P> procedure,
                            P parameter)
```
  - forEachWith
```
public <P> void forEachWith(Procedure2<? super Integer,? super P> procedure,
                            P parameter)
```
    Specified by:
    
    forEachWith in interface InternalIterable<Integer>
    
    Overrides:
    
    forEachWith in class AbstractRichIterable<Integer>
  - forEach
```
public void forEach(IntProcedure procedure)
```
  - each
```
public void each(Procedure<? super Integer> procedure)
```
    Specified by:
    
    each in interface RichIterable<Integer>
  - forEach
```
public void forEach(Procedure<? super Integer> procedure,
                    Executor executor)
```
    This method executes a void procedure against an executor, passing the current index of the interval.
  - run
```
public void run(Runnable runnable)
```
    This method runs a runnable a specified number of times against on the current thread.
  - run
```
public void run(Runnable runnable,
                Executor executor)
```
    This method runs a runnable a specified number of times against an executor. The method is effectively asynchronous because it does not wait for all the runnables to finish.
  - injectInto
```
public <R> R injectInto(R injectValue,
                        Function2<? super R,? super Integer,? extends R> function)
```
    Specified by:
    
    injectInto in interface RichIterable<Integer>
    
    Overrides:
    
    injectInto in class AbstractRichIterable<Integer>
  - injectInto
```
public int injectInto(int injectedValue,
                      IntObjectToIntFunction<? super Integer> function)
```
    Specified by:
    
    injectInto in interface RichIterable<Integer>
    
    Overrides:
    
    injectInto in class AbstractRichIterable<Integer>
  - injectInto
```
public long injectInto(long injectedValue,
                       LongObjectToLongFunction<? super Integer> function)
```
    Specified by:
    
    injectInto in interface RichIterable<Integer>
    
    Overrides:
    
    injectInto in class AbstractRichIterable<Integer>
  - injectInto
```
public double injectInto(double injectedValue,
                         DoubleObjectToDoubleFunction<? super Integer> function)
```
    Specified by:
    
    injectInto in interface RichIterable<Integer>
    
    Overrides:
    
    injectInto in class AbstractRichIterable<Integer>
  - reverseForEach
```
public void reverseForEach(Procedure<? super Integer> procedure)
```
  - reverseInjectInto
```
public <R> R reverseInjectInto(R injectValue,
                               Function2<? super R,Integer,? extends R> function)
```
  - addAllTo
```
public <R extends Collection<Integer>> R addAllTo(R targetCollection)
```
  - collect
```
public <T,R extends Collection<T>> R collect(Function<? super Integer,? extends T> function,
                                             R target)
```
    Specified by:
    
    collect in interface RichIterable<Integer>
    
    Overrides:
    
    collect in class AbstractRichIterable<Integer>
  - select
```
public <R extends Collection<Integer>> R select(Predicate<? super Integer> predicate,
                                                R target)
```
    Specified by:
    
    select in interface RichIterable<Integer>
    
    Overrides:
    
    select in class AbstractRichIterable<Integer>
  - reject
```
public <R extends Collection<Integer>> R reject(Predicate<? super Integer> predicate,
                                                R target)
```
    Specified by:
    
    reject in interface RichIterable<Integer>
    
    Overrides:
    
    reject in class AbstractRichIterable<Integer>
  - equals
```
public boolean equals(Object otherList)
```
    Specified by:
    
    equals in interface Collection<Integer>
    
    Specified by:
    
    equals in interface List<Integer>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Collection<Integer>
    
    Specified by:
    
    hashCode in interface List<Integer>
    
    Overrides:
    
    hashCode in class Object
  - reverseThis
```
public Interval reverseThis()
```
    Returns a new interval with the from and to values reversed and the step value negated.
  - size
```
public int size()
```
    Returns the size of the interval.
    
    Specified by:
    
    size in interface Collection<Integer>
    
    Specified by:
    
    size in interface List<Integer>
    
    Specified by:
    
    size in interface RichIterable<Integer>
    
    Overrides:
    
    size in class AbstractLazyIterable<Integer>
  - toArray
```
public Integer[] toArray()
```
    Specified by:
    
    toArray in interface Collection<Integer>
    
    Specified by:
    
    toArray in interface List<Integer>
    
    Specified by:
    
    toArray in interface RichIterable<Integer>
    
    Overrides:
    
    toArray in class AbstractRichIterable<Integer>
  - toIntArray
```
public int[] toIntArray()
```
    Converts the interval to an Integer array.
  - toString
```
public String toString()
```
    Description copied from class: AbstractRichIterable
    Returns a string with the elements of the iterable separated by commas with spaces and enclosed in square brackets.
```
 Assert.assertEquals("[]", Lists.mutable.empty().toString());
 Assert.assertEquals("[1]", Lists.mutable.with(1).toString());
 Assert.assertEquals("[1, 2, 3]", Lists.mutable.with(1, 2, 3).toString());
 
```
    Specified by:
    
    toString in interface RichIterable<Integer>
    
    Overrides:
    
    toString in class AbstractRichIterable<Integer>
    
    Returns:
    
    a string representation of this collection.
    
    See Also:
    
    AbstractCollection.toString()
  - 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>
  - getFirst
```
public Integer getFirst()
```
    Specified by:
    
    getFirst in interface LazyIterable<Integer>
    
    Specified by:
    
    getFirst in interface RichIterable<Integer>
    
    Overrides:
    
    getFirst in class AbstractLazyIterable<Integer>
  - getLast
```
public Integer getLast()
```
    Specified by:
    
    getLast in interface RichIterable<Integer>
    
    Overrides:
    
    getLast in class AbstractLazyIterable<Integer>
  - forEach
```
public void forEach(Procedure<? super Integer> procedure,
                    int startIndex,
                    int endIndex)
```
  - forEachWithIndex
```
public void forEachWithIndex(ObjectIntProcedure<? super Integer> objectIntProcedure,
                             int startIndex,
                             int endIndex)
```
  - get
```
public Integer get(int index)
```
    Specified by:
    
    get in interface List<Integer>
  - indexOf
```
public int indexOf(Object object)
```
    Specified by:
    
    indexOf in interface List<Integer>
  - lastIndexOf
```
public int lastIndexOf(Object object)
```
    Specified by:
    
    lastIndexOf in interface List<Integer>
  - toList
```
public MutableList<Integer> toList()
```
    Specified by:
    
    toList in interface RichIterable<Integer>
    
    Overrides:
    
    toList in class AbstractRichIterable<Integer>
  - toSet
```
public MutableSet<Integer> toSet()
```
    Specified by:
    
    toSet in interface RichIterable<Integer>
    
    Overrides:
    
    toSet in class AbstractRichIterable<Integer>
  - toBag
```
public MutableBag<Integer> toBag()
```
    Specified by:
    
    toBag in interface RichIterable<Integer>
    
    Overrides:
    
    toBag in class AbstractRichIterable<Integer>
  - add
```
public boolean add(Integer integer)
```
    Specified by:
    
    add in interface Collection<Integer>
    
    Specified by:
    
    add in interface List<Integer>
  - remove
```
public boolean remove(Object o)
```
    Specified by:
    
    remove in interface Collection<Integer>
    
    Specified by:
    
    remove in interface List<Integer>
  - addAll
```
public boolean addAll(Collection<? extends Integer> collection)
```
    Specified by:
    
    addAll in interface Collection<Integer>
    
    Specified by:
    
    addAll in interface List<Integer>
  - addAll
```
public boolean addAll(int index,
                      Collection<? extends Integer> collection)
```
    Specified by:
    
    addAll in interface List<Integer>
  - removeAll
```
public boolean removeAll(Collection<?> collection)
```
    Specified by:
    
    removeAll in interface Collection<Integer>
    
    Specified by:
    
    removeAll in interface List<Integer>
  - retainAll
```
public boolean retainAll(Collection<?> collection)
```
    Specified by:
    
    retainAll in interface Collection<Integer>
    
    Specified by:
    
    retainAll in interface List<Integer>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Collection<Integer>
    
    Specified by:
    
    clear in interface List<Integer>
  - set
```
public Integer set(int index,
                   Integer element)
```
    Specified by:
    
    set in interface List<Integer>
  - add
```
public void add(int index,
                Integer element)
```
    Specified by:
    
    add in interface List<Integer>
  - remove
```
public Integer remove(int index)
```
    Specified by:
    
    remove in interface List<Integer>
  - listIterator
```
public ListIterator<Integer> listIterator()
```
    Specified by:
    
    listIterator in interface List<Integer>
  - listIterator
```
public ListIterator<Integer> listIterator(int index)
```
    Specified by:
    
    listIterator in interface List<Integer>
  - subList
```
public Interval subList(int fromIndex,
                        int toIndex)
```
    Specified by:
    
    subList in interface List<Integer>
  - take
```
public LazyIterable<Integer> take(int count)
```
    Specified by:
    
    take in interface LazyIterable<Integer>
    
    Overrides:
    
    take in class AbstractLazyIterable<Integer>
  - drop
```
public LazyIterable<Integer> drop(int count)
```
    Specified by:
    
    drop in interface LazyIterable<Integer>
    
    Overrides:
    
    drop in class AbstractLazyIterable<Integer>
  - distinct
```
public LazyIterable<Integer> distinct()
```
    Specified by:
    
    distinct in interface LazyIterable<Integer>
    
    Overrides:
    
    distinct in class AbstractLazyIterable<Integer>

Class Interval

Method Summary

Methods inherited from class org.eclipse.collections.impl.lazy.AbstractLazyIterable

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.eclipse.collections.api.LazyIterable

Methods inherited from interface org.eclipse.collections.api.RichIterable

Methods inherited from interface org.eclipse.collections.api.InternalIterable

Method Detail

from

to

by

zero

oneTo

oneToBy

zeroTo

zeroToBy

fromTo

fromToExclusive

evensFromTo

oddsFromTo

toSet

toReverseList

toArray

toReverseArray

fromToBy

containsAll

containsNone

contains

contains

factorial

product

forEachWithIndex

forEachWithIndex

forEachWith

forEachWith

forEach

each

forEach

run

run

injectInto

injectInto

injectInto

injectInto

reverseForEach

reverseInjectInto

addAllTo

collect

select

reject

equals

hashCode

reverseThis

size

toArray

toIntArray

toString

iterator

getFirst

getLast

forEach

forEachWithIndex

get

indexOf

lastIndexOf

toList

toSet

toBag

add

remove

addAll

addAll

removeAll

retainAll

clear

set