cyclops.stream

Interface Streamable<T>

Type Parameters:

T - Data type for Stream

All Superinterfaces:

ConvertableSequence<T>, ConvertableToReactiveSeq<T>, CyclopsCollectable<T>, ExtendedTraversable<T>, FilterableTransformable<T>, Filters<T>, Fn1<java.lang.Long,T>, FoldableTraversable<T>, Folds<T>, java.util.function.Function<java.lang.Long,T>, org.jooq.lambda.function.Function1<java.lang.Long,T>, java.lang.Iterable<T>, IterableFilterable<T>, OnEmpty<T>, org.reactivestreams.Publisher<T>, ReactiveStreamsTerminalOperations<T>, Sequential<T>, To<Streamable<T>>, ToStream<T>, Transformable<T>, TransformerTraversable<T>, Traversable<T>, Unit<T>, Zippable<T>

public interface Streamable<T>
extends To<Streamable<T>>, ToStream<T>, FoldableTraversable<T>, CyclopsCollectable<T>, ConvertableSequence<T>, Transformable<T>, Filters<T>, Traversable<T>, Unit<T>, Zippable<T>

Represents something that can generate a Stream, repeatedly

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	Streamable.Impl
static class	Streamable.PrintableIterable<T>

Nested classes/interfaces inherited from interface cyclops.function.Fn1

Fn1.µ, Fn1.FunctionalOperations<T1,R>

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<Witness.streamable,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 take of this Streamable
default Streamable<T>	append(T value)
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<? extends U> type) Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
default <R> Streamable<R>	coflatMap(java.util.function.Function<? super Streamable<T>,? extends R> fn) coflatMap pattern, can be used to perform lazy reductions / collections / folds and other terminal operations
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<ReactiveSeq<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<ReactiveSeq<T>>	combinations(int size) Streamable.of(1,2,3).combinations(2) //Streamable[Streamable[1,2],Streamable[1,3],Streamable[2,3]]
default Streamable<T>	combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op) Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
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(long times) Convert to a Stream with the values repeated specified times
default Streamable<T>	cycle(Monoid<T> m, long 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 Streamable<T>	dropRight(int num) Generate a new Traversable that drops the specified number elements from the take of this Traversable
default Streamable<T>	dropUntil(java.util.function.Predicate<? super T> p) Generate a new Traversable that drops elements from this Traversable until the predicate holds
default Streamable<T>	dropWhile(java.util.function.Predicate<? super T> p) Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
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) Keep only elements for which the supplied predicates hold e.g.
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 ReactiveSeq<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,? extends AnyM<Witness.streamable,? extends R>> fn) Allows flatMap return type to be any Monad type
default <R> Streamable<R>	flatMapIterable(java.util.function.Function<? super T,? extends 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
static <T1> Streamable<T1>	flatten(Streamable<? extends Streamable<T1>> nested) 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,? super U,? extends 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>	fromObject(java.lang.Object toCoerce)
static <T> Streamable<T>	fromPublisher(org.reactivestreams.Publisher<? extends T> publisher) Construct a FutureStream from an Publisher
static <T> Streamable<T>	fromStream(java.util.stream.Stream<T> stream) (Lazily) Construct a Streamable from a Stream.
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,ListX<T>>	groupBy(java.util.function.Function<? super T,? extends K> classifier) Use classifier function to group elements in this Sequence into a Map
default <K> Streamable<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>>	grouped(java.util.function.Function<? super T,? extends K> classifier) Group this Traversable by the provided classifying function and collected by the provided Collector
default <K,A,D> Streamable<org.jooq.lambda.tuple.Tuple2<K,D>>	grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream) Group this Traversable by the provided classifying function and collected by the provided Collector
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>>	groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate) Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
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 Traversable<T>	insertAtS(int pos, java.util.stream.Stream<T> stream) Insert a Stream into the middle of this stream at the specified 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
static <T> Streamable<T>	narrow(Streamable<? extends T> broad)
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<? extends U> type) Keep only those elements in a stream that are of a given type.
default Streamable<T>	onEmpty(T value) If this Container instance is empty, create a new instance containing the provided value
default Streamable<T>	onEmptyGet(java.util.function.Supplier<? extends T> supplier) If this Container instance is empty, create a new instance containing the value returned from the provided 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<? extends X> supplier) If this container instance is empty, throw the exception returned by the provided Supplier
default ReactiveSeq<T>	onePer(long time, java.util.concurrent.TimeUnit t) emit one element per time period
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<ReactiveSeq<T>>	permutations() Generate the permutations based on values in the Streamable
default Streamable<T>	prepend(T... values) Prepend given values to the skip of the Stream
default Streamable<T>	prepend(T t) Prepend given values to the skip of the Stream
default Streamable<T>	prependS(java.util.stream.Stream<? extends T> stream) Prepend Stream to this ReactiveSeq
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 skip and take
static Streamable<java.lang.Long>	rangeLong(long start, long end) Create an efficiently reversable Sequence that produces the integers between skip and take
default ReactiveSeq<T>	reactiveSeq()
default <EX extends java.lang.Throwable> Streamable<T>	recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends T> fn) Recover from a particular exception type
default Streamable<T>	recover(java.util.function.Function<? super 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) An equivalent function to Stream.reduce(BinaryOperator)
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) An equivalent function to Stream.reduce(Object, BinaryOperator)
default <U> U	reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner) An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)
default Streamable<T>	remove(T t) Remove all occurances of the specified element from the Streamable
default <R> Streamable<R>	retry(java.util.function.Function<? super T,? extends R> fn) Retry a transformation if it fails.
default Streamable<T>	reverse() Potentially efficient Stream reversal.
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<? super U,? super T,? extends 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,? super U,? extends 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<PVectorX<T>>	sliding(int windowSize) Create a sliding view over this Sequence
default Streamable<PVectorX<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()
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.stream.Stream<T> iterator) assertTrue(Streamable.of(1,2,3,4).startsWith(Stream.of(1,2,3)))
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 skip index removed, and elements after the provided take index removed
static <T> Streamable<T>	synchronizedFromIterable(java.lang.Iterable<T> toCoerce)
static <T> Streamable<T>	synchronizedFromStream(java.util.stream.Stream<T> toCoerce)
default Streamable<T>	tail() Streamable.of(1,2,3,4,5).tail() //Streamable[2,3,4,5]
default Streamable<T>	takeRight(int num) Generate a new Traversable that takes the specified number elements from the take of this Traversable
default Streamable<T>	takeUntil(java.util.function.Predicate<? super T> p) Generate a new Traversable that takes elements from this Traversable until the predicate holds
default Streamable<T>	takeWhile(java.util.function.Predicate<? super T> p) Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
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 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) Create an IterableFunctor instance of the same type from an Iterator
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 ReactiveSeq<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(java.lang.Iterable<? extends U> other) Zip 2 streams into one
default <U,R> Streamable<R>	zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper) Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
default <S,U> Streamable<org.jooq.lambda.tuple.Tuple3<T,S,U>>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third) zip 3 Streams into one
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(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth) zip 4 Streams into 1
default <T2,T3,T4> Streamable<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>	zip4(Streamable<? extends T2> second, Streamable<? extends T3> third, Streamable<? extends T4> fourth) zip 4 Streams into 1
default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>>	zipS(java.util.stream.Stream<? extends U> other) Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
default <U,R> Streamable<R>	zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper) Zip (combine) this Zippable with the supplied Stream, using the supplied combining 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.cyclops2.types.To

to

Methods inherited from interface com.aol.cyclops2.types.FoldableTraversable

apply, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, headAndTail, runFuture, runLazy, seq, visit

Methods inherited from interface cyclops.function.Fn1

andThen, andThen, bind, compose, functionOps, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, product, reader, λ, λv

Methods inherited from interface org.jooq.lambda.function.Function1

apply, applyPartially, applyPartially, curry, curry, from, toFunction

Methods inherited from interface java.util.function.Function

identity

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

avg, avgDouble, avgInt, avgLong, bitAnd, bitAndInt, bitAndLong, bitOr, bitOrInt, bitOrLong, commonPrefix, commonSuffix, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, median, median, medianBy, medianBy, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, mode, modeAll, modeAllBy, modeBy, percentile, percentile, percentileBy, percentileBy, sum, sumDouble, sumInt, sumLong, toList, toMap, toMap, toSet, toSet, toString, toString

Methods inherited from interface com.aol.cyclops2.types.Folds

endsWith, foldLeft, foldLeft, foldLeft, print, print, printErr, printOut, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, singleOptional, toConcurrentLazyStreamable

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

toDequeX, toFutureStream, toFutureStream, toListX, toMapX, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toValue

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

drop, mapToDouble, mapToInt, mapToLong, subscribe, take, traversable

Methods inherited from interface com.aol.cyclops2.types.Zippable

zip, zip3, zip4, zipP, zipP, zipWith, zipWithP, zipWithS

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

futureStream, getStreamable, isEmpty, jdkStream, reveresedJDKStream, reveresedStream

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Methods inherited from interface com.aol.cyclops2.types.IterableFilterable

removeAllS, removeAllS, removeAllS, retainAllS, retainAllS, retainAllS

Methods inherited from interface com.aol.cyclops2.types.Filters

filterNot, notNull

Methods inherited from interface com.aol.cyclops2.types.Transformable

retry, trampoline

Methods inherited from interface com.aol.cyclops2.types.TransformerTraversable

groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

Method Detail

fromObject

static <T> Streamable<T> fromObject(java.lang.Object toCoerce)

reactiveSeq

default ReactiveSeq<T> reactiveSeq()

Specified by:

reactiveSeq in interface ConvertableToReactiveSeq<T>

Specified by:

reactiveSeq in interface ToStream<T>

Returns:

ReactiveSeq generated from this convertable type

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

synchronizedFromStream

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

Parameters:

toCoerce - Efficiently / lazily Makes Stream repeatable, guards iteration with locks on initial iteration

Returns:

synchronizedFromIterable

static <T> Streamable<T> synchronizedFromIterable(java.lang.Iterable<T> toCoerce)

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>

Returns:

Collectable

combine

default Streamable<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
                              java.util.function.BinaryOperator<T> op)

Description copied from interface: Traversable

Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The output of a combination may in turn be combined with it's neighbour

  
  ReactiveSeq.of(1,1,2,3)
                   .combine((a, b)->a.equals(b),Semigroups.intSum)
                   .toListX()
                   
  //ListX(3,4) 
 

Specified by:

combine in interface Traversable<T>

Parameters:

predicate - Test to see if two neighbours should be joined

op - Reducer to combine neighbours

Returns:

Combined / Partially Reduced Traversable

zip

default <U,R> Streamable<R> zip(java.lang.Iterable<? extends U> other,
                                java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Iterable using the supplied combining function

Specified by:

zip in interface Traversable<T>

Specified by:

zip in interface Zippable<T>

Parameters:

other - to zip with

zipper - Zip function

Returns:

Combined zippable

zipS

default <U,R> Streamable<R> zipS(java.util.stream.Stream<? extends U> other,
                                 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

Specified by:

zipS in interface Zippable<T>

Parameters:

other - Stream to combine with

zipper - Zip / combining function

Returns:

Combined zippable

zipS

default <U> Streamable<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)

Description copied from interface: Traversable

Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2

Specified by:

zipS in interface Traversable<T>

Specified by:

zipS in interface Zippable<T>

Parameters:

other - Stream to combine with

Returns:

Combined Zippable

zip3

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

Description copied from interface: Traversable

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']]
 
 
 

Specified by:

zip3 in interface Traversable<T>

Specified by:

zip3 in interface Zippable<T>

zip4

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

Description copied from interface: Traversable

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"]]
 

Specified by:

zip4 in interface Traversable<T>

Specified by:

zip4 in interface Zippable<T>

groupedStatefullyUntil

default Streamable<ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)

Description copied from interface: Traversable

Create Travesable of Lists where each List is populated while the supplied bipredicate holds. The bipredicate recieves the List from the last window as well as the current value and can choose to aggregate the current value or create a new window

  
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
              .toList().size(),equalTo(5));
 
 

Specified by:

groupedStatefullyUntil in interface Traversable<T>

Parameters:

predicate - Window while true

Returns:

Traversable windowed while predicate holds

grouped

default <K,A,D> Streamable<org.jooq.lambda.tuple.Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier,
                                                                      java.util.stream.Collector<? super T,A,D> downstream)

Description copied from interface: Traversable

Group this Traversable by the provided classifying function and collected by the provided Collector

Specified by:

grouped in interface Traversable<T>

Parameters:

classifier - Grouping function

downstream - Collector to create the grouping collection

Returns:

Traversable of grouped data

grouped

default <K> Streamable<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)

Description copied from interface: Traversable

Group this Traversable by the provided classifying function and collected by the provided Collector

Specified by:

grouped in interface Traversable<T>

Parameters:

classifier - Grouping function

Returns:

Traversable of grouped data

takeWhile

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

Description copied from interface: Traversable

Generate a new Traversable that takes elements from this Traversable as long as the predicate holds

  
     ListX.of(1,2,3).takeWhile(i<3);
     //[1,2]
 
 

Specified by:

takeWhile in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be taken

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

dropWhile

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

Description copied from interface: Traversable

Generate a new Traversable that drops elements from this Traversable as long as the predicate holds

  
     ListX.of(1,2,3).dropWhile(i<3);
     //[3]
 
 

Specified by:

dropWhile in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be dropped

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

takeUntil

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

Description copied from interface: Traversable

Generate a new Traversable that takes elements from this Traversable until the predicate holds

  
     ListX.of(1,2,3).takeUntil(i<2);
     //[1,2]
 
 

Specified by:

takeUntil in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be taken until

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

dropUntil

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

Description copied from interface: Traversable

Generate a new Traversable that drops elements from this Traversable until the predicate holds

  
     ListX.of(1,2,3).dropUntil(i>2);
     //[3]
 
 

Specified by:

dropUntil in interface Traversable<T>

Parameters:

p - Predicate to determine when values should be dropped

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

dropRight

default Streamable<T> dropRight(int num)

Description copied from interface: Traversable

Generate a new Traversable that drops the specified number elements from the take of this Traversable

  
     ListX.of(1,2,3).dropRight(2);
     //[1]
 
 

Specified by:

dropRight in interface Traversable<T>

Parameters:

num - Drop this number of elements from the take of this Traversable

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

takeRight

default Streamable<T> takeRight(int num)

Description copied from interface: Traversable

Generate a new Traversable that takes the specified number elements from the take of this Traversable

  
     ListX.of(1,2,3).takeRight(2);
     //[2,3]
 
 

Specified by:

takeRight in interface Traversable<T>

Parameters:

num - Take this number of elements from the take of this Traversable

Returns:

Traversable generated by application of the predicate to the elements in this Traversable in order

fromPublisher

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

Construct a FutureStream from an Publisher

Parameters:

publisher - to construct ReactiveSeq from

Returns:

FutureStream

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)

Description copied from interface: Traversable

Create an IterableFunctor instance of the same type from an Iterator

 
       ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);

 
 

Specified by:

unitIterator in interface Traversable<T>

Parameters:

it - Iterator to create new IterableFunctor from

Returns:

New IterableFunctor instance

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 Streamable

 
 	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 Streamable

prepend

default Streamable<T> prepend(T t)

Prepend given values to the skip 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!!")));
 
 

Specified by:

prepend in interface Traversable<T>

Parameters:

t - value 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"
 
 

Specified by:

foldLeft in interface Folds<T>

Parameters:

identity - - identity value

function - folding function

Returns:

Value from reduction

foldRight

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

Fold a Streamable fromt the right

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

Specified by:

foldRight in interface Folds<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 FilterableTransformable<T>

Specified by:

map in interface Transformable<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 Transformable<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)

Description copied from interface: Filters

Keep only elements for which the supplied predicates hold e.g.

  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 

Specified by:

filter in interface FilterableTransformable<T>

Specified by:

filter in interface Filters<T>

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

flatMap

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

coflatMap

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

coflatMap pattern, can be used to perform lazy reductions / collections / folds and other terminal operations

 

      ReactiveSeq.of(1,2,3)
                 .map(i->i*2)
                 .coflatMap(s -> s.reduce(0,(a,b)->a+b))

      //ReactiveSeq[12]
 
 

Parameters:

fn -

Returns:

count

default long count()

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 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 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 CyclopsCollectable<T>

Parameters:

collectionFactory -

Returns:

contents of this Stream in a mutable collection

permutations

default Streamable<ReactiveSeq<T>> permutations()

Generate the permutations based on values in the Streamable

Specified by:

permutations in interface ExtendedTraversable<T>

Returns:

Streamable containing the permutations in this Streamable

subStream

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

Return a Streamable with elements before the provided skip index removed, and elements after the provided take 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<ReactiveSeq<T>> combinations(int size)

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

Specified by:

combinations in interface ExtendedTraversable<T>

Parameters:

size - of combinations

Returns:

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

combinations

default Streamable<ReactiveSeq<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]]
 
 

Specified by:

combinations in interface ExtendedTraversable<T>

Returns:

All combinations of the elements in this stream

flatten

static <T1> Streamable<T1> flatten(Streamable<? extends Streamable<T1>> nested)

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:

this Streamable converted to an Optional List

cycle

default Streamable<T> cycle(long 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()

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,
                            long 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(java.lang.Iterable<? extends 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"]]
    	  
 

Specified by:

zip in interface Zippable<T>

Parameters:

other - Iterable to combine with

Returns:

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<? extends T2> second,
                                                                             Streamable<? extends T3> third,
                                                                             Streamable<? extends 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>

sliding

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

Create a sliding view over this Sequence

  
 List<List<Integer>> list = fromEither5(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<PVectorX<T>> sliding(int windowSize,
                                        int increment)

Create a sliding view over this Sequence

  
 List<List<Integer>> list = fromEither5(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

 
  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,ListX<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 Folds<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 - To combine values

Returns:

Streamable

scanLeft

default <U> Streamable<U> scanLeft(U identity,
                                   java.util.function.BiFunction<? super U,? super T,? extends 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,? super U,? extends 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 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 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 ));
 
 

Specified by:

xMatch in interface Folds<T>

noneMatch

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

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 Folds<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 Folds<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 Folds<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 CyclopsCollectable<T>

min

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

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 CyclopsCollectable<T>

max

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

Specified by:

max in interface CyclopsCollectable<T>

findFirst

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

Specified by:

findFirst in interface Folds<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 Folds<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 Folds<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 Folds<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 Folds<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)

Description copied from interface: Folds

An equivalent function to Stream.reduce(BinaryOperator)

 
  
       ReactiveSeq.of(1,2,3,4,5).map(it -> it*100).reduce(
 (acc,next) -> acc+next)
        //Optional[1500]
  
  

Specified by:

reduce in interface Folds<T>

Parameters:

accumulator - Combiner function

Returns:

reduce

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

Description copied from interface: Folds

An equivalent function to Stream.reduce(Object, BinaryOperator)

Specified by:

reduce in interface Folds<T>

accumulator - Combiner function

Returns:

Value produced by applying the current accumulated value and the next value to the combiner function as this Folds is traversed from left to right

reduce

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

Description copied from interface: Folds

An equivalent function to Stream.reduce(Object, BiFunction, BinaryOperator)

Specified by:

reduce in interface Folds<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 Folds<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 Folds<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 Folds<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 Folds<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 Folds<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 Folds<T>

Parameters:

iterable -

Returns:

True if Monad starts with Iterable sequence of data

startsWith

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

 assertTrue(Streamable.of(1,2,3,4).startsWith(Stream.of(1,2,3))) 

Specified by:

startsWith in interface Folds<T>

Parameters:

iterator -

Returns:

True if Monad starts with Iterators sequence of data

anyM

default AnyM<Witness.streamable,T> anyM()

Returns:

this Streamable converted to AnyM format

flatMapAnyM

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

Allows flatMap return type to be any Monad type

  
 	assertThat(Streamable.of(1,2,3)).flatMapAnyM(i-> fromEither5(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

narrow

static <T> Streamable<T> narrow(Streamable<? extends T> broad)

flatMapIterable

default <R> Streamable<R> flatMapIterable(java.util.function.Function<? super T,? extends 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<? extends 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 Filters<T>

cast

default <U> Streamable<U> cast(java.lang.Class<? extends 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 Transformable<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 Folds<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 Folds<T>

Returns:

reverse

default Streamable<T> reverse()

Description copied from interface: Traversable

Potentially efficient Stream reversal. Is efficient if - Sequence created via a range - Sequence created via a List - Sequence created via an Array / var args Otherwise Sequence collected into a Collection prior to reversal

  assertThat( of(1, 2, 3).reverse().toList(),
 equalTo(asList(3, 2, 1)));  

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

prependS

default Streamable<T> prependS(java.util.stream.Stream<? extends T> stream)

Description copied from interface: Traversable

Prepend Stream to this ReactiveSeq

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

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

Specified by:

prependS in interface Traversable<T>

Parameters:

stream - to Prepend

Returns:

ReactiveSeq with Stream prepended

append

default Streamable<T> append(T value)

Specified by:

append in interface Traversable<T>

insertAtS

default Traversable<T> insertAtS(int pos,
                                 java.util.stream.Stream<T> stream)

Description copied from interface: Traversable

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

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

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

Specified by:

insertAtS in interface Traversable<T>

Parameters:

pos - to insert Stream at

stream - to insert

Returns:

newly conjoined Traversable

append

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

Append values to the take 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!!")));
 
 

Specified by:

append in interface Traversable<T>

Parameters:

values - to append

Returns:

Streamable with appended values

prepend

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

Prepend given values to the skip 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!!")));
 
 

Specified by:

prepend in interface Traversable<T>

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!!")));
 
 
 

Specified by:

insertAt in interface Traversable<T>

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!!")));
 
 

Specified by:

deleteBetween in interface Traversable<T>

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)
 									 .insertAtS(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

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 Folds<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 Folds<T>

Returns:

first value in this Stream

single

default T single()

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

Specified by:

single in interface Folds<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 Folds<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 skip and take

Parameters:

start - Number of range to skip from

end - Number for range to take 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 skip and take

Parameters:

start - Number of range to skip from

end - Number for range to take 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,'µ'), 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[µ,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)

Description copied from interface: OnEmpty

If this Container instance is empty, create a new instance containing the provided value

Specified by:

onEmpty in interface OnEmpty<T>

Specified by:

onEmpty in interface Traversable<T>

Returns:

New instance containing value if container is empty, otherwise returns this container

onEmptyGet

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

Description copied from interface: OnEmpty

If this Container instance is empty, create a new instance containing the value returned from the provided Supplier

Specified by:

onEmptyGet in interface OnEmpty<T>

Specified by:

onEmptyGet in interface Traversable<T>

Parameters:

supplier - to determine new value for container

Returns:

New Container with value if this is empty, otherwise this container

onEmptyThrow

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

Description copied from interface: OnEmpty

If this container instance is empty, throw the exception returned by the provided Supplier

Specified by:

onEmptyThrow in interface OnEmpty<T>

Specified by:

onEmptyThrow in interface Traversable<T>

Parameters:

supplier - to create exception from

Returns:

Throw exception if empty, otherwise this container

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 ReactiveSeq<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));
    
 
 

Specified by:

xPer in interface Sequential<T>

Parameters:

x - number of elements to emit

time - period

t - Time unit

Returns:

Streamable that emits x elements per time period

onePer

default ReactiveSeq<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->{});
 
 

Specified by:

onePer in interface Sequential<T>

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 ReactiveSeq<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));
 
 

Specified by:

fixedDelay in interface Sequential<T>

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, transform 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, transform 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, transform 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, transform 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<? super 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"));
 
 

Specified by:

recover in interface Traversable<T>

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<? super EX,? extends 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"));
 
 
 

Specified by:

recover in interface Traversable<T>

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<? super T,? extends 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"));
 
 

Specified by:

retry in interface Transformable<T>

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

stream

default ReactiveSeq<T> stream()

Specified by:

stream in interface ConvertableSequence<T>

Specified by:

stream in interface ExtendedTraversable<T>

Specified by:

stream in interface FoldableTraversable<T>

Specified by:

stream in interface Sequential<T>

Specified by:

stream in interface ToStream<T>

Specified by:

stream in interface TransformerTraversable<T>

Specified by:

stream in interface Traversable<T>

Returns:

ReactiveSeq from this Streamable

iterator

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

Specified by:

iterator in interface java.lang.Iterable<T>