org.jooq.lambda

Interface Seq<T>

All Superinterfaces:

AutoCloseable, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, Iterable<T>, java.util.stream.Stream<T>

public interface Seq<T>
extends java.util.stream.Stream<T>, Iterable<T>

A sequential, ordered Stream that adds all sorts of useful methods that work only because it is sequential and ordered.

Author:

Lukas Eder

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.stream.Stream

java.util.stream.Stream.Builder<T>

Method Summary

Modifier and Type	Method and Description
default <U> Seq<U>	cast(Class<U> type) Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
static <T,U> Seq<U>	cast(java.util.stream.Stream<T> stream, Class<U> type) Cast all elements in a stream to a given type, possibly throwing a ClassCastException.
void	close()
static <T> Seq<T>	concat(java.util.stream.Stream<T>... streams) Concatenate a number of streams.
default Seq<T>	concat(java.util.stream.Stream<T> other) Concatenate two streams.
default Seq<T>	concat(T... other) Concatenate two streams.
default Seq<T>	concat(T other) Concatenate two streams.
long	count()
static <T1,T2> Seq<Tuple2<T1,T2>>	crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2) Cross join 2 streams into one.
static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>>	crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3) Cross join 3 streams into one.
static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>>	crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4) Cross join 4 streams into one.
static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>>	crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5) Cross join 5 streams into one.
static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>>	crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6) Cross join 6 streams into one.
static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>>	crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7) Cross join 7 streams into one.
static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>	crossJoin(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8) Cross join 8 streams into one.
default <U> Seq<Tuple2<T,U>>	crossJoin(java.util.stream.Stream<U> other) Cross join 2 streams into one.
default Seq<T>	cycle() Repeat a stream infinitely.
static <T> Seq<T>	cycle(java.util.stream.Stream<T> stream) Repeat a stream infinitely.
Seq<T>	distinct()
default <U> Seq<T>	distinct(java.util.function.Function<? super T,? extends U> keyExtractor) Get a stream of distinct keys.
default Tuple2<Seq<T>,Seq<T>>	duplicate() Duplicate a Streams into two equivalent Streams.
static <T> Tuple2<Seq<T>,Seq<T>>	duplicate(java.util.stream.Stream<T> stream) Duplicate a Streams into two equivalent Streams.
static <T> Seq<T>	empty()
Seq<T>	filter(java.util.function.Predicate<? super T> predicate)
<R> Seq<R>	flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper)
java.util.stream.DoubleStream	flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)
java.util.stream.IntStream	flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)
java.util.stream.LongStream	flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)
static <T,U> U	foldLeft(java.util.stream.Stream<T> stream, U seed, java.util.function.BiFunction<U,? super T,U> function) Fold a stream to the left.
default <U> U	foldLeft(U seed, java.util.function.BiFunction<U,? super T,U> function) Fold a Stream to the left.
static <T,U> U	foldRight(java.util.stream.Stream<T> stream, U seed, java.util.function.BiFunction<? super T,U,U> function) Fold a stream to the right.
default <U> U	foldRight(U seed, java.util.function.BiFunction<? super T,U,U> function) Fold a Stream to the right.
default void	forEach(java.util.function.Consumer<? super T> action)
static Seq<Void>	generate()
static <T> Seq<T>	generate(java.util.function.Supplier<T> s)
static <T> Seq<T>	generate(T value)
default <K> Map<K,List<T>>	groupBy(java.util.function.Function<? super T,? extends K> classifier) Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function) collector.
default <K,A,D> Map<K,D>	groupBy(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream) Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function, Collector) collector.
default <K,D,A,M extends Map<K,D>> M	groupBy(java.util.function.Function<? super T,? extends K> classifier, java.util.function.Supplier<M> mapFactory, java.util.stream.Collector<? super T,A,D> downstream) Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function, Supplier, Collector) collector.
static <T,K> Map<K,List<T>>	groupBy(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends K> classifier) Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function) collector.
static <T,K,A,D> Map<K,D>	groupBy(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream) Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function, Collector) collector.
static <T,K,D,A,M extends Map<K,D>> M	groupBy(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends K> classifier, java.util.function.Supplier<M> mapFactory, java.util.stream.Collector<? super T,A,D> downstream) Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function, Supplier, Collector) collector.
default <U> Seq<Tuple2<T,U>>	innerJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<T,U> predicate) Inner join 2 streams into one.
static <T> Seq<T>	intersperse(java.util.stream.Stream<T> stream, T value) Returns a stream with a given value interspersed between any two values of this stream.
default Seq<T>	intersperse(T value) Returns a stream with a given value interspersed between any two values of this stream.
default boolean	isEmpty() Check if the sequence has any elements
default boolean	isNotEmpty() Check if the sequence has no elements
static <T> Seq<T>	iterate(T seed, java.util.function.UnaryOperator<T> f)
default String	join() Shortcut for calling Stream.collect(Collector) with a Collectors.joining() collector.
default String	join(CharSequence delimiter) Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence) collector.
default String	join(CharSequence delimiter, CharSequence prefix, CharSequence suffix) Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence, CharSequence, CharSequence) collector.
static String	join(java.util.stream.Stream<?> stream) Shortcut for calling Stream.collect(Collector) with a Collectors.joining() collector.
static String	join(java.util.stream.Stream<?> stream, CharSequence delimiter) Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence) collector.
static String	join(java.util.stream.Stream<?> stream, CharSequence delimiter, CharSequence prefix, CharSequence suffix) Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence, CharSequence, CharSequence) collector.
default <U> Seq<Tuple2<T,U>>	leftOuterJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<T,U> predicate) Left outer join 2 streams into one.
Seq<T>	limit(long maxSize)
static <T> Seq<T>	limit(java.util.stream.Stream<T> stream, long elements) Returns a stream limited to n elements.
default Seq<T>	limitUntil(java.util.function.Predicate<? super T> predicate) Returns a stream limited to all elements for which a predicate evaluates to false.
static <T> Seq<T>	limitUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate) Returns a stream limited to all elements for which a predicate evaluates to true.
default Seq<T>	limitWhile(java.util.function.Predicate<? super T> predicate) Returns a stream limited to all elements for which a predicate evaluates to true.
static <T> Seq<T>	limitWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate) Returns a stream limited to all elements for which a predicate evaluates to true.
<R> Seq<R>	map(java.util.function.Function<? super T,? extends R> mapper)
java.util.stream.DoubleStream	mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)
java.util.stream.IntStream	mapToInt(java.util.function.ToIntFunction<? super T> mapper)
java.util.stream.LongStream	mapToLong(java.util.function.ToLongFunction<? super T> mapper)
default <U extends Comparable<U>> Optional<T>	maxBy(java.util.function.Function<T,U> function) Get the maximum value by a function.
default <U> Optional<T>	maxBy(java.util.function.Function<T,U> function, Comparator<? super U> comparator) Get the maximum value by a function.
default <U extends Comparable<U>> Optional<T>	minBy(java.util.function.Function<T,U> function) Get the maximum value by a function.
default <U> Optional<T>	minBy(java.util.function.Function<T,U> function, Comparator<? super U> comparator) Get the maximum value by a function.
static <T> Seq<T>	of(T... values)
static <T> Seq<T>	of(T value)
default <U> Seq<U>	ofType(Class<U> type) Keep only those elements in a stream that are of a given type.
static <T,U> Seq<U>	ofType(java.util.stream.Stream<T> stream, Class<U> type) Keep only those elements in a stream that are of a given type.
Seq<T>	onClose(Runnable closeHandler)
default Seq<T>	onEmpty(T value) Produce this stream, or an alternative stream from the value, in case this stream is empty.
default Seq<T>	onEmptyGet(java.util.function.Supplier<T> supplier) Produce this stream, or an alternative stream from the supplier, in case this stream is empty.
default <X extends Throwable> Seq<T>	onEmptyThrow(java.util.function.Supplier<X> supplier) Produce this stream, or an alternative stream from the supplier, in case this stream is empty.
default Seq<T>	parallel()
default Tuple2<Seq<T>,Seq<T>>	partition(java.util.function.Predicate<? super T> predicate) Partition a stream into two given a predicate.
static <T> Tuple2<Seq<T>,Seq<T>>	partition(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate) Partition a stream into two given a predicate.
Seq<T>	peek(java.util.function.Consumer<? super T> action)
default Seq<T>	reverse() Reverse a stream.
static <T> Seq<T>	reverse(java.util.stream.Stream<T> stream) Reverse a stream.
default <U> Seq<Tuple2<T,U>>	rightOuterJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<T,U> predicate) Right outer join 2 streams into one.
static <T,U> Seq<U>	scanLeft(java.util.stream.Stream<T> stream, U seed, java.util.function.BiFunction<U,? super T,U> function) Scan a stream to the left.
default <U> Seq<U>	scanLeft(U seed, java.util.function.BiFunction<U,? super T,U> function) Scan a stream to the left.
static <T,U> Seq<U>	scanRight(java.util.stream.Stream<T> stream, U seed, java.util.function.BiFunction<? super T,U,U> function) Scan a stream to the right.
default <U> Seq<U>	scanRight(U seed, java.util.function.BiFunction<? super T,U,U> function) Scan a stream to the right.
static Seq<Double>	seq(java.util.stream.DoubleStream stream) Wrap a IntStream into a Seq.
static Seq<Byte>	seq(InputStream is) Wrap an InputStream into a Seq.
static Seq<Integer>	seq(java.util.stream.IntStream stream) Wrap a IntStream into a Seq.
static <T> Seq<T>	seq(Iterable<T> iterable) Wrap an Iterable into a Seq.
static <T> Seq<T>	seq(Iterator<T> iterator) Wrap an Iterator into a Seq.
static Seq<Long>	seq(java.util.stream.LongStream stream) Wrap a IntStream into a Seq.
static <K,V> Seq<Tuple2<K,V>>	seq(Map<K,V> map) Wrap a Map into a Seq.
static <T> Seq<T>	seq(Optional<T> optional) Wrap an Optional into a Seq.
static Seq<Character>	seq(Reader reader) Wrap a Reader into a Seq.
static <T> Seq<T>	seq(Spliterator<T> spliterator) Wrap a Spliterator into a Seq.
static <T> Seq<T>	seq(java.util.stream.Stream<T> stream) Wrap a Stream into a Seq.
default Seq<T>	sequential()
default Seq<T>	shuffle() Shuffle a stream // e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle()
default Seq<T>	shuffle(Random random) Shuffle a stream using specified source of randomness // e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle(new Random())
static <T> Seq<T>	shuffle(java.util.stream.Stream<T> stream) Shuffle a stream // e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle()
static <T> Seq<T>	shuffle(java.util.stream.Stream<T> stream, Random random) Shuffle a stream using specified source of randomness // e.g. (2, 3, 1) Seq.of(1, 2, 3).shuffle(new Random())
Seq<T>	skip(long n)
static <T> Seq<T>	skip(java.util.stream.Stream<T> stream, long elements) Returns a stream with n elements skipped.
default Seq<T>	skipUntil(java.util.function.Predicate<? super T> predicate) Returns a stream with all elements skipped for which a predicate evaluates to false.
static <T> Seq<T>	skipUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate) Returns a stream with all elements skipped for which a predicate evaluates to false.
default Seq<T>	skipWhile(java.util.function.Predicate<? super T> predicate) Returns a stream with all elements skipped for which a predicate evaluates to true.
static <T> Seq<T>	skipWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate) Returns a stream with all elements skipped for which a predicate evaluates to true.
default Seq<T>	slice(long from, long to) Returns a limited interval from a given Stream.
static <T> Seq<T>	slice(java.util.stream.Stream<T> stream, long from, long to) Returns a limited interval from a given Stream.
Seq<T>	sorted()
Seq<T>	sorted(Comparator<? super T> comparator)
default <U extends Comparable<? super U>> Seq<T>	sorted(java.util.function.Function<? super T,? extends U> function) Sort by the results of function.
default Tuple2<Seq<T>,Seq<T>>	splitAt(long position) Split a stream at a given position.
static <T> Tuple2<Seq<T>,Seq<T>>	splitAt(java.util.stream.Stream<T> stream, long position) Split a stream at a given position.
default Tuple2<Optional<T>,Seq<T>>	splitAtHead() Split a stream at the head.
static <T> Tuple2<Optional<T>,Seq<T>>	splitAtHead(java.util.stream.Stream<T> stream) Split a stream at the head.
default Spliterator<T>	spliterator()
java.util.stream.Stream<T>	stream() The underlying Stream implementation.
static <T,C extends Collection<T>> C	toCollection(java.util.stream.Stream<T> stream, java.util.function.Supplier<C> collectionFactory) Collect a Stream into a List.
default <C extends Collection<T>> C	toCollection(java.util.function.Supplier<C> collectionFactory) Collect a Stream into a Collection.
default List<T>	toList() Collect a Stream into a List.
static <T> List<T>	toList(java.util.stream.Stream<T> stream) Collect a Stream into a List.
default <L extends List<T>> L	toList(java.util.function.Supplier<L> listFactory) Collect a Stream into a List.
default <K,V> Map<K,V>	toMap(java.util.function.Function<T,K> keyMapper, java.util.function.Function<T,V> valueMapper) Collect a Stream into a Map.
static <T,K,V> Map<K,V>	toMap(java.util.stream.Stream<T> stream, java.util.function.Function<T,K> keyMapper, java.util.function.Function<T,V> valueMapper) Collect a Stream into a Map.
static <T,K,V> Map<K,V>	toMap(java.util.stream.Stream<Tuple2<K,V>> stream) Collect a Stream of Tuple2 into a Map.
default Set<T>	toSet() Collect a Stream into a Set.
static <T> Set<T>	toSet(java.util.stream.Stream<T> stream) Collect a Stream into a Set.
default <S extends Set<T>> S	toSet(java.util.function.Supplier<S> setFactory) Collect a Stream into a Set.
static String	toString(java.util.stream.Stream<?> stream) Consume a stream and concatenate all elements.
static String	toString(java.util.stream.Stream<?> stream, String separator) Consume a stream and concatenate all elements using a separator.
default String	toString(String separator) Consume a stream and concatenate all elements using a separator.
static <T,U> Seq<T>	unfold(U seed, java.util.function.Function<U,Optional<Tuple2<T,U>>> unfolder) Unfold a function into a stream.
default Seq<T>	unordered()
static <T1,T2> Tuple2<Seq<T1>,Seq<T2>>	unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream) Unzip one Stream into two.
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>	unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream, java.util.function.BiFunction<T1,T2,Tuple2<U1,U2>> unzipper) Unzip one Stream into two.
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>	unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream, java.util.function.Function<T1,U1> leftUnzipper, java.util.function.Function<T2,U2> rightUnzipper) Unzip one Stream into two.
static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>>	unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream, java.util.function.Function<Tuple2<T1,T2>,Tuple2<U1,U2>> unzipper) Unzip one Stream into two.
default <U> Seq<Tuple2<T,U>>	zip(Seq<U> other) Zip two streams into one.
default <U,R> Seq<R>	zip(Seq<U> other, java.util.function.BiFunction<T,U,R> zipper) Zip two streams into one using a BiFunction to produce resulting values.
static <T1,T2> Seq<Tuple2<T1,T2>>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2) Zip 2 streams into one.
static <T1,T2,R> Seq<R>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.function.BiFunction<T1,T2,R> zipper) Zip 2 streams into one using a BiFunction to produce resulting values.
static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3) Zip 3 streams into one.
static <T1,T2,T3,R> Seq<R>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, Function3<T1,T2,T3,R> zipper) Zip 3 streams into one using a Function3 to produce resulting values.
static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4) Zip 4 streams into one.
static <T1,T2,T3,T4,R> Seq<R>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, Function4<T1,T2,T3,T4,R> zipper) Zip 4 streams into one using a Function4 to produce resulting values.
static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5) Zip 5 streams into one.
static <T1,T2,T3,T4,T5,R> Seq<R>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, Function5<T1,T2,T3,T4,T5,R> zipper) Zip 5 streams into one using a Function5 to produce resulting values.
static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6) Zip 6 streams into one.
static <T1,T2,T3,T4,T5,T6,R> Seq<R>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, Function6<T1,T2,T3,T4,T5,T6,R> zipper) Zip 6 streams into one using a Function6 to produce resulting values.
static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7) Zip 7 streams into one.
static <T1,T2,T3,T4,T5,T6,T7,R> Seq<R>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, Function7<T1,T2,T3,T4,T5,T6,T7,R> zipper) Zip 7 streams into one using a Function7 to produce resulting values.
static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8) Zip 8 streams into one.
static <T1,T2,T3,T4,T5,T6,T7,T8,R> Seq<R>	zip(java.util.stream.Stream<T1> s1, java.util.stream.Stream<T2> s2, java.util.stream.Stream<T3> s3, java.util.stream.Stream<T4> s4, java.util.stream.Stream<T5> s5, java.util.stream.Stream<T6> s6, java.util.stream.Stream<T7> s7, java.util.stream.Stream<T8> s8, Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> zipper) Zip 8 streams into one using a Function8 to produce resulting values.
default Seq<Tuple2<T,Long>>	zipWithIndex() Zip a Stream with a corresponding Stream of indexes.
static <T> Seq<Tuple2<T,Long>>	zipWithIndex(java.util.stream.Stream<T> stream) Zip a Stream with a corresponding Stream of indexes.

Methods inherited from interface java.util.stream.Stream

allMatch, anyMatch, builder, collect, collect, concat, findAny, findFirst, forEachOrdered, max, min, noneMatch, reduce, reduce, reduce, toArray, toArray

Methods inherited from interface java.util.stream.BaseStream

isParallel, iterator

Methods inherited from interface java.lang.Iterable

iterator

Method Detail

stream

java.util.stream.Stream<T> stream()

The underlying Stream implementation.

crossJoin

default <U> Seq<Tuple2<T,U>> crossJoin(java.util.stream.Stream<U> other)

Cross join 2 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 

innerJoin

default <U> Seq<Tuple2<T,U>> innerJoin(java.util.stream.Stream<U> other,
                                       java.util.function.BiPredicate<T,U> predicate)

Inner join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2))
 Seq.of(1, 2, 3).innerJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))
 

leftOuterJoin

default <U> Seq<Tuple2<T,U>> leftOuterJoin(java.util.stream.Stream<U> other,
                                           java.util.function.BiPredicate<T,U> predicate)

Left outer join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2), tuple(3, null))
 Seq.of(1, 2, 3).leftOuterJoin(Seq.of(1, 2), t -> Objects.equals(t.v1, t.v2))
 

rightOuterJoin

default <U> Seq<Tuple2<T,U>> rightOuterJoin(java.util.stream.Stream<U> other,
                                            java.util.function.BiPredicate<T,U> predicate)

Right outer join 2 streams into one.

 // (tuple(1, 1), tuple(2, 2), tuple(null, 3))
 Seq.of(1, 2).rightOuterJoin(Seq.of(1, 2, 3), t -> Objects.equals(t.v1, t.v2))
 

onEmpty

default Seq<T> onEmpty(T value)

Produce this stream, or an alternative stream from the value, in case this stream is empty.

onEmptyGet

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

Produce this stream, or an alternative stream from the supplier, in case this stream is empty.

onEmptyThrow

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

Produce this stream, or an alternative stream from the supplier, in case this stream is empty.

concat

default Seq<T> concat(java.util.stream.Stream<T> other)

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(Seq.of(4, 5, 6))
 

See Also:

concat(Stream[])

concat

default Seq<T> concat(T other)

Concatenate two streams.

 // (1, 2, 3, 4)
 Seq.of(1, 2, 3).concat(4)
 

See Also:

concat(Stream[])

concat

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

Concatenate two streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(4, 5, 6)
 

See Also:

concat(Stream[])

cycle

default Seq<T> cycle()

Repeat a stream infinitely.

 // (1, 2, 3, 1, 2, 3, ...)
 Seq.of(1, 2, 3).cycle();
 

See Also:

cycle(Stream)

distinct

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

Get a stream of distinct keys.

 // (1, 2, 3)
 Seq.of(1, 1, 2, -2, 3).distinct(Math::abs)
 

zip

default <U> Seq<Tuple2<T,U>> zip(Seq<U> other)

Zip two streams into one.

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

See Also:

zip(Stream, Stream)

zip

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

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

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

See Also:

zip(Seq, BiFunction)

zipWithIndex

default Seq<Tuple2<T,Long>> zipWithIndex()

Zip a Stream with a corresponding Stream of indexes.

 // (tuple("a", 0), tuple("b", 1), tuple("c", 2))
 Seq.of("a", "b", "c").zipWithIndex()
 

See Also:

zipWithIndex(Stream)

foldLeft

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

Fold a Stream to the left.

 // "abc"
 Seq.of("a", "b", "c").foldLeft("", (u, t) -> u + t)
 

foldRight

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

Fold a Stream to the right.

 // "cba"
 Seq.of("a", "b", "c").foldRight("", (t, u) -> u + t)
 

scanLeft

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

Scan a stream to the left.

 // ("", "a", "ab", "abc")
 Seq.of("a", "b", "c").scanLeft("", (u, t) -> u + t)
 

scanRight

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

Scan a stream to the right.

 // ("", "c", "cb", "cba")
 Seq.of("a", "b", "c").scanRight("", (t, u) -> u + t)
 

reverse

default Seq<T> reverse()

Reverse a stream.

 // (3, 2, 1)
 Seq.of(1, 2, 3).reverse()
 

shuffle

default Seq<T> shuffle()

Shuffle a stream

 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle()
 

shuffle

default Seq<T> shuffle(Random random)

Shuffle a stream using specified source of randomness

 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle(new Random())
 

skipWhile

default Seq<T> skipWhile(java.util.function.Predicate<? super T> predicate)

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

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

See Also:

skipWhile(Stream, Predicate)

skipUntil

default Seq<T> skipUntil(java.util.function.Predicate<? super T> predicate)

Returns a stream with all elements skipped for which a predicate evaluates to false.

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

See Also:

skipUntil(Stream, Predicate)

limitWhile

default Seq<T> limitWhile(java.util.function.Predicate<? super T> predicate)

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

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

See Also:

limitWhile(Stream, Predicate)

limitUntil

default Seq<T> limitUntil(java.util.function.Predicate<? super T> predicate)

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

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

See Also:

limitUntil(Stream, Predicate)

intersperse

default Seq<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)
 Seq.of(1, 2, 3, 4).intersperse(0)
 

See Also:

intersperse(Stream, Object)

duplicate

default Tuple2<Seq<T>,Seq<T>> duplicate()

Duplicate a Streams into two equivalent Streams.

 // tuple((1, 2, 3), (1, 2, 3))
 Seq.of(1, 2, 3).duplicate()
 

See Also:

duplicate(Stream)

partition

default Tuple2<Seq<T>,Seq<T>> partition(java.util.function.Predicate<? super T> predicate)

Partition a stream into two given a predicate.

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

See Also:

partition(Stream, Predicate)

splitAt

default Tuple2<Seq<T>,Seq<T>> splitAt(long position)

Split a stream at a given position.

 // tuple((1, 2, 3), (4, 5, 6))
 Seq.of(1, 2, 3, 4, 5, 6).splitAt(3)
 

See Also:

splitAt(Stream, long)

splitAtHead

default Tuple2<Optional<T>,Seq<T>> splitAtHead()

Split a stream at the head.

 // tuple(1, (2, 3, 4, 5, 6))
 Seq.of(1, 2, 3, 4, 5, 6).splitHead(3)
 

See Also:

splitAt(Stream, long)

slice

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

Returns a limited interval from a given Stream.

 // (4, 5)
 Seq.of(1, 2, 3, 4, 5, 6).slice(3, 5)
 

See Also:

slice(Stream, long, long)

toCollection

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

Collect a Stream into a Collection.

See Also:

toCollection(Stream, Supplier)

toList

default List<T> toList()

Collect a Stream into a List.

See Also:

toList(Stream)

toList

default <L extends List<T>> L toList(java.util.function.Supplier<L> listFactory)

Collect a Stream into a List.

See Also:

toList(Stream)

toSet

default Set<T> toSet()

Collect a Stream into a Set.

See Also:

toSet(Stream)

toSet

default <S extends Set<T>> S toSet(java.util.function.Supplier<S> setFactory)

Collect a Stream into a Set.

See Also:

toSet(Stream)

toMap

default <K,V> Map<K,V> toMap(java.util.function.Function<T,K> keyMapper,
                             java.util.function.Function<T,V> valueMapper)

Collect a Stream into a Map.

See Also:

toMap(Stream, Function, Function)

toString

default String toString(String separator)

Consume a stream and concatenate all elements using a separator.

minBy

default <U extends Comparable<U>> Optional<T> minBy(java.util.function.Function<T,U> function)

Get the maximum value by a function.

minBy

default <U> Optional<T> minBy(java.util.function.Function<T,U> function,
                              Comparator<? super U> comparator)

Get the maximum value by a function.

maxBy

default <U extends Comparable<U>> Optional<T> maxBy(java.util.function.Function<T,U> function)

Get the maximum value by a function.

maxBy

default <U> Optional<T> maxBy(java.util.function.Function<T,U> function,
                              Comparator<? super U> comparator)

Get the maximum value by a function.

isEmpty

default boolean isEmpty()

Check if the sequence has any elements

isNotEmpty

default boolean isNotEmpty()

Check if the sequence has no elements

sorted

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

Sort by the results of function.

ofType

default <U> Seq<U> ofType(Class<U> type)

Keep only those elements in a stream that are of a given type.

 // (1, 2, 3)
 Seq.of(1, "a", 2, "b", 3).ofType(Integer.class)
 

See Also:

ofType(Stream, Class)

cast

default <U> Seq<U> cast(Class<U> type)

Cast all elements in a stream to a given type, possibly throwing a ClassCastException.

 // ClassCastException
 Seq.of(1, "a", 2, "b", 3).cast(Integer.class)
 

See Also:

cast(Stream, Class)

groupBy

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

Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function) collector.

groupBy

default <K,A,D> Map<K,D> groupBy(java.util.function.Function<? super T,? extends K> classifier,
                                 java.util.stream.Collector<? super T,A,D> downstream)

Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function, Collector) collector.

groupBy

default <K,D,A,M extends Map<K,D>> M groupBy(java.util.function.Function<? super T,? extends K> classifier,
                                             java.util.function.Supplier<M> mapFactory,
                                             java.util.stream.Collector<? super T,A,D> downstream)

Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function, Supplier, Collector) collector.

join

default String join()

Shortcut for calling Stream.collect(Collector) with a Collectors.joining() collector.

join

default String join(CharSequence delimiter)

Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence) collector.

join

default String join(CharSequence delimiter,
                    CharSequence prefix,
                    CharSequence suffix)

Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence, CharSequence, CharSequence) collector.

of

static <T> Seq<T> of(T value)

Specified by:

of in interface java.util.stream.Stream<T>

See Also:

Stream.of(Object)

of

@SafeVarargs
static <T> Seq<T> of(T... values)

Specified by:

of in interface java.util.stream.Stream<T>

See Also:

Stream.of(Object[])

empty

static <T> Seq<T> empty()

Specified by:

empty in interface java.util.stream.Stream<T>

See Also:

Stream.empty()

iterate

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

Specified by:

iterate in interface java.util.stream.Stream<T>

See Also:

Stream.iterate(Object, UnaryOperator)

generate

static Seq<Void> generate()

See Also:

Stream.generate(Supplier)

generate

static <T> Seq<T> generate(T value)

Specified by:

generate in interface java.util.stream.Stream<T>

See Also:

Stream.generate(Supplier)

generate

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

Specified by:

generate in interface java.util.stream.Stream<T>

See Also:

Stream.generate(Supplier)

seq

static <T> Seq<T> seq(java.util.stream.Stream<T> stream)

Wrap a Stream into a Seq.

seq

static Seq<Integer> seq(java.util.stream.IntStream stream)

Wrap a IntStream into a Seq.

seq

static Seq<Long> seq(java.util.stream.LongStream stream)

Wrap a IntStream into a Seq.

seq

static Seq<Double> seq(java.util.stream.DoubleStream stream)

Wrap a IntStream into a Seq.

seq

static <T> Seq<T> seq(Iterable<T> iterable)

Wrap an Iterable into a Seq.

seq

static <T> Seq<T> seq(Iterator<T> iterator)

Wrap an Iterator into a Seq.

seq

static <T> Seq<T> seq(Spliterator<T> spliterator)

Wrap a Spliterator into a Seq.

seq

static <K,V> Seq<Tuple2<K,V>> seq(Map<K,V> map)

Wrap a Map into a Seq.

seq

static <T> Seq<T> seq(Optional<T> optional)

Wrap an Optional into a Seq.

seq

static Seq<Byte> seq(InputStream is)

Wrap an InputStream into a Seq.

Client code must close the InputStream. All IOException's thrown be the InputStream are wrapped by UncheckedIOException's.

seq

static Seq<Character> seq(Reader reader)

Wrap a Reader into a Seq.

Client code must close the Reader. All IOException's thrown be the InputStream are wrapped by UncheckedIOException's.

cycle

static <T> Seq<T> cycle(java.util.stream.Stream<T> stream)

Repeat a stream infinitely.

 // (1, 2, 3, 1, 2, 3, ...)
 Seq.of(1, 2, 3).cycle();
 

unzip

static <T1,T2> Tuple2<Seq<T1>,Seq<T2>> unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream)

Unzip one Stream into two.

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

unzip

static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream,
                                                   java.util.function.Function<T1,U1> leftUnzipper,
                                                   java.util.function.Function<T2,U2> rightUnzipper)

Unzip one Stream into two.

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

unzip

static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream,
                                                   java.util.function.Function<Tuple2<T1,T2>,Tuple2<U1,U2>> unzipper)

Unzip one Stream into two.

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

unzip

static <T1,T2,U1,U2> Tuple2<Seq<U1>,Seq<U2>> unzip(java.util.stream.Stream<Tuple2<T1,T2>> stream,
                                                   java.util.function.BiFunction<T1,T2,Tuple2<U1,U2>> unzipper)

Unzip one Stream into two.

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

zip

static <T1,T2> Seq<Tuple2<T1,T2>> zip(java.util.stream.Stream<T1> s1,
                                      java.util.stream.Stream<T2> s2)

Zip 2 streams into one.

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

zip

static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>> zip(java.util.stream.Stream<T1> s1,
                                            java.util.stream.Stream<T2> s2,
                                            java.util.stream.Stream<T3> s3)

Zip 3 streams into one.

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

zip

static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>> zip(java.util.stream.Stream<T1> s1,
                                                  java.util.stream.Stream<T2> s2,
                                                  java.util.stream.Stream<T3> s3,
                                                  java.util.stream.Stream<T4> s4)

Zip 4 streams into one.

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

zip

static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>> zip(java.util.stream.Stream<T1> s1,
                                                        java.util.stream.Stream<T2> s2,
                                                        java.util.stream.Stream<T3> s3,
                                                        java.util.stream.Stream<T4> s4,
                                                        java.util.stream.Stream<T5> s5)

Zip 5 streams into one.

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

zip

static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>> zip(java.util.stream.Stream<T1> s1,
                                                              java.util.stream.Stream<T2> s2,
                                                              java.util.stream.Stream<T3> s3,
                                                              java.util.stream.Stream<T4> s4,
                                                              java.util.stream.Stream<T5> s5,
                                                              java.util.stream.Stream<T6> s6)

Zip 6 streams into one.

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

zip

static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>> zip(java.util.stream.Stream<T1> s1,
                                                                    java.util.stream.Stream<T2> s2,
                                                                    java.util.stream.Stream<T3> s3,
                                                                    java.util.stream.Stream<T4> s4,
                                                                    java.util.stream.Stream<T5> s5,
                                                                    java.util.stream.Stream<T6> s6,
                                                                    java.util.stream.Stream<T7> s7)

Zip 7 streams into one.

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

zip

static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> zip(java.util.stream.Stream<T1> s1,
                                                                          java.util.stream.Stream<T2> s2,
                                                                          java.util.stream.Stream<T3> s3,
                                                                          java.util.stream.Stream<T4> s4,
                                                                          java.util.stream.Stream<T5> s5,
                                                                          java.util.stream.Stream<T6> s6,
                                                                          java.util.stream.Stream<T7> s7,
                                                                          java.util.stream.Stream<T8> s8)

Zip 8 streams into one.

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

zip

static <T1,T2,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                            java.util.stream.Stream<T2> s2,
                            java.util.function.BiFunction<T1,T2,R> zipper)

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

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

zip

static <T1,T2,T3,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                               java.util.stream.Stream<T2> s2,
                               java.util.stream.Stream<T3> s3,
                               Function3<T1,T2,T3,R> zipper)

Zip 3 streams into one using a Function3 to produce resulting values.

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

zip

static <T1,T2,T3,T4,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                  java.util.stream.Stream<T2> s2,
                                  java.util.stream.Stream<T3> s3,
                                  java.util.stream.Stream<T4> s4,
                                  Function4<T1,T2,T3,T4,R> zipper)

Zip 4 streams into one using a Function4 to produce resulting values.

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

zip

static <T1,T2,T3,T4,T5,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                     java.util.stream.Stream<T2> s2,
                                     java.util.stream.Stream<T3> s3,
                                     java.util.stream.Stream<T4> s4,
                                     java.util.stream.Stream<T5> s5,
                                     Function5<T1,T2,T3,T4,T5,R> zipper)

Zip 5 streams into one using a Function5 to produce resulting values.

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

zip

static <T1,T2,T3,T4,T5,T6,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                        java.util.stream.Stream<T2> s2,
                                        java.util.stream.Stream<T3> s3,
                                        java.util.stream.Stream<T4> s4,
                                        java.util.stream.Stream<T5> s5,
                                        java.util.stream.Stream<T6> s6,
                                        Function6<T1,T2,T3,T4,T5,T6,R> zipper)

Zip 6 streams into one using a Function6 to produce resulting values.

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

zip

static <T1,T2,T3,T4,T5,T6,T7,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                           java.util.stream.Stream<T2> s2,
                                           java.util.stream.Stream<T3> s3,
                                           java.util.stream.Stream<T4> s4,
                                           java.util.stream.Stream<T5> s5,
                                           java.util.stream.Stream<T6> s6,
                                           java.util.stream.Stream<T7> s7,
                                           Function7<T1,T2,T3,T4,T5,T6,T7,R> zipper)

Zip 7 streams into one using a Function7 to produce resulting values.

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

zip

static <T1,T2,T3,T4,T5,T6,T7,T8,R> Seq<R> zip(java.util.stream.Stream<T1> s1,
                                              java.util.stream.Stream<T2> s2,
                                              java.util.stream.Stream<T3> s3,
                                              java.util.stream.Stream<T4> s4,
                                              java.util.stream.Stream<T5> s5,
                                              java.util.stream.Stream<T6> s6,
                                              java.util.stream.Stream<T7> s7,
                                              java.util.stream.Stream<T8> s8,
                                              Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> zipper)

Zip 8 streams into one using a Function8 to produce resulting values.

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

zipWithIndex

static <T> Seq<Tuple2<T,Long>> zipWithIndex(java.util.stream.Stream<T> stream)

Zip a Stream with a corresponding Stream of indexes.

 // (tuple("a", 0), tuple("b", 1), tuple("c", 2))
 Seq.of("a", "b", "c").zipWithIndex()
 

foldLeft

static <T,U> U foldLeft(java.util.stream.Stream<T> stream,
                        U seed,
                        java.util.function.BiFunction<U,? super T,U> function)

Fold a stream to the left.

 // "abc"
 Seq.of("a", "b", "c").foldLeft("", (u, t) -> u + t)
 

foldRight

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

Fold a stream to the right.

 // "cba"
 Seq.of("a", "b", "c").foldRight("", (t, u) -> u + t)
 

scanLeft

static <T,U> Seq<U> scanLeft(java.util.stream.Stream<T> stream,
                             U seed,
                             java.util.function.BiFunction<U,? super T,U> function)

Scan a stream to the left.

 // ("", "a", "ab", "abc")
 Seq.of("a", "b", "c").scanLeft("", (u, t) -> u + t)
 

scanRight

static <T,U> Seq<U> scanRight(java.util.stream.Stream<T> stream,
                              U seed,
                              java.util.function.BiFunction<? super T,U,U> function)

Scan a stream to the right.

 // ("", "c", "cb", "cba")
 Seq.of("a", "b", "c").scanRight("", (t, u) -> u + t)
 

unfold

static <T,U> Seq<T> unfold(U seed,
                           java.util.function.Function<U,Optional<Tuple2<T,U>>> unfolder)

Unfold a function into a stream.

 // (1, 2, 3, 4, 5)
 Seq.unfold(1, i -> i <= 6 ? Optional.of(tuple(i, i + 1)) : Optional.empty())
 

reverse

static <T> Seq<T> reverse(java.util.stream.Stream<T> stream)

Reverse a stream.

 // (3, 2, 1)
 Seq.of(1, 2, 3).reverse()
 

shuffle

static <T> Seq<T> shuffle(java.util.stream.Stream<T> stream)

Shuffle a stream

 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle()
 

shuffle

static <T> Seq<T> shuffle(java.util.stream.Stream<T> stream,
                          Random random)

Shuffle a stream using specified source of randomness

 // e.g. (2, 3, 1)
 Seq.of(1, 2, 3).shuffle(new Random())
 

crossJoin

static <T1,T2> Seq<Tuple2<T1,T2>> crossJoin(java.util.stream.Stream<T1> s1,
                                            java.util.stream.Stream<T2> s2)

Cross join 2 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 

crossJoin

static <T1,T2,T3> Seq<Tuple3<T1,T2,T3>> crossJoin(java.util.stream.Stream<T1> s1,
                                                  java.util.stream.Stream<T2> s2,
                                                  java.util.stream.Stream<T3> s3)

Cross join 3 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 

crossJoin

static <T1,T2,T3,T4> Seq<Tuple4<T1,T2,T3,T4>> crossJoin(java.util.stream.Stream<T1> s1,
                                                        java.util.stream.Stream<T2> s2,
                                                        java.util.stream.Stream<T3> s3,
                                                        java.util.stream.Stream<T4> s4)

Cross join 4 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 

crossJoin

static <T1,T2,T3,T4,T5> Seq<Tuple5<T1,T2,T3,T4,T5>> crossJoin(java.util.stream.Stream<T1> s1,
                                                              java.util.stream.Stream<T2> s2,
                                                              java.util.stream.Stream<T3> s3,
                                                              java.util.stream.Stream<T4> s4,
                                                              java.util.stream.Stream<T5> s5)

Cross join 5 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 

crossJoin

static <T1,T2,T3,T4,T5,T6> Seq<Tuple6<T1,T2,T3,T4,T5,T6>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                    java.util.stream.Stream<T2> s2,
                                                                    java.util.stream.Stream<T3> s3,
                                                                    java.util.stream.Stream<T4> s4,
                                                                    java.util.stream.Stream<T5> s5,
                                                                    java.util.stream.Stream<T6> s6)

Cross join 6 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 

crossJoin

static <T1,T2,T3,T4,T5,T6,T7> Seq<Tuple7<T1,T2,T3,T4,T5,T6,T7>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                          java.util.stream.Stream<T2> s2,
                                                                          java.util.stream.Stream<T3> s3,
                                                                          java.util.stream.Stream<T4> s4,
                                                                          java.util.stream.Stream<T5> s5,
                                                                          java.util.stream.Stream<T6> s6,
                                                                          java.util.stream.Stream<T7> s7)

Cross join 7 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 

crossJoin

static <T1,T2,T3,T4,T5,T6,T7,T8> Seq<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> crossJoin(java.util.stream.Stream<T1> s1,
                                                                                java.util.stream.Stream<T2> s2,
                                                                                java.util.stream.Stream<T3> s3,
                                                                                java.util.stream.Stream<T4> s4,
                                                                                java.util.stream.Stream<T5> s5,
                                                                                java.util.stream.Stream<T6> s6,
                                                                                java.util.stream.Stream<T7> s7,
                                                                                java.util.stream.Stream<T8> s8)

Cross join 8 streams into one.

 // (tuple(1, "a"), tuple(1, "b"), tuple(2, "a"), tuple(2, "b"))
 Seq.of(1, 2).crossJoin(Seq.of("a", "b"))
 

concat

@SafeVarargs
static <T> Seq<T> concat(java.util.stream.Stream<T>... streams)

Concatenate a number of streams.

 // (1, 2, 3, 4, 5, 6)
 Seq.of(1, 2, 3).concat(Seq.of(4, 5, 6))
 

duplicate

static <T> Tuple2<Seq<T>,Seq<T>> duplicate(java.util.stream.Stream<T> stream)

Duplicate a Streams into two equivalent Streams.

 // tuple((1, 2, 3), (1, 2, 3))
 Seq.of(1, 2, 3).duplicate()
 

toString

static String toString(java.util.stream.Stream<?> stream)

Consume a stream and concatenate all elements.

toString

static String toString(java.util.stream.Stream<?> stream,
                       String separator)

Consume a stream and concatenate all elements using a separator.

toCollection

static <T,C extends Collection<T>> C toCollection(java.util.stream.Stream<T> stream,
                                                  java.util.function.Supplier<C> collectionFactory)

Collect a Stream into a List.

toList

static <T> List<T> toList(java.util.stream.Stream<T> stream)

Collect a Stream into a List.

toSet

static <T> Set<T> toSet(java.util.stream.Stream<T> stream)

Collect a Stream into a Set.

toMap

static <T,K,V> Map<K,V> toMap(java.util.stream.Stream<Tuple2<K,V>> stream)

Collect a Stream of Tuple2 into a Map.

toMap

static <T,K,V> Map<K,V> toMap(java.util.stream.Stream<T> stream,
                              java.util.function.Function<T,K> keyMapper,
                              java.util.function.Function<T,V> valueMapper)

Collect a Stream into a Map.

slice

static <T> Seq<T> slice(java.util.stream.Stream<T> stream,
                        long from,
                        long to)

Returns a limited interval from a given Stream.

 // (4, 5)
 Seq.of(1, 2, 3, 4, 5, 6).slice(3, 5)
 

skip

static <T> Seq<T> skip(java.util.stream.Stream<T> stream,
                       long elements)

Returns a stream with n elements skipped.

 // (4, 5, 6)
 Seq.of(1, 2, 3, 4, 5, 6).skip(3)
 

skipWhile

static <T> Seq<T> skipWhile(java.util.stream.Stream<T> stream,
                            java.util.function.Predicate<? super T> predicate)

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

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

skipUntil

static <T> Seq<T> skipUntil(java.util.stream.Stream<T> stream,
                            java.util.function.Predicate<? super T> predicate)

Returns a stream with all elements skipped for which a predicate evaluates to false.

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

limit

static <T> Seq<T> limit(java.util.stream.Stream<T> stream,
                        long elements)

Returns a stream limited to n elements.

 // (1, 2, 3)
 Seq.of(1, 2, 3, 4, 5, 6).limit(3)
 

limitWhile

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

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

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

limitUntil

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

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

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

intersperse

static <T> Seq<T> intersperse(java.util.stream.Stream<T> stream,
                              T value)

Returns a stream with a given value interspersed between any two values of this stream.

 // (1, 0, 2, 0, 3, 0, 4)
 Seq.of(1, 2, 3, 4).intersperse(0)
 

partition

static <T> Tuple2<Seq<T>,Seq<T>> partition(java.util.stream.Stream<T> stream,
                                           java.util.function.Predicate<? super T> predicate)

Partition a stream into two given a predicate.

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

splitAt

static <T> Tuple2<Seq<T>,Seq<T>> splitAt(java.util.stream.Stream<T> stream,
                                         long position)

Split a stream at a given position.

 // tuple((1, 2, 3), (4, 5, 6))
 Seq.of(1, 2, 3, 4, 5, 6).splitAt(3)
 

splitAtHead

static <T> Tuple2<Optional<T>,Seq<T>> splitAtHead(java.util.stream.Stream<T> stream)

Split a stream at the head.

 // tuple(1, (2, 3, 4, 5, 6))
 Seq.of(1, 2, 3, 4, 5, 6).splitHead(3)
 

ofType

static <T,U> Seq<U> ofType(java.util.stream.Stream<T> stream,
                           Class<U> type)

Keep only those elements in a stream that are of a given type.

 // (1, 2, 3)
 Seq.of(1, "a", 2, "b", 3).ofType(Integer.class)
 

cast

static <T,U> Seq<U> cast(java.util.stream.Stream<T> stream,
                         Class<U> type)

Cast all elements in a stream to a given type, possibly throwing a ClassCastException.

 // ClassCastException
 Seq.of(1, "a", 2, "b", 3).cast(Integer.class)
 

groupBy

static <T,K> Map<K,List<T>> groupBy(java.util.stream.Stream<T> stream,
                                    java.util.function.Function<? super T,? extends K> classifier)

Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function) collector.

groupBy

static <T,K,A,D> Map<K,D> groupBy(java.util.stream.Stream<T> stream,
                                  java.util.function.Function<? super T,? extends K> classifier,
                                  java.util.stream.Collector<? super T,A,D> downstream)

Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function, Collector) collector.

groupBy

static <T,K,D,A,M extends Map<K,D>> M groupBy(java.util.stream.Stream<T> stream,
                                              java.util.function.Function<? super T,? extends K> classifier,
                                              java.util.function.Supplier<M> mapFactory,
                                              java.util.stream.Collector<? super T,A,D> downstream)

Shortcut for calling Stream.collect(Collector) with a Collectors.groupingBy(Function, Supplier, Collector) collector.

join

static String join(java.util.stream.Stream<?> stream)

Shortcut for calling Stream.collect(Collector) with a Collectors.joining() collector.

join

static String join(java.util.stream.Stream<?> stream,
                   CharSequence delimiter)

Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence) collector.

join

static String join(java.util.stream.Stream<?> stream,
                   CharSequence delimiter,
                   CharSequence prefix,
                   CharSequence suffix)

Shortcut for calling Stream.collect(Collector) with a Collectors.joining(CharSequence, CharSequence, CharSequence) collector.

filter

Seq<T> filter(java.util.function.Predicate<? super T> predicate)

Specified by:

filter in interface java.util.stream.Stream<T>

map

<R> Seq<R> map(java.util.function.Function<? super T,? extends R> mapper)

Specified by:

map in interface java.util.stream.Stream<T>

mapToInt

java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super T> mapper)

Specified by:

mapToInt in interface java.util.stream.Stream<T>

mapToLong

java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super T> mapper)

Specified by:

mapToLong in interface java.util.stream.Stream<T>

mapToDouble

java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)

Specified by:

mapToDouble in interface java.util.stream.Stream<T>

flatMap

<R> Seq<R> flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> mapper)

Specified by:

flatMap in interface java.util.stream.Stream<T>

flatMapToInt

java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)

Specified by:

flatMapToInt in interface java.util.stream.Stream<T>

flatMapToLong

java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)

Specified by:

flatMapToLong in interface java.util.stream.Stream<T>

flatMapToDouble

java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)

Specified by:

flatMapToDouble in interface java.util.stream.Stream<T>

distinct

Seq<T> distinct()

Specified by:

distinct in interface java.util.stream.Stream<T>

sorted

Seq<T> sorted()

Specified by:

sorted in interface java.util.stream.Stream<T>

sorted

Seq<T> sorted(Comparator<? super T> comparator)

Specified by:

sorted in interface java.util.stream.Stream<T>

peek

Seq<T> peek(java.util.function.Consumer<? super T> action)

Specified by:

peek in interface java.util.stream.Stream<T>

limit

Seq<T> limit(long maxSize)

Specified by:

limit in interface java.util.stream.Stream<T>

skip

Seq<T> skip(long n)

Specified by:

skip in interface java.util.stream.Stream<T>

onClose

Seq<T> onClose(Runnable closeHandler)

Specified by:

onClose in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

close

void close()

Specified by:

close in interface AutoCloseable

Specified by:

close in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

count

long count()

Specified by:

count in interface java.util.stream.Stream<T>

sequential

default Seq<T> sequential()

Specified by:

sequential in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

parallel

default Seq<T> parallel()

Specified by:

parallel in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

unordered

default Seq<T> unordered()

Specified by:

unordered in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

spliterator

default Spliterator<T> spliterator()

Specified by:

spliterator in interface java.util.stream.BaseStream<T,java.util.stream.Stream<T>>

Specified by:

spliterator in interface Iterable<T>

forEach

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

Specified by:

forEach in interface Iterable<T>

Specified by:

forEach in interface java.util.stream.Stream<T>