LazyIterate (Eclipse Collections

java.lang.Object
- org.eclipse.collections.impl.utility.LazyIterate

```
public final class LazyIterate
extends Object
```
LazyIterate is a factory class which creates "deferred" iterables around the specified iterables. A "deferred" iterable performs some operation, such as filtering or transforming, when the result iterable is iterated over. This makes the operation very memory efficient, because you don't have to create intermediate collections during the operation.

Since:

1.0

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static <T> LazyIterable<T>`	`adapt(Iterable<T> iterable)`	Creates a deferred rich iterable for the specified iterable.
`static <T> LazyIterable<RichIterable<T>>`	`chunk(Iterable<T> iterable, int size)`
`static <T,V> LazyIterable<V>`	`collect(Iterable<T> iterable, Function<? super T,? extends V> function)`	Creates a deferred transforming iterable for the specified iterable.
`static <T,V> LazyIterable<V>`	`collectIf(Iterable<T> iterable, Predicate<? super T> predicate, Function<? super T,? extends V> function)`	Creates a deferred filtering and transforming iterable for the specified iterable.
`static <T> LazyIterable<T>`	`concatenate(Iterable<T>... iterables)`	Combines iterables into a deferred composite iterable.
`static <T> LazyIterable<T>`	`distinct(Iterable<T> iterable)`	Creates a deferred distinct iterable for the specified iterable.
`static <T> LazyIterable<T>`	`drop(Iterable<T> iterable, int count)`	Creates a deferred drop iterable for the specified iterable using the specified count as the size to drop.
`static <T> LazyIterable<T>`	`dropWhile(Iterable<T> iterable, Predicate<? super T> predicate)`	Creates a deferred dropWhile iterable for the specified iterable using the specified count as the size to drop.
`static <T> LazyIterable<T>`	`empty()`
`static <T,V> LazyIterable<V>`	`flatCollect(Iterable<T> iterable, Function<? super T,? extends Iterable<V>> function)`	Creates a deferred flattening iterable for the specified iterable.
`static <T> LazyIterable<T>`	`reject(Iterable<T> iterable, Predicate<? super T> predicate)`	Creates a deferred negative filtering iterable for the specified iterable.
`static <T> LazyIterable<T>`	`select(Iterable<T> iterable, Predicate<? super T> predicate)`	Creates a deferred filtering iterable for the specified iterable.
`static <T> LazyIterable<T>`	`selectInstancesOf(Iterable<?> iterable, Class<T> clazz)`
`static <T> LazyIterable<T>`	`take(Iterable<T> iterable, int count)`	Creates a deferred take iterable for the specified iterable using the specified count as the limit.
`static <T> LazyIterable<T>`	`takeWhile(Iterable<T> iterable, Predicate<? super T> predicate)`	Creates a deferred takeWhile iterable for the specified iterable using the specified predicate.
`static <T> LazyIterable<T>`	`tap(Iterable<T> iterable, Procedure<? super T> procedure)`	Creates a deferred tap iterable for the specified iterable.
`static <A,B> LazyIterable<Pair<A,B>>`	`zip(Iterable<A> as, Iterable<B> bs)`
`static <T> LazyIterable<Pair<T,Integer>>`	`zipWithIndex(Iterable<T> iterable)`

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

Method Detail

adapt

public static <T> LazyIterable<T> adapt(Iterable<T> iterable)

Creates a deferred rich iterable for the specified iterable.

select

public static <T> LazyIterable<T> select(Iterable<T> iterable,
                                         Predicate<? super T> predicate)

Creates a deferred filtering iterable for the specified iterable.

reject

public static <T> LazyIterable<T> reject(Iterable<T> iterable,
                                         Predicate<? super T> predicate)

Creates a deferred negative filtering iterable for the specified iterable.

selectInstancesOf

public static <T> LazyIterable<T> selectInstancesOf(Iterable<?> iterable,
                                                    Class<T> clazz)

collect

public static <T,V> LazyIterable<V> collect(Iterable<T> iterable,
                                            Function<? super T,? extends V> function)

Creates a deferred transforming iterable for the specified iterable.

flatCollect

public static <T,V> LazyIterable<V> flatCollect(Iterable<T> iterable,
                                                Function<? super T,? extends Iterable<V>> function)

Creates a deferred flattening iterable for the specified iterable.

collectIf

public static <T,V> LazyIterable<V> collectIf(Iterable<T> iterable,
                                              Predicate<? super T> predicate,
                                              Function<? super T,? extends V> function)

Creates a deferred filtering and transforming iterable for the specified iterable.

take

public static <T> LazyIterable<T> take(Iterable<T> iterable,
                                       int count)

Creates a deferred take iterable for the specified iterable using the specified count as the limit.

drop

public static <T> LazyIterable<T> drop(Iterable<T> iterable,
                                       int count)

Creates a deferred drop iterable for the specified iterable using the specified count as the size to drop.

takeWhile

public static <T> LazyIterable<T> takeWhile(Iterable<T> iterable,
                                            Predicate<? super T> predicate)

Creates a deferred takeWhile iterable for the specified iterable using the specified predicate. Short circuits at the first element which does not satisfy the Predicate.

Since:: 8.0

dropWhile
```
public static <T> LazyIterable<T> dropWhile(Iterable<T> iterable,
                                            Predicate<? super T> predicate)
```
Creates a deferred dropWhile iterable for the specified iterable using the specified count as the size to drop. Short circuits at the first element which satisfies the Predicate.

Since:

8.0

distinct
```
public static <T> LazyIterable<T> distinct(Iterable<T> iterable)
```
Creates a deferred distinct iterable for the specified iterable.

Since:

5.0

concatenate

public static <T> LazyIterable<T> concatenate(Iterable<T>... iterables)

Combines iterables into a deferred composite iterable.

empty

public static <T> LazyIterable<T> empty()

zip

public static <A,B> LazyIterable<Pair<A,B>> zip(Iterable<A> as,
                                                Iterable<B> bs)

zipWithIndex

public static <T> LazyIterable<Pair<T,Integer>> zipWithIndex(Iterable<T> iterable)

chunk

public static <T> LazyIterable<RichIterable<T>> chunk(Iterable<T> iterable,
                                                      int size)

tap

public static <T> LazyIterable<T> tap(Iterable<T> iterable,
                                      Procedure<? super T> procedure)

Creates a deferred tap iterable for the specified iterable.

Since:: 6.0

Class LazyIterate