Class LazyIterate


  • public final class LazyIterate
    extends java.lang.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
    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      private LazyIterate()  
    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      static <T> LazyIterable<T> adapt​(java.lang.Iterable<T> iterable)
      Creates a deferred rich iterable for the specified iterable.
      static <A,​B>
      LazyIterable<Pair<A,​B>>
      cartesianProduct​(java.lang.Iterable<A> iterable1, java.lang.Iterable<B> iterable2)
      Create a deferred cartesian product of the two specified iterables.
      static <A,​B,​C>
      LazyIterable<C>
      cartesianProduct​(java.lang.Iterable<A> iterable1, java.lang.Iterable<B> iterable2, Function2<? super A,​? super B,​? extends C> function)
      Create a deferred cartesian product of the two specified iterables.
      static <T> LazyIterable<RichIterable<T>> chunk​(java.lang.Iterable<T> iterable, int size)  
      static <T,​V>
      LazyIterable<V>
      collect​(java.lang.Iterable<T> iterable, Function<? super T,​? extends V> function)
      Creates a deferred transforming iterable for the specified iterable.
      static <T,​V>
      LazyIterable<V>
      collectIf​(java.lang.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​(java.lang.Iterable<T>... iterables)
      Combines iterables into a deferred composite iterable.
      static <T> LazyIterable<T> distinct​(java.lang.Iterable<T> iterable)
      Creates a deferred distinct iterable for the specified iterable.
      static <T> LazyIterable<T> drop​(java.lang.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​(java.lang.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​(java.lang.Iterable<T> iterable, Function<? super T,​? extends java.lang.Iterable<V>> function)
      Creates a deferred flattening iterable for the specified iterable.
      static <T> LazyIterable<T> reject​(java.lang.Iterable<T> iterable, Predicate<? super T> predicate)
      Creates a deferred negative filtering iterable for the specified iterable.
      static <T> LazyIterable<T> select​(java.lang.Iterable<T> iterable, Predicate<? super T> predicate)
      Creates a deferred filtering iterable for the specified iterable.
      static <T> LazyIterable<T> selectInstancesOf​(java.lang.Iterable<?> iterable, java.lang.Class<T> clazz)  
      static <T> LazyIterable<T> take​(java.lang.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​(java.lang.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​(java.lang.Iterable<T> iterable, Procedure<? super T> procedure)
      Creates a deferred tap iterable for the specified iterable.
      static <A,​B>
      LazyIterable<Pair<A,​B>>
      zip​(java.lang.Iterable<A> as, java.lang.Iterable<B> bs)  
      static <T> LazyIterable<Pair<T,​java.lang.Integer>> zipWithIndex​(java.lang.Iterable<T> iterable)  
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • EMPTY_ITERABLE

        private static final LazyIterable<?> EMPTY_ITERABLE
    • Constructor Detail

      • LazyIterate

        private LazyIterate()
    • Method Detail

      • adapt

        public static <T> LazyIterable<T> adapt​(java.lang.Iterable<T> iterable)
        Creates a deferred rich iterable for the specified iterable.
      • select

        public static <T> LazyIterable<T> select​(java.lang.Iterable<T> iterable,
                                                 Predicate<? super T> predicate)
        Creates a deferred filtering iterable for the specified iterable.
      • reject

        public static <T> LazyIterable<T> reject​(java.lang.Iterable<T> iterable,
                                                 Predicate<? super T> predicate)
        Creates a deferred negative filtering iterable for the specified iterable.
      • selectInstancesOf

        public static <T> LazyIterable<T> selectInstancesOf​(java.lang.Iterable<?> iterable,
                                                            java.lang.Class<T> clazz)
      • collect

        public static <T,​V> LazyIterable<V> collect​(java.lang.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​(java.lang.Iterable<T> iterable,
                                                              Function<? super T,​? extends java.lang.Iterable<V>> function)
        Creates a deferred flattening iterable for the specified iterable.
      • collectIf

        public static <T,​V> LazyIterable<V> collectIf​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.Iterable<T> iterable)
        Creates a deferred distinct iterable for the specified iterable.
        Since:
        5.0
      • concatenate

        public static <T> LazyIterable<T> concatenate​(java.lang.Iterable<T>... iterables)
        Combines iterables into a deferred composite iterable.
      • zip

        public static <A,​B> LazyIterable<Pair<A,​B>> zip​(java.lang.Iterable<A> as,
                                                                    java.lang.Iterable<B> bs)
      • zipWithIndex

        public static <T> LazyIterable<Pair<T,​java.lang.Integer>> zipWithIndex​(java.lang.Iterable<T> iterable)
      • tap

        public static <T> LazyIterable<T> tap​(java.lang.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​(java.lang.Iterable<A> iterable1,
                                                                                 java.lang.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​(java.lang.Iterable<A> iterable1,
                                                                           java.lang.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