com.aol.cyclops2.types.futurestream

Class LazyFutureStreamFunctions

java.lang.Object

com.aol.cyclops2.types.futurestream.LazyFutureStreamFunctions

public class LazyFutureStreamFunctions
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
LazyFutureStreamFunctions()

Method Summary

Modifier and Type	Method and Description
static <T> org.jooq.lambda.Seq<T>	limitUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate) Returns a stream ed to all elements for which a predicate evaluates to true.
static <T> org.jooq.lambda.Seq<T>	limitWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate) Returns a stream limited to all elements for which a predicate evaluates to true.
static <T1,T2> org.jooq.lambda.Seq<org.jooq.lambda.tuple.Tuple2<T1,T2>>	zip(java.util.stream.Stream<T1> left, java.util.stream.Stream<? extends T2> right) Zip two streams into one.
static <T1,T2,R> org.jooq.lambda.Seq<R>	zip(java.util.stream.Stream<T1> left, java.util.stream.Stream<T2> right, java.util.function.BiFunction<? super T1,? super T2,? extends R> zipper) Zip two streams into one using a BiFunction to produce resulting values.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LazyFutureStreamFunctions

public LazyFutureStreamFunctions()

Method Detail

zip

public static <T1,T2> org.jooq.lambda.Seq<org.jooq.lambda.tuple.Tuple2<T1,T2>> zip(java.util.stream.Stream<T1> left,
                                                                                   java.util.stream.Stream<? extends T2> right)

Zip two streams into one.

// (tuple(1, "a"), tuple(2, "b"), tuple(3, "c")) Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"))

zip

public static <T1,T2,R> org.jooq.lambda.Seq<R> zip(java.util.stream.Stream<T1> left,
                                                   java.util.stream.Stream<T2> right,
                                                   java.util.function.BiFunction<? super T1,? super T2,? extends R> zipper)

Zip two streams into one using a BiFunction to produce resulting values.

// ("1:a", "2:b", "3:c") Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (i, s) -> i + ":" + s)

limitWhile

public static <T> org.jooq.lambda.Seq<T> limitWhile(java.util.stream.Stream<T> stream,
                                                    java.util.function.Predicate<? super T> predicate)

Returns a stream limited to all elements for which a predicate evaluates to true.

// (1, 2) Seq.of(1, 2, 3, 4, 5).limitWhile(i -> i < 3)

limitUntil

public static <T> org.jooq.lambda.Seq<T> limitUntil(java.util.stream.Stream<T> stream,
                                                    java.util.function.Predicate<? super T> predicate)

Returns a stream ed to all elements for which a predicate evaluates to true.

// (1, 2) Seq.of(1, 2, 3, 4, 5).limitUntil(i -> i == 3)