LazyIterable (Goldman Sachs Collections API

All Superinterfaces:

InternalIterable<T>, java.lang.Iterable<T>, RichIterable<T>
```
public interface LazyIterable<T>
extends RichIterable<T>
```
A LazyIterable is RichIterable which will defer evaluation for certain methods like select, reject, collect, etc. Any methods that do not return a LazyIterable when called will cause evaluation to be forced.

Since:

1.0

Method Summary

Methods
Modifier and Type	Method and Description
`LazyIterable<RichIterable<T>>`	`chunk(int size)` Creates a deferred chunking iterable.
`<V> LazyIterable<V>`	`collect(Function<? super T,? extends V> function)` Creates a deferred iterable for collecting elements from the current iterable.
`LazyBooleanIterable`	`collectBoolean(BooleanFunction<? super T> booleanFunction)` Returns a lazy BooleanIterable which will transform the underlying iterable data to boolean values based on the booleanFunction.
`LazyByteIterable`	`collectByte(ByteFunction<? super T> byteFunction)` Returns a lazy ByteIterable which will transform the underlying iterable data to byte values based on the byteFunction.
`LazyCharIterable`	`collectChar(CharFunction<? super T> charFunction)` Returns a lazy CharIterable which will transform the underlying iterable data to char values based on the charFunction.
`LazyDoubleIterable`	`collectDouble(DoubleFunction<? super T> doubleFunction)` Returns a lazy DoubleIterable which will transform the underlying iterable data to double values based on the doubleFunction.
`LazyFloatIterable`	`collectFloat(FloatFunction<? super T> floatFunction)` Returns a lazy FloatIterable which will transform the underlying iterable data to float values based on the floatFunction.
`<V> LazyIterable<V>`	`collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function)` Creates a deferred iterable for selecting and collecting elements from the current iterable.
`LazyIntIterable`	`collectInt(IntFunction<? super T> intFunction)` Returns a lazy IntIterable which will transform the underlying iterable data to int values based on the intFunction.
`LazyLongIterable`	`collectLong(LongFunction<? super T> longFunction)` Returns a lazy LongIterable which will transform the underlying iterable data to long values based on the longFunction.
`LazyShortIterable`	`collectShort(ShortFunction<? super T> shortFunction)` Returns a lazy ShortIterable which will transform the underlying iterable data to short values based on the shortFunction.
`<P,V> LazyIterable<V>`	`collectWith(Function2<? super T,? super P,? extends V> function, P parameter)` Same as collect with a `Function2` and specified parameter which is passed to the block
`LazyIterable<T>`	`concatenate(java.lang.Iterable<T> iterable)` Creates a deferred iterable that will join this iterable with the specified iterable.
`LazyIterable<T>`	`distinct()` Creates a deferred distinct iterable to get distinct elements from the current iterable.
`LazyIterable<T>`	`drop(int count)` Creates a deferred drop iterable for the current iterable using the specified count as the limit.
`<V> LazyIterable<V>`	`flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function)` Creates a deferred flattening iterable for the current iterable.
`<R extends java.util.Collection<T>> R`	`into(R target)` Iterates over this iterable adding all elements into the target collection.
`LazyIterable<T>`	`reject(Predicate<? super T> predicate)` Creates a deferred iterable for rejecting elements from the current iterable.
`<P> LazyIterable<T>`	`rejectWith(Predicate2<? super T,? super P> predicate, P parameter)` Similar to `RichIterable.reject(Predicate)`, except with an evaluation parameter for the second generic argument in `Predicate2`.
`LazyIterable<T>`	`select(Predicate<? super T> predicate)` Creates a deferred iterable for selecting elements from the current iterable.
`<S> LazyIterable<S>`	`selectInstancesOf(java.lang.Class<S> clazz)` Returns all elements of the source collection that are instances of the Class `clazz`.
`<P> LazyIterable<T>`	`selectWith(Predicate2<? super T,? super P> predicate, P parameter)` Similar to `RichIterable.select(Predicate)`, except with an evaluation parameter for the second generic argument in `Predicate2`.
`LazyIterable<T>`	`take(int count)` Creates a deferred take iterable for the current iterable using the specified count as the limit.
`<S> LazyIterable<Pair<T,S>>`	`zip(java.lang.Iterable<S> that)` Creates a deferred zip iterable.
`LazyIterable<Pair<T,java.lang.Integer>>`	`zipWithIndex()` Creates a deferred zipWithIndex iterable.

Methods inherited from interface com.gs.collections.api.RichIterable
aggregateBy, aggregateInPlaceBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, flatCollect, getFirst, getLast, groupBy, groupBy, groupByEach, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, isEmpty, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, partition, partitionWith, reject, rejectWith, select, selectWith, size, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex

Methods inherited from interface com.gs.collections.api.InternalIterable
forEach, forEachWith, forEachWithIndex

Methods inherited from interface java.lang.Iterable
iterator

- Method Detail
  - select
```
LazyIterable<T> select(Predicate<? super T> predicate)
```
    Creates a deferred iterable for selecting elements from the current iterable.
    
    Specified by:
    
    select in interface RichIterable<T>
  - selectWith
```
<P> LazyIterable<T> selectWith(Predicate2<? super T,? super P> predicate,
                             P parameter)
```
    Description copied from interface: RichIterable
    
    Similar to RichIterable.select(Predicate), except with an evaluation parameter for the second generic argument in Predicate2.
    
    Specified by:
    
    selectWith in interface RichIterable<T>
    
    Parameters:
    predicate - a Predicate2 to use as the select criteria
    parameter - a parameter to pass in for evaluation of the second argument P in predicate
    See Also:
    RichIterable.select(Predicate)
  - selectInstancesOf
```
<S> LazyIterable<S> selectInstancesOf(java.lang.Class<S> clazz)
```
    Description copied from interface: RichIterable
    
    Returns all elements of the source collection that are instances of the Class clazz.
    
    Specified by:
    
    selectInstancesOf in interface RichIterable<T>
  - reject
```
LazyIterable<T> reject(Predicate<? super T> predicate)
```
    Creates a deferred iterable for rejecting elements from the current iterable.
    
    Specified by:
    
    reject in interface RichIterable<T>
    
    Parameters:
    predicate - a Predicate to use as the reject criteria
    
    Returns:
    a RichIterable that contains elements that cause Predicate.accept(Object) method to evaluate to false
  - rejectWith
```
<P> LazyIterable<T> rejectWith(Predicate2<? super T,? super P> predicate,
                             P parameter)
```
    Description copied from interface: RichIterable
    
    Similar to RichIterable.reject(Predicate), except with an evaluation parameter for the second generic argument in Predicate2.
    
    Specified by:
    
    rejectWith in interface RichIterable<T>
    
    Parameters:
    predicate - a Predicate2 to use as the select criteria
    parameter - a parameter to pass in for evaluation of the second argument P in predicate
    See Also:
    RichIterable.select(Predicate)
  - collect
```
<V> LazyIterable<V> collect(Function<? super T,? extends V> function)
```
    Creates a deferred iterable for collecting elements from the current iterable.
    
    Specified by:
    
    collect in interface RichIterable<T>
  - collectWith
```
<P,V> LazyIterable<V> collectWith(Function2<? super T,? super P,? extends V> function,
                                P parameter)
```
    Description copied from interface: RichIterable
    Same as collect with a Function2 and specified parameter which is passed to the block
```
e.g.
 Function2 addParameterFunction =
 new Function2()
 {
      public Integer value(final Integer each, final Integer parameter)
      {
          return each + parameter;
      }
 };
 FastList.newListWith(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1));
 
```
    Specified by:
    
    collectWith in interface RichIterable<T>
    
    Parameters:
    function - A Function2 to use as the collect transformation function
    parameter - A parameter to pass in for evaluation of the second argument P in function
    
    Returns:
    A new RichIterable that contains the transformed elements returned by Function2.value(Object, Object)
    See Also:
    RichIterable.collect(Function)
  - collectIf
```
<V> LazyIterable<V> collectIf(Predicate<? super T> predicate,
                            Function<? super T,? extends V> function)
```
    Creates a deferred iterable for selecting and collecting elements from the current iterable.
    
    Specified by:
    
    collectIf in interface RichIterable<T>
  - take
```
LazyIterable<T> take(int count)
```
    Creates a deferred take iterable for the current iterable using the specified count as the limit.
  - drop
```
LazyIterable<T> drop(int count)
```
    Creates a deferred drop iterable for the current iterable using the specified count as the limit.
  - distinct
```
LazyIterable<T> distinct()
```
    Creates a deferred distinct iterable to get distinct elements from the current iterable.
    
    Since:
    
    5.0
  - flatCollect
```
<V> LazyIterable<V> flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function)
```
    Creates a deferred flattening iterable for the current iterable.
    
    Specified by:
    
    flatCollect in interface RichIterable<T>
    
    Parameters:
    function - The Function to apply
    
    Returns:
    a new flattened collection produced by applying the given function
  - concatenate
```
LazyIterable<T> concatenate(java.lang.Iterable<T> iterable)
```
    Creates a deferred iterable that will join this iterable with the specified iterable.
  - zip
```
<S> LazyIterable<Pair<T,S>> zip(java.lang.Iterable<S> that)
```
    Creates a deferred zip iterable.
    
    Specified by:
    
    zip in interface RichIterable<T>
    
    Type Parameters:
    S - the type of the second half of the returned pairs
    Parameters:
    that - The RichIterable providing the second half of each result pair
    
    Returns:
    A new RichIterable containing pairs consisting of corresponding elements of this RichIterable and that. The length of the returned RichIterable is the minimum of the lengths of this RichIterable and that.
  - zipWithIndex
```
LazyIterable<Pair<T,java.lang.Integer>> zipWithIndex()
```
    Creates a deferred zipWithIndex iterable.
    
    Specified by:
    
    zipWithIndex in interface RichIterable<T>
    
    Returns:
    A new RichIterable containing pairs consisting of all elements of this RichIterable paired with their index. Indices start at 0.
    See Also:
    RichIterable.zip(Iterable)
  - chunk
```
LazyIterable<RichIterable<T>> chunk(int size)
```
    Creates a deferred chunking iterable.
    
    Specified by:
    
    chunk in interface RichIterable<T>
    
    Parameters:
    size - the number of elements per chunk
    
    Returns:
    A RichIterable containing RichIterables of size size, except the last will be truncated if the elements don't divide evenly.
  - into
```
<R extends java.util.Collection<T>> R into(R target)
```
    Iterates over this iterable adding all elements into the target collection.
  - collectBoolean
```
LazyBooleanIterable collectBoolean(BooleanFunction<? super T> booleanFunction)
```
    Returns a lazy BooleanIterable which will transform the underlying iterable data to boolean values based on the booleanFunction.
    
    Specified by:
    
    collectBoolean in interface RichIterable<T>
  - collectByte
```
LazyByteIterable collectByte(ByteFunction<? super T> byteFunction)
```
    Returns a lazy ByteIterable which will transform the underlying iterable data to byte values based on the byteFunction.
    
    Specified by:
    
    collectByte in interface RichIterable<T>
  - collectChar
```
LazyCharIterable collectChar(CharFunction<? super T> charFunction)
```
    Returns a lazy CharIterable which will transform the underlying iterable data to char values based on the charFunction.
    
    Specified by:
    
    collectChar in interface RichIterable<T>
  - collectDouble
```
LazyDoubleIterable collectDouble(DoubleFunction<? super T> doubleFunction)
```
    Returns a lazy DoubleIterable which will transform the underlying iterable data to double values based on the doubleFunction.
    
    Specified by:
    
    collectDouble in interface RichIterable<T>
  - collectFloat
```
LazyFloatIterable collectFloat(FloatFunction<? super T> floatFunction)
```
    Returns a lazy FloatIterable which will transform the underlying iterable data to float values based on the floatFunction.
    
    Specified by:
    
    collectFloat in interface RichIterable<T>
  - collectInt
```
LazyIntIterable collectInt(IntFunction<? super T> intFunction)
```
    Returns a lazy IntIterable which will transform the underlying iterable data to int values based on the intFunction.
    
    Specified by:
    
    collectInt in interface RichIterable<T>
  - collectLong
```
LazyLongIterable collectLong(LongFunction<? super T> longFunction)
```
    Returns a lazy LongIterable which will transform the underlying iterable data to long values based on the longFunction.
    
    Specified by:
    
    collectLong in interface RichIterable<T>
  - collectShort
```
LazyShortIterable collectShort(ShortFunction<? super T> shortFunction)
```
    Returns a lazy ShortIterable which will transform the underlying iterable data to short values based on the shortFunction.
    
    Specified by:
    
    collectShort in interface RichIterable<T>

Interface LazyIterable<T>

Method Summary

Methods inherited from interface com.gs.collections.api.RichIterable

Methods inherited from interface com.gs.collections.api.InternalIterable

Methods inherited from interface java.lang.Iterable

Method Detail

select

selectWith

selectInstancesOf

reject

rejectWith

collect

collectWith

collectIf

take

drop

distinct

flatCollect

concatenate

zip

zipWithIndex

chunk

into

collectBoolean

collectByte

collectChar

collectDouble

collectFloat

collectInt

collectLong

collectShort