com.aol.cyclops.util.stream

Interface Streamable<T>

Type Parameters:

T - Data type for Stream

All Superinterfaces:

org.jooq.lambda.Collectable<T>, ConvertableSequence<T>, ConvertableToReactiveSeq<T>, CyclopsCollectable<T>, Filterable<T>, Foldable<T>, Functor<T>, java.lang.Iterable<T>, IterableFunctor<T>, org.reactivestreams.Publisher<T>, ToStream<T>, Traversable<T>, Unit<T>, ZippingApplicativable<T>

All Known Implementing Classes:

ReversedIterator, StreamableImpl

public interface Streamable<T>
extends ToStream<T>, CyclopsCollectable<T>, ConvertableSequence<T>, Functor<T>, Filterable<T>, Traversable<T>, Unit<T>, ZippingApplicativable<T>

Represents something that can generate a Stream, repeatedly

Method Summary

Modifier and Type	Method and Description
default boolean	allMatch(java.util.function.Predicate<? super T> c) True if predicate matches all elements when Monad converted to a Stream
default AnyM<T>	anyM()
default boolean	anyMatch(java.util.function.Predicate<? super T> c) True if a single element matches when Monad converted to a Stream
default Streamable<T>	append(T... values) Append values to the end of this Streamable
default Streamable<T>	appendAll(Streamable<T> t) Create a new Streamablw with all elements in this Streamable followed by the elements in the provided Streamable
default Streamable<T>	appendStreamable(Streamable<T> stream) Append Stream to this Streamable
default <U> Streamable<U>	cast(java.lang.Class<U> type) Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
default <R,A> R	collect(java.util.stream.Collector<? super T,A,R> collector)
default <R> R	collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super T> accumulator, java.util.function.BiConsumer<R,R> combiner)
default org.jooq.lambda.Collectable<T>	collectable() Narrow this class to a Collectable
default Streamable<Streamable<T>>	combinations() Streamable.of(1,2,3).combinations() //Streamable[Streamable[],Streamable[1],Streamable[2],Streamable[3],Streamable[1,2],Streamable[1,3],Streamable[2,3] ,Streamable[1,2,3]]
default Streamable<Streamable<T>>	combinations(int size) Streamable.of(1,2,3).combinations(2) //Streamable[Streamable[1,2],Streamable[1,3],Streamable[2,3]]
default Streamable<T>	concat(Streamable<T> other)
default Streamable<T>	concat(T... other)
default Streamable<T>	concat(T other)
default boolean	contains(T t) True if a streamable contains element t
default long	count()
default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>>	crossJoin(Streamable<U> other)
default Streamable<T>	cycle() Convert to a Stream with the values infinitely cycled
default Streamable<T>	cycle(int times) Convert to a Stream with the values repeated specified times
default Streamable<T>	cycle(Monoid<T> m, int times) Convert to a Stream with the result of a reduction operation repeated specified times
default Streamable<T>	cycleUntil(java.util.function.Predicate<? super T> predicate) Repeat in a Stream until specified predicate holds
default Streamable<T>	cycleWhile(java.util.function.Predicate<? super T> predicate) Repeat in a Stream while specified predicate holds
default Streamable<T>	debounce(long time, java.util.concurrent.TimeUnit t) Allow one element through per time period, drop all other elements in that time period
default Streamable<T>	deleteBetween(int start, int end) Delete elements between given indexes in a Stream
default Streamable<T>	distinct()
default <U> Streamable<T>	distinct(java.util.function.Function<? super T,? extends U> keyExtractor)
default org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<T>>	duplicate() Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
default Streamable<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>	elapsed() Streamable.of(1,2,3,4,5) .elapsed() .forEach(System.out::println);
default T	elementAt(int index) Gets the element at index (it must be present)
default org.jooq.lambda.tuple.Tuple2<T,Streamable<T>>	elementAt(long index) Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.
static <T> Streamable<T>	empty()
default boolean	endsWith(Streamable<T> stream) assertTrue(Streamable.of(1,2,3,4,5,6) .endsWith(Stream.of(5,6)));
default boolean	endsWithIterable(java.lang.Iterable<T> iterable) assertTrue(Streamable.of(1,2,3,4,5,6) .endsWith(Arrays.asList(5,6)));
default Streamable<T>	filter(java.util.function.Predicate<? super T> fn)
default java.util.Optional<T>	findAny()
default java.util.Optional<T>	findFirst()
default T	firstValue() assertThat(Streamable.of(1,2,3,4) .map(u->{throw new RuntimeException();}) .recover(e->"hello") .firstValue(),equalTo("hello"));
default Streamable<T>	fixedDelay(long l, java.util.concurrent.TimeUnit unit) emit elements after a fixed delay
default <R> Streamable<R>	flatMap(java.util.function.Function<? super T,Streamable<? extends R>> fn)
default <R> Streamable<R>	flatMapAnyM(java.util.function.Function<? super T,AnyM<? extends R>> fn) Allows flatMap return type to be any Monad type
default <R> Streamable<R>	flatMapIterable(java.util.function.Function<? super T,java.lang.Iterable<? extends R>> fn) FlatMap where the result is a Collection, flattens the resultant collections into the host Streamable
default <R> Streamable<R>	flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn) flatMap operation
default <T1> Streamable<T1>	flatten() join / flatten one level of a nested hierarchy
default <U> U	foldLeft(U identity, java.util.function.BiFunction<U,? super T,U> function) Fold a Streamable Left
default T	foldRight(Monoid<T> reducer) Streamable.of("a","b","c").foldRight(Reducers.toString("")); // "cab"
default T	foldRight(T identity, java.util.function.BinaryOperator<T> accumulator) Immutable reduction from right to left
default <U> U	foldRight(U seed, java.util.function.BiFunction<? super T,U,U> function) Fold a Streamable fromt the right
default <T> T	foldRightMapToType(Reducer<T> reducer) Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
default void	forEachOrdered(java.util.function.Consumer<? super T> action)
static Streamable<java.lang.Double>	fromDoubleStream(java.util.stream.DoubleStream stream) Construct a Sequence from a Stream
static Streamable<java.lang.Integer>	fromIntStream(java.util.stream.IntStream stream) Construct a Sequence from a Stream
static <T> Streamable<T>	fromIterable(java.lang.Iterable<T> iterable) (Lazily) Construct a Streamable from an Iterable.
static <T> Streamable<T>	fromIterator(java.util.Iterator<T> it)
static <T> Streamable<T>	fromList(java.util.List<T> list)
static Streamable<java.lang.Long>	fromLongStream(java.util.stream.LongStream stream) Construct a Sequence from a Stream
static <T> Streamable<T>	fromPublisher(org.reactivestreams.Publisher<? extends T> publisher) Construct a LazyFutureStream from an Publisher
static <T> Streamable<T>	fromStream(java.util.stream.Stream<T> stream) (Lazily) Construct a Streamable from a Stream.
default FutureOperations<T>	futureOperations(java.util.concurrent.Executor exec) Access asynchronous terminal operations (each returns a Future)
static <T> Streamable<T>	generate(java.util.function.Supplier<T> s)
default java.util.Optional<T>	get(long index) Return the elementAt index or Optional.empty
default <K> MapX<K,java.util.List<T>>	groupBy(java.util.function.Function<? super T,? extends K> classifier) Use classifier function to group elements in this Sequence into a Map
default Streamable<ListX<T>>	grouped(int groupSize) Group elements in a Stream
default <C extends java.util.Collection<? super T>> Streamable<C>	grouped(int size, java.util.function.Supplier<C> supplier) Batch elements in a Stream by size into a collection created by the supplied factory
default Streamable<ListX<T>>	groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t) Batch elements by size into a List
default <C extends java.util.Collection<? super T>> Streamable<C>	groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory) Batch elements by size into a collection created by the supplied factory
default Streamable<ListX<T>>	groupedByTime(long time, java.util.concurrent.TimeUnit t) Batch elements in a Stream by time period
default <C extends java.util.Collection<? super T>> Streamable<C>	groupedByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory) Batch elements by time into a collection created by the supplied factory
default Streamable<ListX<T>>	groupedUntil(java.util.function.Predicate<? super T> predicate) Create a Streamable batched by List, where each batch is populated until the predicate holds
default <C extends java.util.Collection<? super T>> Streamable<C>	groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory) Create a Streamable batched by a Collection, where each batch is populated until the predicate holds
default Streamable<ListX<T>>	groupedWhile(java.util.function.Predicate<? super T> predicate) Create a Streamable batched by List, where each batch is populated while the predicate holds
default <C extends java.util.Collection<? super T>> Streamable<C>	groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory) Create a Streamable batched by a Collection, where each batch is populated while the predicate holds
default T	head() Streamable.of(1,2,3,4,5).head() //1
default HotStream<T>	hotStream(java.util.concurrent.Executor e) Turns this Streamable into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data
default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>>	innerJoin(Streamable<U> other, java.util.function.BiPredicate<T,U> predicate)
default Streamable<T>	insertAt(int pos, T... values) Insert data into a stream at given position
default Streamable<T>	insertStreamableAt(int pos, Streamable<T> stream) Insert a Stream into the middle of this stream at the specified position
default Streamable<T>	intersperse(T value) Returns a stream with a given value interspersed between any two values of this stream.
static <T> Streamable<T>	iterate(T seed, java.util.function.UnaryOperator<T> f)
default java.util.Iterator<T>	iterator()
default Streamable<T>	jitter(long maxJitterPeriodInNanos) Introduce a random jitter / time delay between the emission of elements
default java.lang.String	join() assertEquals("123".length(),Streamable.of(1, 2, 3).join().length());
default java.lang.String	join(java.lang.String sep) assertEquals("1, 2, 3".length(), Streamable.of(1, 2, 3).join(", ").length());
default java.lang.String	join(java.lang.String sep, java.lang.String start, java.lang.String end) assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>>	leftOuterJoin(Streamable<U> other, java.util.function.BiPredicate<T,U> predicate)
default Streamable<T>	limit(long num) assertThat(Streamable.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
default Streamable<T>	limit(long time, java.util.concurrent.TimeUnit unit) Return all elements until specified time period has elapsed
default Streamable<T>	limitLast(int num) Limit results to the last x elements in a Streamable
default Streamable<T>	limitUntil(java.util.function.Predicate<? super T> p) assertThat(Streamable.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));
default Streamable<T>	limitWhile(java.util.function.Predicate<? super T> p) assertThat(Streamable.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
default <R> Streamable<R>	map(java.util.function.Function<? super T,? extends R> fn) Map the values in the Streamable from one set of values / types to another
default <R> R	mapReduce(java.util.function.Function<? super T,? extends R> mapper, Monoid<R> reducer) Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
default <R> R	mapReduce(Reducer<R> reducer) Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values
default java.util.Optional<T>	max(java.util.Comparator<? super T> comparator)
default <C extends java.lang.Comparable<? super C>> java.util.Optional<T>	maxBy(java.util.function.Function<? super T,? extends C> f) Extract the maximum as determined by the supplied function
default java.util.Optional<T>	min(java.util.Comparator<? super T> comparator)
default <C extends java.lang.Comparable<? super C>> java.util.Optional<T>	minBy(java.util.function.Function<? super T,? extends C> f) Extract the minimum as determined by supplied function
default boolean	noneMatch(java.util.function.Predicate<? super T> c)
static <T> Streamable<T>	of(T... values) Construct a Streamable that returns a Stream
default <U> Streamable<U>	ofType(java.lang.Class<U> type) Keep only those elements in a stream that are of a given type.
default Streamable<T>	onEmpty(T value)
default Streamable<T>	onEmptyGet(java.util.function.Supplier<T> supplier)
default Streamable<T>	onEmptySwitch(java.util.function.Supplier<Streamable<T>> switchTo) If this Streamable is empty replace it with a another Stream
default <X extends java.lang.Throwable> Streamable<T>	onEmptyThrow(java.util.function.Supplier<X> supplier)
default Streamable<T>	onePer(long time, java.util.concurrent.TimeUnit t) emit one element per time period
default boolean	parallelContains(T t) True if a streamable contains element t use paralleled stream underneath
default org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<T>>	partition(java.util.function.Predicate<T> splitter) Partition a Stream into two one a per element basis, based on predicate's boolean value
default Streamable<T>	peek(java.util.function.Consumer<? super T> fn) Peek at each value in a Streamable as it passes through unchanged
default Streamable<Streamable<T>>	permutations() Generate the permutations based on values in the Streamable
default Streamable<T>	prepend(T... values) Prepend given values to the start of the Stream
default Streamable<T>	prepend(T t) Prepend given values to the start of the Stream
default Streamable<T>	prependStreamable(Streamable<T> stream) Prepend Stream to this Streamable
default org.jooq.lambda.tuple.Tuple4<Streamable<T>,Streamable<T>,Streamable<T>,Streamable<T>>	quadruplicate()
static Streamable<java.lang.Integer>	range(int start, int end) Create an efficiently reversable Sequence that produces the integers between start and end
static Streamable<java.lang.Long>	rangeLong(long start, long end) Create an efficiently reversable Sequence that produces the integers between start and end
default <EX extends java.lang.Throwable> Streamable<T>	recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<EX,T> fn) Recover from a particular exception type
default Streamable<T>	recover(java.util.function.Function<java.lang.Throwable,? extends T> fn) Recover from an exception with an alternative value
default java.util.Optional<T>	reduce(java.util.function.BinaryOperator<T> accumulator)
default ListX<T>	reduce(java.lang.Iterable<? extends Monoid<T>> reducers) Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
default T	reduce(Monoid<T> reducer) Streamable.of("hello","2","world","4").reduce(Reducers.toString(",")); //hello,2,world,4
default ListX<T>	reduce(java.util.stream.Stream<? extends Monoid<T>> reducers) Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first.
default T	reduce(T identity, java.util.function.BinaryOperator<T> accumulator)
default <U> U	reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)
default Streamable<T>	remove(T t) Remove all occurances of the specified element from the SequenceM
default <R> Streamable<R>	retry(java.util.function.Function<T,R> fn) Retry a transformation if it fails.
default Streamable<T>	reverse()
static <T> Streamable<T>	reversedListOf(java.util.List<T> elements) Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
static <T> Streamable<T>	reversedOf(T... elements) Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently
default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>>	rightOuterJoin(Streamable<U> other, java.util.function.BiPredicate<T,U> predicate)
default Streamable<T>	scanLeft(Monoid<T> monoid) Scan left using supplied Monoid
default <U> Streamable<U>	scanLeft(U identity, java.util.function.BiFunction<U,? super T,U> function) Scan left
default Streamable<T>	scanRight(Monoid<T> monoid) Scan right
default <U> Streamable<U>	scanRight(U identity, java.util.function.BiFunction<? super T,U,U> combiner) Scan right
default Streamable<T>	shuffle()
default Streamable<T>	shuffle(java.util.Random random)
default T	single() assertThat(Streamable.of(1).single(),equalTo(1));
default int	size() [equivalent to count]
default Streamable<T>	skip(long num) assertThat(Streamable.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
default Streamable<T>	skip(long time, java.util.concurrent.TimeUnit unit) Skip all elements until specified time period has passed
default Streamable<T>	skipLast(int num) assertThat(Streamable.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
default Streamable<T>	skipUntil(java.util.function.Predicate<? super T> p) assertThat(Streamable.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
default Streamable<T>	skipWhile(java.util.function.Predicate<? super T> p) assertThat(Streamable.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
default Streamable<T>	slice(long from, long to)
default Streamable<ListX<T>>	sliding(int windowSize) Create a sliding view over this Sequence
default Streamable<ListX<T>>	sliding(int windowSize, int increment) Create a sliding view over this Sequence
default Streamable<T>	sorted() assertThat(Streamable.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
default Streamable<T>	sorted(java.util.Comparator<? super T> c) assertThat(Streamable.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
default <U extends java.lang.Comparable<? super U>> Streamable<T>	sorted(java.util.function.Function<? super T,? extends U> function)
default org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<T>>	splitAt(int where) Split at supplied location
default org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,Streamable<T>>	splitAtHead() Split this Streamable after the first element (if present)
default org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<T>>	splitBy(java.util.function.Predicate<T> splitter) Split stream at point where predicate no longer holds
default boolean	startsWith(java.util.Iterator<T> iterator) assertTrue(Streamable.of(1,2,3,4).startsWith(Arrays.asList(1,2,3).iterator()))
default boolean	startsWithIterable(java.lang.Iterable<T> iterable) assertTrue(Streamable.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
default ReactiveSeq<T>	stream()
default Streamable<T>	subStream(int start, int end) Return a Streamable with elements before the provided start index removed, and elements after the provided end index removed
default Streamable<T>	tail() Streamable.of(1,2,3,4,5).tail() //Streamable[2,3,4,5]
default Streamable<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>	timestamp() Streamable.of(1,2,3,4,5) .timestamp() .forEach(System.out::println)
default java.lang.Object[]	toArray()
default <A> A[]	toArray(java.util.function.IntFunction<A[]> generator)
default <C extends java.util.Collection<T>> C	toCollection(java.util.function.Supplier<C> collectionFactory) Add the contents of this Stream to the mutable collection supplied by the provided collectionFactory
default java.util.concurrent.CompletableFuture<ListX<T>>	toCompletableFuture() CompletableFuture<List<String>> cf = Streamable.of("hello","world") .toCompletableFuture(); assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));
default CollectionX<T>	toConcurrentLazyCollection() Lazily converts this Streamable into a Collection.
default CollectionX<T>	toLazyCollection() Lazily converts this Streamable into a Collection.
default java.util.List<T>	toList() Streamable.of(1,2,3) .toList(); //List[1,2,3]
default java.util.Optional<ListX<T>>	toOptional() Type safe unwrap
default org.jooq.lambda.tuple.Tuple3<Streamable<T>,Streamable<T>,Streamable<T>>	triplicate()
default <T> Streamable<T>	unit(T t)
default <T> Streamable<T>	unitIterator(java.util.Iterator<T> it)
static <T,U> org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<U>>	unzip(Streamable<org.jooq.lambda.tuple.Tuple2<T,U>> sequence) Unzip a zipped Stream
static <T1,T2,T3> org.jooq.lambda.tuple.Tuple3<Streamable<T1>,Streamable<T2>,Streamable<T3>>	unzip3(Streamable<org.jooq.lambda.tuple.Tuple3<T1,T2,T3>> sequence) Unzip a zipped Stream into 3
static <T1,T2,T3,T4> org.jooq.lambda.tuple.Tuple4<Streamable<T1>,Streamable<T2>,Streamable<T3>,Streamable<T4>>	unzip4(Streamable<org.jooq.lambda.tuple.Tuple4<T1,T2,T3,T4>> sequence) Unzip a zipped Stream into 4
default boolean	xMatch(int num, java.util.function.Predicate<? super T> c) Check that there are specified number of matches of predicate in the Stream
default Streamable<T>	xPer(int x, long time, java.util.concurrent.TimeUnit t) emit x elements per time period
default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>>	zip(Streamable<U> other) Zip 2 streams into one
default <U,R> Streamable<R>	zip(Streamable<U> other, java.util.function.BiFunction<T,U,R> zipper)
default <S,U> Streamable<org.jooq.lambda.tuple.Tuple3<T,S,U>>	zip3(Streamable<? extends S> second, Streamable<? extends U> third) zip 3 Streams into one
default <T2,T3,T4> Streamable<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>	zip4(Streamable<T2> second, Streamable<T3> third, Streamable<T4> fourth) zip 4 Streams into 1
default <S,R> Streamable<R>	zipAnyM(AnyMSeq<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper) Zip this Streamable against any monad type.
default <S,R> Streamable<R>	zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper) Zip this Monad with a Stream
default <S,R> Streamable<R>	zipStreamable(Streamable<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper) Generic zip function.
default Streamable<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>	zipWithIndex() Add an index to the current Stream

Methods inherited from interface com.aol.cyclops.types.stream.ToStream

getStreamable, isEmpty, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream

Methods inherited from interface com.aol.cyclops.types.stream.CyclopsCollectable

avg, avg, avgDouble, avgInt, avgLong, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, maxBy, median, median, medianBy, medianBy, min, min, min, minBy, mode, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toList, toMap, toSet, toSet, toString, toString

Methods inherited from interface org.jooq.lambda.Collectable

collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect, collect

Methods inherited from interface com.aol.cyclops.types.Filterable

filterNot, notNull

Methods inherited from interface com.aol.cyclops.types.applicative.zipping.ZippingApplicativable

ap1, ap2, ap3, ap4, ap5, applicatives

Methods inherited from interface com.aol.cyclops.types.IterableFunctor

flatMapPublisher, flatMapPublisher, flatMapPublisher, mergePublisher, mergePublisher

Methods inherited from interface com.aol.cyclops.types.Functor

patternMatch, trampoline

Methods inherited from interface com.aol.cyclops.types.Traversable

combine, dropRight, dropUntil, dropWhile, endsWith, grouped, grouped, groupedStatefullyWhile, headAndTail, lazyOperations, schedule, scheduleFixedDelay, scheduleFixedRate, single, singleOptional, takeRight, takeUntil, takeWhile, toConcurrentLazyStreamable, validate, visit, visit, zip, zip, zip3, zip4, zipStream

Methods inherited from interface com.aol.cyclops.types.Foldable

print, print, printErr, printOut, reduce

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence

seq, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Method Detail

collectable

default org.jooq.lambda.Collectable<T> collectable()

Description copied from interface: CyclopsCollectable

Narrow this class to a Collectable

Specified by:

collectable in interface CyclopsCollectable<T>

Specified by:

collectable in interface IterableFunctor<T>

Returns:

Collectable

fromPublisher

static <T> Streamable<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)

Construct a LazyFutureStream from an Publisher

Parameters:

publisher - to construct ReactiveSeq from

Returns:

LazyFutureStream

fromStream

static <T> Streamable<T> fromStream(java.util.stream.Stream<T> stream)

(Lazily) Construct a Streamable from a Stream.

Parameters:

stream - to construct Streamable from

Returns:

Streamable

fromIterable

static <T> Streamable<T> fromIterable(java.lang.Iterable<T> iterable)

(Lazily) Construct a Streamable from an Iterable.

Parameters:

iterable - to construct Streamable from

Returns:

Streamable

fromIterator

static <T> Streamable<T> fromIterator(java.util.Iterator<T> it)

unit

default <T> Streamable<T> unit(T t)

Specified by:

unit in interface Unit<T>

unitIterator

default <T> Streamable<T> unitIterator(java.util.Iterator<T> it)

Specified by:

unitIterator in interface IterableFunctor<T>

of

static <T> Streamable<T> of(T... values)

Construct a Streamable that returns a Stream

Parameters:

values - to construct Streamable from

Returns:

Streamable

empty

static <T> Streamable<T> empty()

tail

default Streamable<T> tail()

  
   Streamable.of(1,2,3,4,5).tail()
   
   //Streamable[2,3,4,5]
 

Returns:

The tail of this Streamable

head

default T head()

  
 Streamable.of(1,2,3,4,5).head()
  
  //1
 

Returns:

The head of this Streamable

appendAll

default Streamable<T> appendAll(Streamable<T> t)

Create a new Streamablw with all elements in this Streamable followed by the elements in the provided Streamable

  
 	Streamable.of(1,2,3).appendAll(Streamable.of(4,5,6))
 
   //Streamable[1,2,3,4,5,6]
 
 

Parameters:

t - Streamable to append

Returns:

New Streamable with provided Streamable appended

remove

default Streamable<T> remove(T t)

Remove all occurances of the specified element from the SequenceM

 
 	Streamable.of(1,2,3,4,5,1,2,3).remove(1)
 
  //Streamable[2,3,4,5,2,3]
 
 

Parameters:

t - element to remove

Returns:

Filtered Stream / SequenceM

prepend

default Streamable<T> prepend(T t)

Prepend given values to the start of the Stream

  
 List<String> result = 	Streamable.of(1,2,3)
 									 .prepend(100,200,300)
										 .map(it ->it+"!!")
										 .collect(Collectors.toList());

			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 

Parameters:

values - to prepend

Returns:

Streamable with values prepended

distinct

default Streamable<T> distinct()

Specified by:

distinct in interface Traversable<T>

foldLeft

default <U> U foldLeft(U identity,
                       java.util.function.BiFunction<U,? super T,U> function)

Fold a Streamable Left

  
   Streamable.of("hello","world")
   			.foldLeft("",(a,b)->a+":"+b);
   
   //"hello:world"
 
 

Parameters:

identity - - identity value

function - folding function

Returns:

Value from reduction

foldRight

default <U> U foldRight(U seed,
                        java.util.function.BiFunction<? super T,U,U> function)

Fold a Streamable fromt the right

  
   Streamable.of("hello","world")
   			.foldRight("",(a,b)->a+":"+b);
   
   //"world:hello"
 

Specified by:

foldRight in interface Foldable<T>

Parameters:

seed - - identity value

function - folding function

Returns:

Single reduced value

map

default <R> Streamable<R> map(java.util.function.Function<? super T,? extends R> fn)

Map the values in the Streamable from one set of values / types to another

  
 	Streamable.of(1,2,3).map(i->i+2);
  //Streamable[3,4,5]
  
  Streamable.of(1,2,3).map(i->"hello"+(i+2));
  
   //Streamable["hello3","hello4","hello5"]
 
 

Specified by:

map in interface Functor<T>

Specified by:

map in interface IterableFunctor<T>

Parameters:

fn - mapper function

Returns:

Mapped Streamable

peek

default Streamable<T> peek(java.util.function.Consumer<? super T> fn)

Peek at each value in a Streamable as it passes through unchanged

 
    Streamable.of(1,2,3)
              .peek(System.out::println)
              .map(i->i+2);
 
 

Specified by:

peek in interface Functor<T>

Parameters:

fn - Consumer to peek with

Returns:

Streamable that will peek at values as they pass through

filter

default Streamable<T> filter(java.util.function.Predicate<? super T> fn)

Specified by:

filter in interface Filterable<T>

flatMap

default <R> Streamable<R> flatMap(java.util.function.Function<? super T,Streamable<? extends R>> fn)

count

default long count()

Specified by:

count in interface org.jooq.lambda.Collectable<T>

Specified by:

count in interface CyclopsCollectable<T>

Returns:

number of elements in this Streamable

forEachOrdered

default void forEachOrdered(java.util.function.Consumer<? super T> action)

toArray

default java.lang.Object[] toArray()

toArray

default <A> A[] toArray(java.util.function.IntFunction<A[]> generator)

toList

default java.util.List<T> toList()

  
   Streamable.of(1,2,3)
             .toList(); 
 
  //List[1,2,3]
 
 

Specified by:

toList in interface org.jooq.lambda.Collectable<T>

Specified by:

toList in interface CyclopsCollectable<T>

Returns:

Streamable converted to a List

collect

default <R> R collect(java.util.function.Supplier<R> supplier,
                      java.util.function.BiConsumer<R,? super T> accumulator,
                      java.util.function.BiConsumer<R,R> combiner)

collect

default <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)

Specified by:

collect in interface org.jooq.lambda.Collectable<T>

Specified by:

collect in interface CyclopsCollectable<T>

toCollection

default <C extends java.util.Collection<T>> C toCollection(java.util.function.Supplier<C> collectionFactory)

Add the contents of this Stream to the mutable collection supplied by the provided collectionFactory

  
   Streamable.of(1,2,3).toCollection( ()->new ArrayList());
   
   //ArrayList[1,2,3]
 
 

Specified by:

toCollection in interface org.jooq.lambda.Collectable<T>

Specified by:

toCollection in interface CyclopsCollectable<T>

Parameters:

collectionFactory -

Returns:

contents of this Stream in a mutable collection

permutations

default Streamable<Streamable<T>> permutations()

Generate the permutations based on values in the Streamable

subStream

default Streamable<T> subStream(int start,
                                int end)

Return a Streamable with elements before the provided start index removed, and elements after the provided end index removed

  
   Streamable.of(1,2,3,4,5,6).subStream(1,3);
   
   
   //Streamable[2,3]
 
 

Parameters:

start - index inclusive

end - index exclusive

Returns:

Sequence between supplied indexes of original Sequence

elementAt

default T elementAt(int index)

Gets the element at index (it must be present)

  
 Streamable.of(1,2,3,4,5).get(2)
 //3
 
 

Parameters:

index - to extract element from

Returns:

Element and Sequence

size

default int size()

[equivalent to count]

Returns:

size

combinations

default Streamable<Streamable<T>> combinations(int size)

 
   Streamable.of(1,2,3).combinations(2)
   
   //Streamable[Streamable[1,2],Streamable[1,3],Streamable[2,3]]
 
 

Parameters:

size - of combinations

Returns:

All combinations of the elements in this stream of the specified size

combinations

default Streamable<Streamable<T>> combinations()

 
   Streamable.of(1,2,3).combinations()
   
   //Streamable[Streamable[],Streamable[1],Streamable[2],Streamable[3],Streamable[1,2],Streamable[1,3],Streamable[2,3]
   			,Streamable[1,2,3]]
 
 

Returns:

All combinations of the elements in this stream

flatten

default <T1> Streamable<T1> flatten()

join / flatten one level of a nested hierarchy

  
  Streamable.of(Arrays.asList(1,2)).flatten();
  
  //stream of (1,  2);		
  
 
 
 

Returns:

Flattened / joined one level

toOptional

default java.util.Optional<ListX<T>> toOptional()

Type safe unwrap

  
 Optional<List<String>> stream = Streamable.of("hello","world")
    												.toOptional();
    												
    		assertThat(stream.get(),equalTo(Arrays.asList("hello","world")));
 
 
 

Specified by:

toOptional in interface ConvertableSequence<T>

Returns:

toCompletableFuture

default java.util.concurrent.CompletableFuture<ListX<T>> toCompletableFuture()

  
 CompletableFuture<List<String>> cf = Streamable.of("hello","world")
    											.toCompletableFuture();
    		assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));
 
 

Specified by:

toCompletableFuture in interface ConvertableSequence<T>

Returns:

cycle

default Streamable<T> cycle(int times)

Convert to a Stream with the values repeated specified times

  
 		assertThat(Streamable.of(1,2,2)
    								.cycle(3)
    								.collect(Collectors.toList()),
    								equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));

 
 
 

Specified by:

cycle in interface Traversable<T>

Parameters:

times - Times values should be repeated within a Stream

Returns:

Streamable with values repeated

cycle

default Streamable<T> cycle()

Convert to a Stream with the values infinitely cycled

  
   assertEquals(asList(1, 1, 1, 1, 1,1),Streamable.of(1).cycle().limit(6).toList());
   
 

Returns:

Stream with values repeated

duplicate

default org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<T>> duplicate()

Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

  
  Tuple2<Streamable<Integer>, Streamable<Integer>> copies =of(1,2,3,4,5,6).duplicate();
    		 assertTrue(copies.v1.anyMatch(i->i==2));
    		 assertTrue(copies.v2.anyMatch(i->i==2));
 
 
 

Returns:

duplicated stream

triplicate

default org.jooq.lambda.tuple.Tuple3<Streamable<T>,Streamable<T>,Streamable<T>> triplicate()

quadruplicate

default org.jooq.lambda.tuple.Tuple4<Streamable<T>,Streamable<T>,Streamable<T>,Streamable<T>> quadruplicate()

splitAt

default org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<T>> splitAt(int where)

Split at supplied location

  
 Streamable.of(1,2,3).splitAt(1)
 
  //Streamable[1], Streamable[2,3]
 
 
 

splitAtHead

default org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,Streamable<T>> splitAtHead()

Split this Streamable after the first element (if present)

  
  Streamable.of(1,2,3).splitAtHead()
  
  //Tuple[1,Streamable[2,3]]
  
 

Returns:

Split Streamable

splitBy

default org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<T>> splitBy(java.util.function.Predicate<T> splitter)

Split stream at point where predicate no longer holds

 
   Streamable.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
   
   //Streamable[1,2,3] Streamable[4,5,6]
 
 

partition

default org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<T>> partition(java.util.function.Predicate<T> splitter)

Partition a Stream into two one a per element basis, based on predicate's boolean value

  
  Streamable.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0) 
  
  //Streamable[1,3,5], Streamable[2,4,6]
 

 

cycle

default Streamable<T> cycle(Monoid<T> m,
                            int times)

Convert to a Stream with the result of a reduction operation repeated specified times

  
   		List<Integer> list = AsGenericMonad,asMonad(Stream.of(1,2,2))
 										.cycle(Reducers.toCountInt(),3)
 										.collect(Collectors.toList());
 	//is asList(3,3,3);
   
 

Specified by:

cycle in interface Traversable<T>

Parameters:

m - Monoid to be used in reduction

times - Number of times value should be repeated

Returns:

Stream with reduced values repeated

cycleWhile

default Streamable<T> cycleWhile(java.util.function.Predicate<? super T> predicate)

Repeat in a Stream while specified predicate holds

 
 count =0;
    		assertThat(Streamable.of(1,2,2)
    							.cycleWhile(next -> count++<6)
    							.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2)));
 
 

Specified by:

cycleWhile in interface Traversable<T>

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

cycleUntil

default Streamable<T> cycleUntil(java.util.function.Predicate<? super T> predicate)

Repeat in a Stream until specified predicate holds

  
 	count =0;
    		assertThat(Streamable.of(1,2,2)
    							.cycleUntil(next -> count++>6)
    							.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2,1)));

 
 

Specified by:

cycleUntil in interface Traversable<T>

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

zip

default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>> zip(Streamable<U> other)

Zip 2 streams into one

  
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
           // [[1,"a"],[2,"b"]]
    		  
 

zip

default <U,R> Streamable<R> zip(Streamable<U> other,
                                java.util.function.BiFunction<T,U,R> zipper)

zip3

default <S,U> Streamable<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(Streamable<? extends S> second,
                                                                   Streamable<? extends U> third)

zip 3 Streams into one

  
 List<Tuple3<Integer,Integer,Character>> list =
    				of(1,2,3,4,5,6).zip3(of(100,200,300,400),of('a','b','c'))
    											.collect(Collectors.toList());
 
 //[[1,100,'a'],[2,200,'b'],[3,300,'c']]
 
 

zip4

default <T2,T3,T4> Streamable<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(Streamable<T2> second,
                                                                             Streamable<T3> third,
                                                                             Streamable<T4> fourth)

zip 4 Streams into 1

  
 List<Tuple4<Integer,Integer,Character,String>> list =
    				of(1,2,3,4,5,6).zip4(of(100,200,300,400),of('a','b','c'),of("hello","world"))
    												.collect(Collectors.toList());
    			
 
  //[[1,100,'a',"hello"],[2,200,'b',"world"]]
 

zipWithIndex

default Streamable<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

Add an index to the current Stream

  
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());
 
 

Specified by:

zipWithIndex in interface Traversable<T>

zipStreamable

default <S,R> Streamable<R> zipStreamable(Streamable<? extends S> second,
                                          java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Generic zip function. E.g. Zipping a Stream and an Optional

 {
        @code
        Stream<List<Integer>> zipped = asMonad(Stream.of(1, 2, 3)).zip(
                        asMonad(Optional.of(2)), (a, b) -> Arrays.asList(a, b));
        // [[1,2]]
 }
 

Parameters:

second - Monad to zip with

zipper - Zipping function

Returns:

Stream zipping two Monads

zipAnyM

default <S,R> Streamable<R> zipAnyM(AnyMSeq<? extends S> second,
                                    java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Zip this Streamable against any monad type.

 
 Stream<List<Integer>> zipped = anyM(Stream.of(1,2,3))
    										.asSequence()
    										.zip(anyM(Optional.of(2)), 
    											(a,b) -> Arrays.asList(a,b)).toStream();
    		
    		
    		List<Integer> zip = zipped.collect(Collectors.toList()).get(0);
    		assertThat(zip.get(0),equalTo(1));
    		assertThat(zip.get(1),equalTo(2));
 
 

zipStream

default <S,R> Streamable<R> zipStream(java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second,
                                      java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Zip this Monad with a Stream

 {
        @code
        Stream<List<Integer>> zipped = asMonad(Stream.of(1, 2, 3)).zip(
                        Stream.of(2, 3, 4), (a, b) -> Arrays.asList(a, b));
 
        // [[1,2][2,3][3,4]]
 }
 

Parameters:

second - Stream to zip with

zipper - Zip funciton

Returns:

This monad zipped with a Stream

sliding

default Streamable<ListX<T>> sliding(int windowSize)

Create a sliding view over this Sequence

  
 List<List<Integer>> list = anyM(Stream.of(1,2,3,4,5,6))
    									.asSequence()
    									.sliding(2)
    									.collect(Collectors.toList());
    		
    	
    		assertThat(list.get(0),hasItems(1,2));
    		assertThat(list.get(1),hasItems(2,3));
 
 
 
 

Specified by:

sliding in interface Traversable<T>

Parameters:

windowSize - Size of sliding window

Returns:

Streamable with sliding view

sliding

default Streamable<ListX<T>> sliding(int windowSize,
                                     int increment)

Create a sliding view over this Sequence

  
 List<List<Integer>> list = anyM(Stream.of(1,2,3,4,5,6))
    									.asSequence()
    									.sliding(3,2)
    									.collect(Collectors.toList());
    		
    	
    		assertThat(list.get(0),hasItems(1,2,3));
    		assertThat(list.get(1),hasItems(3,4,5));
 
 
 
 

Specified by:

sliding in interface Traversable<T>

Parameters:

windowSize - number of elements in each batch

increment - for each window

Returns:

Streamable with sliding view

grouped

default Streamable<ListX<T>> grouped(int groupSize)

Group elements in a Stream

 {
        @code
        List<List<Integer>> list = monad(Stream.of(1, 2, 3, 4, 5, 6)).grouped(3)
                        .collect(Collectors.toList());
 
        assertThat(list.get(0), hasItems(1, 2, 3));
        assertThat(list.get(1), hasItems(4, 5, 6));
 
 }
 

Specified by:

grouped in interface Traversable<T>

Parameters:

groupSize - Size of each Group

Returns:

Stream with elements grouped by size

groupBy

default <K> MapX<K,java.util.List<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)

Use classifier function to group elements in this Sequence into a Map

  
 Map<Integer, List<Integer>> map1 =of(1, 2, 3, 4).groupBy(i -> i % 2);
    		        assertEquals(asList(2, 4), map1.get(0));
    		        assertEquals(asList(1, 3), map1.get(1));
    		        assertEquals(2, map1.size());
 
 
 
 

Specified by:

groupBy in interface Traversable<T>

scanLeft

default Streamable<T> scanLeft(Monoid<T> monoid)

Scan left using supplied Monoid

   
 
 	assertEquals(asList("", "a", "ab", "abc"),Streamable.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());
         
         
 

Specified by:

scanLeft in interface Traversable<T>

Parameters:

monoid -

Returns:

scanLeft

default <U> Streamable<U> scanLeft(U identity,
                                   java.util.function.BiFunction<U,? super T,U> function)

Scan left

  
  assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
            		is(4));
 
 

Specified by:

scanLeft in interface Traversable<T>

scanRight

default Streamable<T> scanRight(Monoid<T> monoid)

Scan right

  
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
                is(asList("", "c", "bc", "abc").size()));
 
 

Specified by:

scanRight in interface Traversable<T>

scanRight

default <U> Streamable<U> scanRight(U identity,
                                    java.util.function.BiFunction<? super T,U,U> combiner)

Scan right

  
 assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
                is(asList(0, 3, 5, 6).size()));
 
 
 

Specified by:

scanRight in interface Traversable<T>

sorted

default Streamable<T> sorted()

  assertThat(Streamable.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 

Specified by:

sorted in interface Traversable<T>

sorted

default Streamable<T> sorted(java.util.Comparator<? super T> c)

  
 	assertThat(Streamable.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
 
 

Specified by:

sorted in interface Traversable<T>

Parameters:

c - Compartor to sort with

Returns:

Sorted Monad

skip

default Streamable<T> skip(long num)

  assertThat(Streamable.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 

Specified by:

skip in interface Traversable<T>

Parameters:

num - Number of elemenets to skip

Returns:

Monad converted to Stream with specified number of elements skipped

skipWhile

default Streamable<T> skipWhile(java.util.function.Predicate<? super T> p)

 
 assertThat(Streamable.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
 
 

Specified by:

skipWhile in interface Traversable<T>

Parameters:

p - Predicate to skip while true

Returns:

Monad converted to Stream with elements skipped while predicate holds

skipUntil

default Streamable<T> skipUntil(java.util.function.Predicate<? super T> p)

  assertThat(Streamable.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 

Specified by:

skipUntil in interface Traversable<T>

Parameters:

p - Predicate to skip until true

Returns:

Monad converted to Stream with elements skipped until predicate holds

limit

default Streamable<T> limit(long num)

  assertThat(Streamable.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 

Specified by:

limit in interface Traversable<T>

Parameters:

num - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

limitWhile

default Streamable<T> limitWhile(java.util.function.Predicate<? super T> p)

  assertThat(Streamable.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
 

Specified by:

limitWhile in interface Traversable<T>

Parameters:

p - Limit while predicate is true

Returns:

Monad converted to Stream with limited elements

limitUntil

default Streamable<T> limitUntil(java.util.function.Predicate<? super T> p)

  assertThat(Streamable.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3))); 
 

Specified by:

limitUntil in interface Traversable<T>

Parameters:

p - Limit until predicate is true

Returns:

Monad converted to Stream with limited elements

allMatch

default boolean allMatch(java.util.function.Predicate<? super T> c)

True if predicate matches all elements when Monad converted to a Stream

  
 assertThat(Streamable.of(1,2,3,4,5).allMatch(it-> it>0 && it <6),equalTo(true));
 
 

Specified by:

allMatch in interface org.jooq.lambda.Collectable<T>

Specified by:

allMatch in interface CyclopsCollectable<T>

Parameters:

c - Predicate to check if all match

anyMatch

default boolean anyMatch(java.util.function.Predicate<? super T> c)

True if a single element matches when Monad converted to a Stream

  
 assertThat(Streamable.of(1,2,3,4,5).anyMatch(it-> it.equals(3)),equalTo(true));
 
 

Specified by:

anyMatch in interface org.jooq.lambda.Collectable<T>

Specified by:

anyMatch in interface CyclopsCollectable<T>

Parameters:

c - Predicate to check if any match

xMatch

default boolean xMatch(int num,
                       java.util.function.Predicate<? super T> c)

Check that there are specified number of matches of predicate in the Stream

  
  assertTrue(Streamable.of(1,2,3,5,6,7).xMatch(3, i-> i>4 ));
 
 

noneMatch

default boolean noneMatch(java.util.function.Predicate<? super T> c)

Specified by:

noneMatch in interface org.jooq.lambda.Collectable<T>

Specified by:

noneMatch in interface CyclopsCollectable<T>

join

default java.lang.String join()

 
  assertEquals("123".length(),Streamable.of(1, 2, 3).join().length());
 
 

Specified by:

join in interface Foldable<T>

Specified by:

join in interface Traversable<T>

Returns:

Stream as concatenated String

join

default java.lang.String join(java.lang.String sep)

 
 assertEquals("1, 2, 3".length(), Streamable.of(1, 2, 3).join(", ").length());
 
 

Specified by:

join in interface Foldable<T>

Specified by:

join in interface Traversable<T>

Returns:

Stream as concatenated String

join

default java.lang.String join(java.lang.String sep,
                              java.lang.String start,
                              java.lang.String end)

  
 assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
 
 

Specified by:

join in interface Foldable<T>

Specified by:

join in interface Traversable<T>

Returns:

Stream as concatenated String

minBy

default <C extends java.lang.Comparable<? super C>> java.util.Optional<T> minBy(java.util.function.Function<? super T,? extends C> f)

Extract the minimum as determined by supplied function

Specified by:

minBy in interface org.jooq.lambda.Collectable<T>

Specified by:

minBy in interface CyclopsCollectable<T>

min

default java.util.Optional<T> min(java.util.Comparator<? super T> comparator)

Specified by:

min in interface org.jooq.lambda.Collectable<T>

Specified by:

min in interface CyclopsCollectable<T>

maxBy

default <C extends java.lang.Comparable<? super C>> java.util.Optional<T> maxBy(java.util.function.Function<? super T,? extends C> f)

Extract the maximum as determined by the supplied function

Specified by:

maxBy in interface org.jooq.lambda.Collectable<T>

Specified by:

maxBy in interface CyclopsCollectable<T>

max

default java.util.Optional<T> max(java.util.Comparator<? super T> comparator)

Specified by:

max in interface org.jooq.lambda.Collectable<T>

Specified by:

max in interface CyclopsCollectable<T>

findFirst

default java.util.Optional<T> findFirst()

Specified by:

findFirst in interface Traversable<T>

Returns:

First matching element in sequential order

 
 Streamable.of(1,2,3,4,5).filter(it -> it <3).findFirst().get();
 
 //3
 
 

(deterministic)

findAny

default java.util.Optional<T> findAny()

Specified by:

findAny in interface Traversable<T>

Returns:

first matching element, but order is not guaranteed

 
 Streamable.of(1,2,3,4,5).filter(it -> it <3).findAny().get();
 
 //3
 
 

(non-deterministic)

mapReduce

default <R> R mapReduce(Reducer<R> reducer)

Attempt to map this Sequence to the same type as the supplied Monoid (Reducer) Then use Monoid to reduce values

  
 Streamable.of("hello","2","world","4").mapReduce(Reducers.toCountInt());
 
 //4
 
 

Specified by:

mapReduce in interface Foldable<T>

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

mapReduce

default <R> R mapReduce(java.util.function.Function<? super T,? extends R> mapper,
                        Monoid<R> reducer)

Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values

  
  Streamable.of("one","two","three","four")
           .mapReduce(this::toInt,Reducers.toTotalInt());
  
  //10
  
  int toInt(String s){
    		if("one".equals(s))
    			return 1;
    		if("two".equals(s))
    			return 2;
    		if("three".equals(s))
    			return 3;
    		if("four".equals(s))
    			return 4;
    		return -1;
    	   }
  
  

Specified by:

mapReduce in interface Foldable<T>

Parameters:

mapper - Function to map Monad type

reducer - Monoid to reduce values

Returns:

Reduce result

reduce

default T reduce(Monoid<T> reducer)

  
 Streamable.of("hello","2","world","4").reduce(Reducers.toString(","));
 
 //hello,2,world,4
 

Specified by:

reduce in interface Foldable<T>

Parameters:

reducer - Use supplied Monoid to reduce values

Returns:

reduced values

reduce

default java.util.Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator)

Specified by:

reduce in interface Foldable<T>

reduce

default T reduce(T identity,
                 java.util.function.BinaryOperator<T> accumulator)

Specified by:

reduce in interface Foldable<T>

reduce

default <U> U reduce(U identity,
                     java.util.function.BiFunction<U,? super T,U> accumulator,
                     java.util.function.BinaryOperator<U> combiner)

Specified by:

reduce in interface Foldable<T>

reduce

default ListX<T> reduce(java.util.stream.Stream<? extends Monoid<T>> reducers)

Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)

  
 Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
    	   Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
    	   List<Integer> result = Streamable.of(1,2,3,4)
    						.reduce(Arrays.asList(sum,mult).stream() );
    				
    		 
    		assertThat(result,equalTo(Arrays.asList(10,24)));
 
 
 

Specified by:

reduce in interface Foldable<T>

Parameters:

reducers -

Returns:

reduce

default ListX<T> reduce(java.lang.Iterable<? extends Monoid<T>> reducers)

Reduce with multiple reducers in parallel NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value To reduce over the values on the list, called streamedMonad() first. I.e. streamedMonad().reduce(reducer)

  
 Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
    		Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
    		List<Integer> result = Streamable.of(1,2,3,4))
    										.reduce(Arrays.asList(sum,mult) );
    				
    		 
    		assertThat(result,equalTo(Arrays.asList(10,24)));
 
 

Specified by:

reduce in interface Foldable<T>

Parameters:

reducers -

Returns:

foldRight

default T foldRight(Monoid<T> reducer)

                
    		Streamable.of("a","b","c").foldRight(Reducers.toString(""));
           
            // "cab"
            
            

Specified by:

foldRight in interface Foldable<T>

Parameters:

reducer - Use supplied Monoid to reduce values starting via foldRight

Returns:

Reduced result

foldRight

default T foldRight(T identity,
                    java.util.function.BinaryOperator<T> accumulator)

Immutable reduction from right to left

  
  assertTrue(Streamable.of("a","b","c").foldRight("", String::concat).equals("cba"));
 
 

Specified by:

foldRight in interface Foldable<T>

Parameters:

identity -

accumulator -

Returns:

foldRightMapToType

default <T> T foldRightMapToType(Reducer<T> reducer)

Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

                
    		Streamable.of(1,2,3).foldRightMapToType(Reducers.toString(""));
           
            // "321"
            
            

Specified by:

foldRightMapToType in interface Foldable<T>

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

startsWithIterable

default boolean startsWithIterable(java.lang.Iterable<T> iterable)

  
  assertTrue(Streamable.of(1,2,3,4).startsWith(Arrays.asList(1,2,3)));
 

Specified by:

startsWithIterable in interface Traversable<T>

Parameters:

iterable -

Returns:

True if Monad starts with Iterable sequence of data

startsWith

default boolean startsWith(java.util.Iterator<T> iterator)

 assertTrue(Streamable.of(1,2,3,4).startsWith(Arrays.asList(1,2,3).iterator())) 

Specified by:

startsWith in interface Traversable<T>

Parameters:

iterator -

Returns:

True if Monad starts with Iterators sequence of data

anyM

default AnyM<T> anyM()

Returns:

this Streamable converted to AnyM format

flatMapAnyM

default <R> Streamable<R> flatMapAnyM(java.util.function.Function<? super T,AnyM<? extends R>> fn)

Allows flatMap return type to be any Monad type

  
 	assertThat(Streamable.of(1,2,3)).flatMapAnyM(i-> anyM(CompletableFuture.completedFuture(i+2))).toList(),equalTo(Arrays.asList(3,4,5)));

 

Parameters:

fn - to be applied

Returns:

new stage in Sequence with flatMap operation to be lazily applied

flatMapIterable

default <R> Streamable<R> flatMapIterable(java.util.function.Function<? super T,java.lang.Iterable<? extends R>> fn)

FlatMap where the result is a Collection, flattens the resultant collections into the host Streamable

  
 	Streamable.of(1,2)
 			.flatMap(i -> asList(i, -i))
          .toList();
          
   //1,-1,2,-2       
 
 

Parameters:

fn -

Returns:

flatMapStream

default <R> Streamable<R> flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)

flatMap operation

  
 	assertThat(Streamable.of(1,2,3)
                      .flatMapStream(i->IntStream.of(i))
                      .toList(),equalTo(Arrays.asList(1,2,3)));

 
 

Parameters:

fn - to be applied

Returns:

new stage in Sequence with flatMap operation to be lazily applied

intersperse

default Streamable<T> intersperse(T value)

Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) Streamable.of(1, 2, 3, 4).intersperse(0)

Specified by:

intersperse in interface Traversable<T>

ofType

default <U> Streamable<U> ofType(java.lang.Class<U> type)

Keep only those elements in a stream that are of a given type. // (1, 2, 3) Streamable.of(1, "a", 2, "b",3).ofType(Integer.class)

Specified by:

ofType in interface Filterable<T>

cast

default <U> Streamable<U> cast(java.lang.Class<U> type)

Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException Streamable.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Functor<T>

toLazyCollection

default CollectionX<T> toLazyCollection()

Lazily converts this Streamable into a Collection. This does not trigger the Stream. E.g. Collection is not thread safe on the first iteration.

  
 Collection<Integer> col = Streamable.of(1,2,3,4,5)
    											.peek(System.out::println)
    											.toLazyCollection();
    		System.out.println("first!");
    		col.forEach(System.out::println);
 
 
 //Will print out "first!" before anything else
 

Specified by:

toLazyCollection in interface Traversable<T>

Returns:

toConcurrentLazyCollection

default CollectionX<T> toConcurrentLazyCollection()

Lazily converts this Streamable into a Collection. This does not trigger the Stream. E.g.

  
 Collection<Integer> col = Streamable.of(1,2,3,4,5)
    											.peek(System.out::println)
    											.toConcurrentLazyCollection();
    		System.out.println("first!");
    		col.forEach(System.out::println);
 
 
 //Will print out "first!" before anything else
 

Specified by:

toConcurrentLazyCollection in interface Traversable<T>

Returns:

reverse

default Streamable<T> reverse()

Specified by:

reverse in interface Traversable<T>

shuffle

default Streamable<T> shuffle()

Specified by:

shuffle in interface Traversable<T>

appendStreamable

default Streamable<T> appendStreamable(Streamable<T> stream)

Append Stream to this Streamable

  
 List<String> result = 	Streamable.of(1,2,3)
                                  .appendStream(Streamable.of(100,200,300))
    										.map(it ->it+"!!")
    										.collect(Collectors.toList());

    			assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
 
 

Parameters:

stream - to append

Returns:

Streamable with Stream appended

prependStreamable

default Streamable<T> prependStreamable(Streamable<T> stream)

Prepend Stream to this Streamable

  
 List<String> result = Streamable.of(1,2,3)
 								  .prependStream(of(100,200,300))
    									  .map(it ->it+"!!")
    									  .collect(Collectors.toList());

    			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
 
 

Parameters:

stream - to Prepend

Returns:

Streamable with Stream prepended

append

default Streamable<T> append(T... values)

Append values to the end of this Streamable

  
 List<String> result = Streamable.of(1,2,3)
 								   .append(100,200,300)
    										.map(it ->it+"!!")
    										.collect(Collectors.toList());

    			assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
 
 

Parameters:

values - to append

Returns:

Streamable with appended values

prepend

default Streamable<T> prepend(T... values)

Prepend given values to the start of the Stream

  
 List<String> result = 	Streamable.of(1,2,3)
 									 .prepend(100,200,300)
    										 .map(it ->it+"!!")
    										 .collect(Collectors.toList());

    			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 

Parameters:

values - to prepend

Returns:

Streamable with values prepended

insertAt

default Streamable<T> insertAt(int pos,
                               T... values)

Insert data into a stream at given position

  
 List<String> result = 	Streamable.of(1,2,3)
 									 .insertAt(1,100,200,300)
    										 .map(it ->it+"!!")
    										 .collect(Collectors.toList());

    			assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
 
 
 

Parameters:

pos - to insert data at

values - to insert

Returns:

Stream with new data inserted

deleteBetween

default Streamable<T> deleteBetween(int start,
                                    int end)

Delete elements between given indexes in a Stream

  
 List<String> result = 	Streamable.of(1,2,3,4,5,6)
 									 .deleteBetween(2,4)
    										 .map(it ->it+"!!")
    										 .collect(Collectors.toList());

    			assertThat(result,equalTo(Arrays.asList("1!!","2!!","5!!","6!!")));
 
 

Parameters:

start - index

end - index

Returns:

Stream with elements removed

insertStreamableAt

default Streamable<T> insertStreamableAt(int pos,
                                         Streamable<T> stream)

Insert a Stream into the middle of this stream at the specified position

  
 List<String> result = 	Streamable.of(1,2,3)
 									 .insertStreamAt(1,of(100,200,300))
    										 .map(it ->it+"!!")
    										 .collect(Collectors.toList());

    			assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
 
 

Parameters:

pos - to insert Stream at

stream - to insert

Returns:

newly conjoined Streamable

futureOperations

default FutureOperations<T> futureOperations(java.util.concurrent.Executor exec)

Access asynchronous terminal operations (each returns a Future)

Specified by:

futureOperations in interface Traversable<T>

Parameters:

exec - Executor to use for Stream execution

Returns:

Async Future Terminal Operations

endsWithIterable

default boolean endsWithIterable(java.lang.Iterable<T> iterable)

 
  assertTrue(Streamable.of(1,2,3,4,5,6)
    				.endsWith(Arrays.asList(5,6)));
 
 

Specified by:

endsWithIterable in interface Traversable<T>

Parameters:

iterable - Values to check

Returns:

true if Streamable ends with values in the supplied iterable

endsWith

default boolean endsWith(Streamable<T> stream)

 
 assertTrue(Streamable.of(1,2,3,4,5,6)
    				.endsWith(Stream.of(5,6))); 
 
 

Parameters:

stream - Values to check

Returns:

true if Streamable endswith values in the supplied Stream

skip

default Streamable<T> skip(long time,
                           java.util.concurrent.TimeUnit unit)

Skip all elements until specified time period has passed

  
 List<Integer> result = Streamable.of(1,2,3,4,5,6)
    										.peek(i->sleep(i*100))
    										.skip(1000,TimeUnit.MILLISECONDS)
    										.toList();
    		
    		
    		//[4,5,6]
 
 
 

Parameters:

time - Length of time

unit - Time unit

Returns:

Streamable that skips all elements until time period has elapsed

limit

default Streamable<T> limit(long time,
                            java.util.concurrent.TimeUnit unit)

Return all elements until specified time period has elapsed

  
 List<Integer> result = Streamable.of(1,2,3,4,5,6)
    										.peek(i->sleep(i*100))
    										.limit(1000,TimeUnit.MILLISECONDS)
    										.toList();
    		
    		
    		//[1,2,3,4]
 
 

Parameters:

time - Length of time

unit - Time unit

Returns:

Streamable that returns all elements until time period has elapsed

skipLast

default Streamable<T> skipLast(int num)

assertThat(Streamable.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));

Specified by:

skipLast in interface Traversable<T>

Parameters:

num -

Returns:

limitLast

default Streamable<T> limitLast(int num)

Limit results to the last x elements in a Streamable

  
 	assertThat(Streamable.of(1,2,3,4,5)
    							.limitLast(2)
    							.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
 
 

Specified by:

limitLast in interface Traversable<T>

Parameters:

num - of elements to return (last elements)

Returns:

Streamable limited to last num elements

hotStream

default HotStream<T> hotStream(java.util.concurrent.Executor e)

Turns this Streamable into a HotStream, a connectable Stream, being executed on a thread on the supplied executor, that is producing data

  
  HotStream<Integer> ints = Streamable.range(0,Integer.MAX_VALUE)
    											.hotStream(exec)
    											
    		
    		ints.connect().forEach(System.out::println);									
  //print out all the ints
  //multiple consumers are possible, so other Streams can connect on different Threads
  
 
 

Parameters:

e - Executor to execute this Streamable on

Returns:

a Connectable HotStream

firstValue

default T firstValue()

  
 	assertThat(Streamable.of(1,2,3,4)
    					.map(u->{throw new RuntimeException();})
    					.recover(e->"hello")
    					.firstValue(),equalTo("hello"));
 
 

Specified by:

firstValue in interface Traversable<T>

Returns:

first value in this Stream

single

default T single()

  
 assertThat(Streamable.of(1).single(),equalTo(1));
 
 

Specified by:

single in interface Traversable<T>

Returns:

a single value or an exception if 0/1 values in this Stream

get

default java.util.Optional<T> get(long index)

Return the elementAt index or Optional.empty

 
 	assertThat(Streamable.of(1,2,3,4,5).elementAt(2).get(),equalTo(3));
 
 

Specified by:

get in interface Traversable<T>

Parameters:

index - to extract element from

Returns:

elementAt index

elementAt

default org.jooq.lambda.tuple.Tuple2<T,Streamable<T>> elementAt(long index)

Gets the element at index, and returns a Tuple containing the element (it must be present) and a lazy copy of the Sequence for further processing.

  
 Streamable.of(1,2,3,4,5).get(2).v1
 //3
 
 

Parameters:

index - to extract element from

Returns:

Element and Sequence

elapsed

default Streamable<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> elapsed()

  
 Streamable.of(1,2,3,4,5)
    				 .elapsed()
    				 .forEach(System.out::println);
 
 

Returns:

Sequence that adds the time between elements in millis to each element

timestamp

default Streamable<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> timestamp()

 
    Streamable.of(1,2,3,4,5)
    				   .timestamp()
    				   .forEach(System.out::println)
 
 
 
 

Returns:

Sequence that adds a timestamp to each element

reversedOf

static <T> Streamable<T> reversedOf(T... elements)

Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently

Parameters:

elements - To Construct sequence from

Returns:

reversedListOf

static <T> Streamable<T> reversedListOf(java.util.List<T> elements)

Construct a Reveresed Sequence from the provided elements Can be reversed (again) efficiently

Parameters:

elements - To Construct sequence from

Returns:

range

static Streamable<java.lang.Integer> range(int start,
                                           int end)

Create an efficiently reversable Sequence that produces the integers between start and end

Parameters:

start - Number of range to start from

end - Number for range to end at

Returns:

Range Streamable

rangeLong

static Streamable<java.lang.Long> rangeLong(long start,
                                            long end)

Create an efficiently reversable Sequence that produces the integers between start and end

Parameters:

start - Number of range to start from

end - Number for range to end at

Returns:

Range Streamable

fromIntStream

static Streamable<java.lang.Integer> fromIntStream(java.util.stream.IntStream stream)

Construct a Sequence from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromLongStream

static Streamable<java.lang.Long> fromLongStream(java.util.stream.LongStream stream)

Construct a Sequence from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromDoubleStream

static Streamable<java.lang.Double> fromDoubleStream(java.util.stream.DoubleStream stream)

Construct a Sequence from a Stream

Parameters:

stream - Stream to construct Sequence from

Returns:

fromList

static <T> Streamable<T> fromList(java.util.List<T> list)

iterate

static <T> Streamable<T> iterate(T seed,
                                 java.util.function.UnaryOperator<T> f)

See Also:

Stream.iterate(Object, UnaryOperator)

generate

static <T> Streamable<T> generate(java.util.function.Supplier<T> s)

See Also:

Stream.generate(Supplier)

unzip

static <T,U> org.jooq.lambda.tuple.Tuple2<Streamable<T>,Streamable<U>> unzip(Streamable<org.jooq.lambda.tuple.Tuple2<T,U>> sequence)

Unzip a zipped Stream

  
  unzip(Streamable.of(new Tuple2(1, "a"), new Tuple2(2, "b"), new Tuple2(3, "c")))
  
  // Streamable[1,2,3], Streamable[a,b,c]
 
 
 

unzip3

static <T1,T2,T3> org.jooq.lambda.tuple.Tuple3<Streamable<T1>,Streamable<T2>,Streamable<T3>> unzip3(Streamable<org.jooq.lambda.tuple.Tuple3<T1,T2,T3>> sequence)

Unzip a zipped Stream into 3

  
    unzip3(Streamable.of(new Tuple3(1, "a", 2l), new Tuple3(2, "b", 3l), new Tuple3(3,"c", 4l)))
 
 // Streamable[1,2,3], Streamable[a,b,c], Streamable[2l,3l,4l]
 

unzip4

static <T1,T2,T3,T4> org.jooq.lambda.tuple.Tuple4<Streamable<T1>,Streamable<T2>,Streamable<T3>,Streamable<T4>> unzip4(Streamable<org.jooq.lambda.tuple.Tuple4<T1,T2,T3,T4>> sequence)

Unzip a zipped Stream into 4

  
 unzip4(Streamable.of(new Tuple4(1, "a", 2l,'z'), new Tuple4(2, "b", 3l,'y'), new Tuple4(3,
    						"c", 4l,'x')));
    		
                // Streamable[1,2,3], Streamable[a,b,c], Streamable[2l,3l,4l], Streamable[z,y,x]
 

crossJoin

default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>> crossJoin(Streamable<U> other)

innerJoin

default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>> innerJoin(Streamable<U> other,
                                                                    java.util.function.BiPredicate<T,U> predicate)

leftOuterJoin

default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>> leftOuterJoin(Streamable<U> other,
                                                                        java.util.function.BiPredicate<T,U> predicate)

rightOuterJoin

default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>> rightOuterJoin(Streamable<U> other,
                                                                         java.util.function.BiPredicate<T,U> predicate)

onEmptySwitch

default Streamable<T> onEmptySwitch(java.util.function.Supplier<Streamable<T>> switchTo)

If this Streamable is empty replace it with a another Stream

  
 assertThat(Streamable.of(4,5,6)
    							.onEmptySwitch(()->Streamable.of(1,2,3))
    							.toList(),
    							equalTo(Arrays.asList(4,5,6)));
 
 

Parameters:

switchTo - Supplier that will generate the alternative Stream

Returns:

Streamable that will switch to an alternative Stream if empty

onEmpty

default Streamable<T> onEmpty(T value)

Specified by:

onEmpty in interface Traversable<T>

onEmptyGet

default Streamable<T> onEmptyGet(java.util.function.Supplier<T> supplier)

Specified by:

onEmptyGet in interface Traversable<T>

onEmptyThrow

default <X extends java.lang.Throwable> Streamable<T> onEmptyThrow(java.util.function.Supplier<X> supplier)

Specified by:

onEmptyThrow in interface Traversable<T>

concat

default Streamable<T> concat(Streamable<T> other)

concat

default Streamable<T> concat(T other)

concat

default Streamable<T> concat(T... other)

distinct

default <U> Streamable<T> distinct(java.util.function.Function<? super T,? extends U> keyExtractor)

shuffle

default Streamable<T> shuffle(java.util.Random random)

Specified by:

shuffle in interface Traversable<T>

slice

default Streamable<T> slice(long from,
                            long to)

Specified by:

slice in interface Traversable<T>

sorted

default <U extends java.lang.Comparable<? super U>> Streamable<T> sorted(java.util.function.Function<? super T,? extends U> function)

Specified by:

sorted in interface Traversable<T>

xPer

default Streamable<T> xPer(int x,
                           long time,
                           java.util.concurrent.TimeUnit t)

emit x elements per time period

  
  SimpleTimer timer = new SimpleTimer();
    		assertThat(Streamable.of(1,2,3,4,5,6)
    		                    .xPer(6,100000000,TimeUnit.NANOSECONDS)
    		                    .collect(Collectors.toList()).size(),is(6));

 
 

Parameters:

x - number of elements to emit

time - period

t - Time unit

Returns:

Streamable that emits x elements per time period

onePer

default Streamable<T> onePer(long time,
                             java.util.concurrent.TimeUnit t)

emit one element per time period

  
 Streamable.iterate("", last -> "next")
    				.limit(100)
    				.batchBySize(10)
    				.onePer(1, TimeUnit.MICROSECONDS)
    				.peek(batch -> System.out.println("batched : " + batch))
    				.flatMap(Collection::stream)
    				.peek(individual -> System.out.println("Flattened : "
    						+ individual))
    				.forEach(a->{});
 

Parameters:

time - period

t - Time unit

Returns:

Streamable that emits 1 element per time period

debounce

default Streamable<T> debounce(long time,
                               java.util.concurrent.TimeUnit t)

Allow one element through per time period, drop all other elements in that time period

  
 Streamable.of(1,2,3,4,5,6)
          .debounce(1000,TimeUnit.SECONDS).toList();
          
 // 1 
 

Parameters:

time -

t -

Returns:

groupedBySizeAndTime

default Streamable<ListX<T>> groupedBySizeAndTime(int size,
                                                  long time,
                                                  java.util.concurrent.TimeUnit t)

Batch elements by size into a List

 
 Streamable.of(1,2,3,4,5,6)
    				.batchBySizeAndTime(3,10,TimeUnit.SECONDS)
    				.toList();
    			
 //[[1,2,3],[4,5,6]] 
 

Parameters:

size - Max size of a batch

time - (Max) time period to build a single batch in

t - time unit for batch

Returns:

Streamable batched by size and time

groupedBySizeAndTime

default <C extends java.util.Collection<? super T>> Streamable<C> groupedBySizeAndTime(int size,
                                                                                       long time,
                                                                                       java.util.concurrent.TimeUnit unit,
                                                                                       java.util.function.Supplier<C> factory)

Batch elements by size into a collection created by the supplied factory

  
 List<ArrayList<Integer>> list = of(1,2,3,4,5,6)
    					.batchBySizeAndTime(10,1,TimeUnit.MICROSECONDS,()->new ArrayList<>())
    					.toList();
 
 

Parameters:

size - Max size of a batch

time - (Max) time period to build a single batch in

unit - time unit for batch

factory - Collection factory

Returns:

Streamable batched by size and time

groupedByTime

default Streamable<ListX<T>> groupedByTime(long time,
                                           java.util.concurrent.TimeUnit t)

Batch elements in a Stream by time period

  
 assertThat(Streamable.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.SECONDS).collect(Collectors.toList()).size(),is(1));
 assertThat(Streamable.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.NANOSECONDS).collect(Collectors.toList()).size(),greaterThan(5));
 
 

Parameters:

time - - time period to build a single batch in

t - time unit for batch

Returns:

Streamable batched into lists by time period

groupedByTime

default <C extends java.util.Collection<? super T>> Streamable<C> groupedByTime(long time,
                                                                                java.util.concurrent.TimeUnit unit,
                                                                                java.util.function.Supplier<C> factory)

Batch elements by time into a collection created by the supplied factory

  
   assertThat(Streamable.of(1,1,1,1,1,1)
                       .batchByTime(1500,TimeUnit.MICROSECONDS,()-> new TreeSet<>())
                       .toList()
                       .get(0)
                       .size(),is(1));
 
 

Parameters:

time - - time period to build a single batch in

unit - time unit for batch

factory - Collection factory

Returns:

Streamable batched into collection types by time period

grouped

default <C extends java.util.Collection<? super T>> Streamable<C> grouped(int size,
                                                                          java.util.function.Supplier<C> supplier)

Batch elements in a Stream by size into a collection created by the supplied factory

 
 assertThat(Streamable.of(1,1,1,1,1,1)
 						.batchBySize(3,()->new TreeSet<>())
 						.toList()
 						.get(0)
 						.size(),is(1));
 

Specified by:

grouped in interface Traversable<T>

Parameters:

size - batch size

supplier - Collection factory

Returns:

Streamable batched into collection types by size

fixedDelay

default Streamable<T> fixedDelay(long l,
                                 java.util.concurrent.TimeUnit unit)

emit elements after a fixed delay

  
 	SimpleTimer timer = new SimpleTimer();
    		assertThat(Streamable.of(1,2,3,4,5,6)
    							.fixedDelay(10000,TimeUnit.NANOSECONDS)
    							.collect(Collectors.toList())
    							.size(),is(6));
    		assertThat(timer.getElapsedNanoseconds(),greaterThan(60000l));
 
 

Parameters:

l - time length in nanos of the delay

unit - for the delay

Returns:

Streamable that emits each element after a fixed delay

jitter

default Streamable<T> jitter(long maxJitterPeriodInNanos)

Introduce a random jitter / time delay between the emission of elements

  
 SimpleTimer timer = new SimpleTimer();
    		assertThat(Streamable.of(1,2,3,4,5,6)
    							.jitter(10000)
    							.collect(Collectors.toList())
    							.size(),is(6));
    		assertThat(timer.getElapsedNanoseconds(),greaterThan(20000l));
 
 

Parameters:

maxJitterPeriodInNanos - - random number less than this is used for each jitter

Returns:

Sequence with a random jitter between element emission

groupedUntil

default Streamable<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)

Create a Streamable batched by List, where each batch is populated until the predicate holds

  
  assertThat(Streamable.of(1,2,3,4,5,6)
    				.batchUntil(i->i%3==0)
    				.toList()
    				.size(),equalTo(2));
 
 

Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, then open next batch

Returns:

Streamable batched into lists determined by the predicate supplied

groupedWhile

default Streamable<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)

Create a Streamable batched by List, where each batch is populated while the predicate holds

  
 assertThat(Streamable.of(1,2,3,4,5,6)
    				.batchWhile(i->i%3!=0)
    				.toList().size(),equalTo(2));
    	
 
 

Specified by:

groupedWhile in interface Traversable<T>

Parameters:

predicate - Batch while predicate holds, then open next batch

Returns:

Streamable batched into lists determined by the predicate supplied

groupedWhile

default <C extends java.util.Collection<? super T>> Streamable<C> groupedWhile(java.util.function.Predicate<? super T> predicate,
                                                                               java.util.function.Supplier<C> factory)

Create a Streamable batched by a Collection, where each batch is populated while the predicate holds

  
 assertThat(Streamable.of(1,2,3,4,5,6)
    				.batchWhile(i->i%3!=0)
    				.toList()
    				.size(),equalTo(2));
 
 

Specified by:

groupedWhile in interface Traversable<T>

Parameters:

predicate - Batch while predicate holds, then open next batch

factory - Collection factory

Returns:

Streamable batched into collections determined by the predicate supplied

groupedUntil

default <C extends java.util.Collection<? super T>> Streamable<C> groupedUntil(java.util.function.Predicate<? super T> predicate,
                                                                               java.util.function.Supplier<C> factory)

Create a Streamable batched by a Collection, where each batch is populated until the predicate holds

  
 assertThat(Streamable.of(1,2,3,4,5,6)
    				.batchUntil(i->i%3!=0)
    				.toList()
    				.size(),equalTo(2));
 
 

Specified by:

groupedUntil in interface Traversable<T>

Parameters:

predicate - Batch until predicate holds, then open next batch

factory - Collection factory

Returns:

Streamable batched into collections determined by the predicate supplied

recover

default Streamable<T> recover(java.util.function.Function<java.lang.Throwable,? extends T> fn)

Recover from an exception with an alternative value

  
 assertThat(Streamable.of(1,2,3,4)
    						   .map(i->i+2)
    						   .map(u->{throw new RuntimeException();})
    						   .recover(e->"hello")
    						   .firstValue(),equalTo("hello"));
 
 

Parameters:

fn - Function that accepts a Throwable and returns an alternative value

Returns:

Streamable that can recover from an Exception

recover

default <EX extends java.lang.Throwable> Streamable<T> recover(java.lang.Class<EX> exceptionClass,
                                                               java.util.function.Function<EX,T> fn)

Recover from a particular exception type

  
 assertThat(Streamable.of(1,2,3,4)
    					.map(i->i+2)
    					.map(u->{ExceptionSoftener.throwSoftenedException( new IOException()); return null;})
    					.recover(IOException.class,e->"hello")
    					.firstValue(),equalTo("hello"));
 
 
 

Parameters:

exceptionClass - Type to recover from

fn - That accepts an error and returns an alternative value

Returns:

Streamable that can recover from a particular exception

retry

default <R> Streamable<R> retry(java.util.function.Function<T,R> fn)

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

  
 given(serviceMock.apply(anyInt())).willThrow(
    				new RuntimeException(new SocketException("First")),
    				new RuntimeException(new IOException("Second"))).willReturn(
    				"42");

    	
    		String result = Streamable.of( 1,  2, 3)
    				.retry(serviceMock)
    				.firstValue();

    		assertThat(result, is("42"));
 
 

Parameters:

fn - Function to retry if fails

contains

default boolean contains(T t)

True if a streamable contains element t

  
 assertThat(Streamable.of(1,2,3,4,5).contains(3),equalTo(true));
 
 

Parameters:

t - element to check for

parallelContains

default boolean parallelContains(T t)

True if a streamable contains element t use paralleled stream underneath

  
 assertThat(Streamable.of(1,2,3,4,5).parallelContains(3),equalTo(true));
 
 

Parameters:

t - element to check for

stream

default ReactiveSeq<T> stream()

Specified by:

stream in interface ConvertableSequence<T>

Specified by:

stream in interface Foldable<T>

Specified by:

stream in interface IterableFunctor<T>

Specified by:

stream in interface ToStream<T>

Specified by:

stream in interface Traversable<T>

Returns:

SequenceM from this Streamable

iterator

default java.util.Iterator<T> iterator()

Specified by:

iterator in interface java.lang.Iterable<T>

Specified by:

iterator in interface ToStream<T>