Package org.eclipse.collections.impl.utility

Class LazyIterate

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 Details

    • 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

    • cartesianProduct

      public static <A,​ B> LazyIterable<Pair<A,​B>> cartesianProduct​(Iterable<A> iterable1, Iterable<B> iterable2)
      Create a deferred cartesian product of the two specified iterables. See cartesianProduct(Iterable, Iterable, Function2) about performance and presence of duplicates.
      Since:
      10.0

    • cartesianProduct

      public static <A,​ B,​ C> LazyIterable<C> cartesianProduct​(Iterable<A> iterable1, Iterable<B> iterable2, Function2<? super A,​? super B,​? extends C> function)
      Create a deferred cartesian product of the two specified iterables. This operation has O(n^2) performance. The presence of duplicates in the resulting iterable is both dependent on the presence of duplicates in the two specified iterables, and on the behaviour of the terminating operation that is applied to the resulting lazy iterable.
      Since:
      10.0