com.landawn.abacus.util.stream

Class Stream<T>

java.lang.Object

com.landawn.abacus.util.stream.Stream<T>

Type Parameters:

T - the type of the stream elements

All Implemented Interfaces:

BaseStream<T,java.lang.Object[],Predicate<? super T>,Consumer<? super T>,java.util.List<T>,Optional<T>,Indexed<T>,ObjIterator<T>,Stream<T>>, java.lang.AutoCloseable

Direct Known Subclasses:

Stream.StreamEx

public abstract class Stream<T>
extends java.lang.Object

Note: It's copied from OpenJDK at: http://hg.openjdk.java.net/jdk8u/hs-dev/jdk, And including methods copied from StreamEx: https://github.com/amaembo/streamex under Apache License, version 2.0.

 It's designed to service your purposes: Do what you want and returns what you expected. Try the best to adopt the the design principles of Java 8 Stream APIs, but won't has to obey every rule.
 

A sequence of elements supporting sequential and parallel aggregate operations. The following example illustrates an aggregate operation using Stream and IntStream:

     int sum = widgets.stream()
                      .filter(w -> w.getColor() == RED)
                      .mapToInt(w -> w.getWeight())
                      .sum();
 

In this example, widgets is a Collection<Widget>. We create a stream of Widget objects via Collection.stream(), filter it to produce a stream containing only the red widgets, and then transform it into a stream of int values representing the weight of each red widget. Then this stream is summed to produce a total weight.

In addition to Stream, which is a stream of object references, there are primitive specializations for IntStream, LongStream, and DoubleStream, all of which are referred to as "streams" and conform to the characteristics and restrictions described here.

To perform a computation, stream operations are composed into a stream pipeline. A stream pipeline consists of a source (which might be an array, a collection, a generator function, an I/O channel, etc), zero or more intermediate operations (which transform a stream into another stream, such as Stream#filter(Predicate)), and a terminal operation (which produces a result or side-effect, such as BaseStream.count() or Stream#forEach(Consumer)). Streams are lazy; computation on the source data is only performed when the terminal operation is initiated, and source elements are consumed only as needed.

Collections and streams, while bearing some superficial similarities, have different goals. Collections are primarily concerned with the efficient management of, and access to, their elements. By contrast, streams do not provide a means to directly access or manipulate their elements, and are instead concerned with declaratively describing their source and the computational operations which will be performed in aggregate on that source. However, if the provided stream operations do not offer the desired functionality, the iterator() and #spliterator() operations can be used to perform a controlled traversal.

A stream pipeline, like the "widgets" example above, can be viewed as a query on the stream source. Unless the source was explicitly designed for concurrent modification (such as a ConcurrentHashMap), unpredictable or erroneous behavior may result from modifying the stream source while it is being queried.

Most stream operations accept parameters that describe user-specified behavior, such as the lambda expression w -> w.getWeight() passed to mapToInt in the example above. To preserve correct behavior, these behavioral parameters:

• must be non-interfering (they do not modify the stream source); and
• in most cases must be stateless (their result should not depend on any state that might change during execution of the stream pipeline).

Such parameters are always instances of a functional interface such as Function, and are often lambda expressions or method references. Unless otherwise specified these parameters must be non-null.

A stream should be operated on (invoking an intermediate or terminal stream operation) only once. This rules out, for example, "forked" streams, where the same source feeds two or more pipelines, or multiple traversals of the same stream. A stream implementation may throw IllegalStateException if it detects that the stream is being reused. However, since some stream operations may return their receiver rather than a new stream object, it may not be possible to detect reuse in all cases.

Streams have a close() method and implement AutoCloseable, but nearly all stream instances do not actually need to be closed after use. Generally, only streams whose source is an IO channel (such as those returned by Files.lines(Path, Charset)) will require closing. Most streams are backed by collections, arrays, or generating functions, which require no special resource management. (If a stream does require closing, it can be declared as a resource in a try-with-resources statement.)

See Also:

IntStream, LongStream, DoubleStream

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Stream.LAIO LAIO = Loading All Intermediate Operations.
static class	Stream.LRNO LAIO = Loading Right Now Operations.
static class	Stream.PSO PSO = Parallel supported Operations.
static class	Stream.SOO SOO = Sequential Only Operations.
static class	Stream.StreamEx<T>

Nested classes/interfaces inherited from interface com.landawn.abacus.util.stream.BaseStream

BaseStream.Splitor

Method Summary

Modifier and Type	Method and Description
<R> R	__(Function<? super Stream<T>,R> transfer)
abstract <E extends java.lang.Exception> boolean	allMatch(Try.Predicate<? super T,E> predicate)
abstract <U,E extends java.lang.Exception> boolean	allMatch(U seed, Try.BiPredicate<? super T,? super U,E> predicate)
abstract <E extends java.lang.Exception> boolean	anyMatch(Try.Predicate<? super T,E> predicate)
abstract <U,E extends java.lang.Exception> boolean	anyMatch(U seed, Try.BiPredicate<? super T,? super U,E> predicate)
abstract Stream<T>	append(java.util.Collection<? extends T> c)
Stream<T>	append(T... a)
abstract OptionalDouble	averageDouble(ToDoubleFunction<? super T> mapper)
abstract OptionalDouble	averageInt(ToIntFunction<? super T> mapper)
abstract OptionalDouble	averageLong(ToLongFunction<? super T> mapper)
abstract Stream<T>	cached(IntFunction<T[]> generator) Returns a reusable stream which can be repeatedly used.
S	carry(C action) Same as peek
abstract Stream<java.util.List<T>>	cartesianProduct(java.util.Collection<? extends java.util.Collection<? extends T>> cs)
Stream<java.util.List<T>>	cartesianProduct(java.util.Collection<? extends T>... cs)
void	close() Closes this stream, causing all close handlers for this stream pipeline to be called.
abstract Stream<T>	collapse(BiPredicate<? super T,? super T> collapsible, BiFunction<? super T,? super T,T> mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract <R,A> Stream<R>	collapse(BiPredicate<? super T,? super T> collapsible, Collector<? super T,A,R> collector) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract <R,A> R	collect(Collector<? super T,A,R> collector) Performs a mutable reduction operation on the elements of this stream using a Collector.
abstract <R,A> R	collect(java.util.stream.Collector<? super T,A,R> collector)
abstract <R> R	collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator) The result will be merged by: a.addAll(b) if result container is Collection/Multiset/LongMultiset/IntList/CharList/..., or a.putAll(b) if result container is Map/Multimap/Sheet, or a.append(b) if result container is StringBuilder when it's necessary in Parallel Stream.
abstract <R> R	collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner) Performs a mutable reduction operation on the elements of this stream.
abstract <R,A,RR> RR	collectAndThen(Collector<? super T,A,R> downstream, Function<R,RR> finisher)
abstract <R,A,RR> RR	collectAndThen(java.util.stream.Collector<? super T,A,R> downstream, Function<R,RR> finisher)
abstract Stream<java.util.List<T>>	combinations() Stream.of(1, 2, 3).combinations().forEach(Fn.println()); // output [] [1] [2] [3] [1, 2] [1, 3] [2, 3] [1, 2, 3]
abstract Stream<java.util.List<T>>	combinations(int len) Stream.of(1, 2, 3).combinations(2).forEach(Fn.println()); // output [1, 2] [1, 3] [2, 3]
abstract Stream<java.util.List<T>>	combinations(int len, boolean repeat) It's same as N.cartesianProduct(N.repeat(toList(), len)) if repeat is true.
static <T> Stream<T>	concat(java.util.Collection<? extends Stream<? extends T>> c)
static <T> Stream<T>	concat(java.util.Collection<? extends T>... a)
static <T> Stream<T>	concat(java.util.Iterator<? extends T>... a)
static <T> Stream<T>	concat(Stream<? extends T>... a)
static <T> Stream<T>	concat(T[]... a)
static <T> Stream<T>	concatt(java.util.Collection<? extends java.util.Iterator<? extends T>> c)
abstract boolean	containsAll(java.util.Collection<? extends T> c)
abstract boolean	containsAll(T... a)
<K> Stream<java.util.Map.Entry<K,java.lang.Integer>>	countBy(Function<? super T,? extends K> classifier)
<K> EntryStream<K,java.lang.Integer>	countByToEntry(Function<? super T,? extends K> classifier)
abstract Stream<T>	difference(Function<? super T,?> mapper, java.util.Collection<?> c) Except with the specified Collection by the values mapped by mapper.
Stream<T>	distinct(Predicate<? super java.lang.Long> occurrencesFilter) Distinct and filter by occurrences.
abstract Stream<T>	distinctBy(Function<? super T,?> keyExtractor) Distinct by the value mapped from keyExtractor
<K> Stream<T>	distinctBy(Function<? super T,K> keyExtractor, Predicate<? super java.lang.Long> occurrencesFilter) Distinct and filter by occurrences.
abstract <U> Stream<T>	dropWhile(U seed, BiPredicate<? super T,? super U> predicate)
abstract <U> Stream<T>	dropWhile(U seed, BiPredicate<? super T,? super U> predicate, Consumer<? super T> consumer) Returns a stream consisting of the remaining elements of this stream after removing and consuming until the specified predicate return false.
static <T> Stream<T>	empty()
abstract <U> Stream<T>	filter(U seed, BiPredicate<? super T,? super U> predicate)
abstract <E extends java.lang.Exception> Optional<T>	findAny(Try.Predicate<? super T,E> predicate)
abstract <U,E extends java.lang.Exception> Optional<T>	findAny(U seed, Try.BiPredicate<? super T,? super U,E> predicate)
abstract <E extends java.lang.Exception> Optional<T>	findFirst(Try.Predicate<? super T,E> predicate)
abstract <U,E extends java.lang.Exception> Optional<T>	findFirst(U seed, Try.BiPredicate<? super T,? super U,E> predicate)
abstract <U,E extends java.lang.Exception,E2 extends java.lang.Exception> Optional<T>	findFirstOrLast(Function<? super T,U> preFunc, Try.BiPredicate<? super T,? super U,E> predicateForFirst, Try.BiPredicate<? super T,? super U,E2> predicateForLast) This method only run sequentially, even in parallel stream.
abstract <E extends java.lang.Exception,E2 extends java.lang.Exception> Optional<T>	findFirstOrLast(Try.Predicate<? super T,E> predicateForFirst, Try.Predicate<? super T,E2> predicateForLast)
abstract <U,E extends java.lang.Exception,E2 extends java.lang.Exception> Optional<T>	findFirstOrLast(U seed, Try.BiPredicate<? super T,? super U,E> predicateForFirst, Try.BiPredicate<? super T,? super U,E2> predicateForLast) This method only run sequentially, even in parallel stream.
abstract <E extends java.lang.Exception> Optional<T>	findLast(Try.Predicate<? super T,E> predicate)
abstract <U,E extends java.lang.Exception> Optional<T>	findLast(U seed, Try.BiPredicate<? super T,? super U,E> predicate)
abstract <R> Stream<R>	flatMap(Function<? super T,? extends Stream<? extends R>> mapper) Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
abstract <U,R> Stream<R>	flatMap(U seed, BiFunction<? super T,? super U,? extends Stream<? extends R>> mapper)
abstract <R> Stream<R>	flatMapp(Function<? super T,R[]> mapper)
abstract <U,R> Stream<R>	flatMapp(U seed, BiFunction<? super T,? super U,R[]> mapper)
abstract <K,V> EntryStream<K,V>	flatMappToEntry(Function<? super T,? extends EntryStream<K,V>> mapper)
abstract ByteStream	flatMapToByte(Function<? super T,? extends ByteStream> mapper)
abstract CharStream	flatMapToChar(Function<? super T,? extends CharStream> mapper)
abstract DoubleStream	flatMapToDouble(Function<? super T,? extends DoubleStream> mapper) Returns an DoubleStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
abstract <K,V> EntryStream<K,V>	flatMapToEntry(Function<? super T,? extends Stream<? extends java.util.Map.Entry<K,V>>> mapper)
abstract FloatStream	flatMapToFloat(Function<? super T,? extends FloatStream> mapper)
abstract IntStream	flatMapToInt(Function<? super T,? extends IntStream> mapper) Returns an IntStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
abstract LongStream	flatMapToLong(Function<? super T,? extends LongStream> mapper) Returns an LongStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
abstract ShortStream	flatMapToShort(Function<? super T,? extends ShortStream> mapper)
abstract <R> Stream<R>	flattMap(Function<? super T,? extends java.util.Collection<? extends R>> mapper)
abstract <U,R> Stream<R>	flattMap(U seed, BiFunction<? super T,? super U,? extends java.util.Collection<? extends R>> mapper)
abstract <K,V> EntryStream<K,V>	flattMapToEntry(Function<? super T,? extends java.util.Map<K,V>> mapper)
abstract <E extends java.lang.Exception> void	forEach(Try.Consumer<? super T,E> action)
abstract <E extends java.lang.Exception> void	forEachPair(Try.BiConsumer<? super T,? super T,E> action)
abstract <E extends java.lang.Exception> void	forEachPair(Try.BiConsumer<? super T,? super T,E> action, int increment) Slide with windowSize = 2 and the specified increment, then consume by the specified mapper.
abstract <E extends java.lang.Exception> void	forEachTriple(Try.TriConsumer<? super T,? super T,? super T,E> action)
abstract <E extends java.lang.Exception> void	forEachTriple(Try.TriConsumer<? super T,? super T,? super T,E> action, int increment) Slide with windowSize = 3 and the specified increment, then consume by the specified mapper.
abstract <U> Stream<Pair<T,U>>	fullJoin(java.util.Collection<U> b, BiPredicate<? super T,? super U> predicate) The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.
abstract <U> Stream<Pair<T,U>>	fullJoin(java.util.Collection<U> b, Function<? super T,?> leftKeyMapper, Function<? super U,?> rightKeyMapper) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
static <T> Stream<T>	generate(Supplier<T> s)
abstract <K> Stream<java.util.Map.Entry<K,java.util.List<T>>>	groupBy(Function<? super T,? extends K> classifier)
abstract <K,A,D> Stream<java.util.Map.Entry<K,D>>	groupBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
abstract <K,A,D> Stream<java.util.Map.Entry<K,D>>	groupBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream, Supplier<? extends java.util.Map<K,D>> mapFactory)
abstract <K,U> Stream<java.util.Map.Entry<K,java.util.List<U>>>	groupBy(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper)
abstract <K,U,A,D> Stream<java.util.Map.Entry<K,D>>	groupBy(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper, Collector<? super U,A,D> downstream)
abstract <K,U,A,D> Stream<java.util.Map.Entry<K,D>>	groupBy(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper, Collector<? super U,A,D> downstream, Supplier<? extends java.util.Map<K,D>> mapFactory)
abstract <K,U> Stream<java.util.Map.Entry<K,java.util.List<U>>>	groupBy(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper, Supplier<? extends java.util.Map<K,java.util.List<U>>> mapFactory)
abstract <K,V> Stream<java.util.Map.Entry<K,V>>	groupBy(Function<? super T,? extends K> classifier, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
abstract <K,V> Stream<java.util.Map.Entry<K,V>>	groupBy(Function<? super T,? extends K> classifier, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends java.util.Map<K,V>> mapFactory)
abstract <K> Stream<java.util.Map.Entry<K,java.util.List<T>>>	groupBy(Function<? super T,? extends K> classifier, Supplier<? extends java.util.Map<K,java.util.List<T>>> mapFactory)
abstract <K> EntryStream<K,java.util.List<T>>	groupByToEntry(Function<? super T,? extends K> classifier)
abstract <K,A,D> EntryStream<K,D>	groupByToEntry(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
abstract <K,A,D> EntryStream<K,D>	groupByToEntry(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream, Supplier<? extends java.util.Map<K,D>> mapFactory)
abstract <K,U> EntryStream<K,java.util.List<U>>	groupByToEntry(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper)
abstract <K,U> EntryStream<K,U>	groupByToEntry(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
abstract <K,U,A,D> EntryStream<K,D>	groupByToEntry(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper, Collector<? super U,A,D> downstream)
abstract <K,U,A,D> EntryStream<K,D>	groupByToEntry(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper, Collector<? super U,A,D> downstream, Supplier<? extends java.util.Map<K,D>> mapFactory)
abstract <K,U> EntryStream<K,java.util.List<U>>	groupByToEntry(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper, Supplier<? extends java.util.Map<K,java.util.List<U>>> mapFactory)
abstract <K,V> EntryStream<K,V>	groupByToEntry(Function<? super T,? extends K> classifier, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends java.util.Map<K,V>> mapFactory)
abstract <K> EntryStream<K,java.util.List<T>>	groupByToEntry(Function<? super T,? extends K> classifier, Supplier<? extends java.util.Map<K,java.util.List<T>>> mapFactory)
abstract <K> java.util.Map<K,java.util.List<T>>	groupTo(Function<? super T,? extends K> classifier)
abstract <K,U> java.util.Map<K,java.util.List<U>>	groupTo(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends U> valueMapper)
abstract <K,U,M extends java.util.Map<K,java.util.List<U>>> M	groupTo(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends U> valueMapper, Supplier<M> mapFactory)
abstract <K,M extends java.util.Map<K,java.util.List<T>>> M	groupTo(Function<? super T,? extends K> classifier, Supplier<M> mapFactory)
abstract boolean	hasDuplicates()
abstract Optional<T>	head() Head and tail should be used by pair.
abstract Pair<Optional<T>,Stream<T>>	headAndTail()
abstract Pair<Stream<T>,Optional<T>>	headAndTaill() Deprecated.
abstract Stream<T>	headd() Deprecated.
abstract <U> Stream<Pair<T,U>>	innerJoin(java.util.Collection<U> b, BiPredicate<? super T,? super U> predicate) The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.
abstract <U> Stream<Pair<T,U>>	innerJoin(java.util.Collection<U> b, Function<? super T,?> leftKeyMapper, Function<? super U,?> rightKeyMapper) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
abstract Stream<T>	intersection(Function<? super T,?> mapper, java.util.Collection<?> c) Intersect with the specified Collection by the values mapped by mapper.
abstract Stream<T>	intersperse(T delimiter) Stream.of(1).intersperse(9) --> [1] Stream.of(1, 2, 3).intersperse(9) --> [1, 9, 2, 9, 3] This method only run sequentially, even in parallel stream.
static <T> Stream<T>	interval(long intervalInMillis, LongFunction<T> s)
static <T> Stream<T>	interval(long delayInMillis, long intervalInMillis, LongFunction<T> s)
static <T> Stream<T>	interval(long delayInMillis, long intervalInMillis, Supplier<T> s)
static <T> Stream<T>	interval(long delay, long interval, java.util.concurrent.TimeUnit unit, LongFunction<T> s)
static <T> Stream<T>	interval(long delay, long interval, java.util.concurrent.TimeUnit unit, Supplier<T> s)
static <T> Stream<T>	interval(long intervalInMillis, Supplier<T> s)
boolean	isParallel() Returns whether this stream, if a terminal operation were to be executed, would execute in parallel.
static <T> Stream<T>	iterate(BooleanSupplier hasNext, Supplier<? extends T> next)
static <T> Stream<T>	iterate(T seed, BooleanSupplier hasNext, UnaryOperator<T> f) Returns a sequential ordered Stream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
static <T> Stream<T>	iterate(T seed, Predicate<T> hasNext, UnaryOperator<T> f)
static <T> Stream<T>	iterate(T seed, UnaryOperator<T> f)
ObjIterator<T>	iterator() Returns an iterator for the elements of this stream.
static <T> Stream<T>	just(T a)
abstract Optional<T>	kthLargest(int k, java.util.Comparator<? super T> comparator)
abstract Stream<T>	last(int n) A queue with size up to n will be maintained to filter out the last n elements.
abstract <U> Stream<Pair<T,U>>	leftJoin(java.util.Collection<U> b, BiPredicate<? super T,? super U> predicate) The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.
abstract <U> Stream<Pair<T,U>>	leftJoin(java.util.Collection<U> b, Function<? super T,?> leftKeyMapper, Function<? super U,?> rightKeyMapper) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
static Stream<java.io.File>	list(java.io.File parentPath)
static Stream<java.io.File>	list(java.io.File parentPath, boolean recursively)
abstract <R> Stream<R>	map(Function<? super T,? extends R> mapper) Returns a stream consisting of the results of applying the given function to the elements of this stream.
abstract <U,R> Stream<R>	map(U seed, BiFunction<? super T,? super U,? extends R> mapper)
abstract Stream<T>	mapFirst(Function<? super T,? extends T> mapperForFirst)
abstract <R> Stream<R>	mapFirstOrElse(Function<? super T,? extends R> mapperForFirst, Function<? super T,? extends R> mapperForElse)
abstract Stream<T>	mapLast(Function<? super T,? extends T> mapperForLast)
abstract <R> Stream<R>	mapLastOrElse(Function<? super T,? extends R> mapperForLast, Function<? super T,? extends R> mapperForElse)
abstract ByteStream	mapToByte(ToByteFunction<? super T> mapper)
abstract CharStream	mapToChar(ToCharFunction<? super T> mapper)
abstract DoubleStream	mapToDouble(ToDoubleFunction<? super T> mapper) Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.
abstract <K,V> EntryStream<K,V>	mapToEntry(Function<? super T,? extends java.util.Map.Entry<K,V>> mapper)
abstract <K,V> EntryStream<K,V>	mapToEntry(Function<? super T,K> keyMapper, Function<? super T,V> valueMapper)
abstract <K,V> EntryStream<K,V>	mapToEntryER(Function<? super T,K> keyMapper, Function<? super T,V> valueMapper) To reduce the memory footprint, Only one instance of Map.Entry is created, and the same entry instance is returned and set with different keys/values during iteration of the returned stream.
abstract FloatStream	mapToFloat(ToFloatFunction<? super T> mapper)
abstract IntStream	mapToInt(ToIntFunction<? super T> mapper) Returns an IntStream consisting of the results of applying the given function to the elements of this stream.
abstract LongStream	mapToLong(ToLongFunction<? super T> mapper) Returns a LongStream consisting of the results of applying the given function to the elements of this stream.
abstract ShortStream	mapToShort(ToShortFunction<? super T> mapper)
abstract Optional<T>	max(java.util.Comparator<? super T> comparator) Returns the maximum element of this stream according to the provided Comparator.
Optional<T>	maxBy(Function<? super T,? extends java.lang.Comparable> keyExtractor)
int	maxThreadNum() Return the underlying maxThreadNum if the stream is parallel, otherwise 1 is returned.
S	maxThreadNum(int maxThreadNum) Returns a parallel stream with the specified maxThreadNum .
static <T> Stream<T>	merge(java.util.Collection<? extends Stream<? extends T>> c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	merge(java.util.Collection<? extends T> a, java.util.Collection<? extends T> b, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	merge(java.util.Collection<? extends T> a, java.util.Collection<? extends T> b, java.util.Collection<? extends T> c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	merge(java.util.Iterator<? extends T> a, java.util.Iterator<? extends T> b, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	merge(java.util.Iterator<? extends T> a, java.util.Iterator<? extends T> b, java.util.Iterator<? extends T> c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
abstract Stream<T>	merge(Stream<? extends T> b, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	merge(Stream<? extends T> a, Stream<? extends T> b, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	merge(Stream<? extends T> a, Stream<? extends T> b, Stream<? extends T> c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	merge(T[] a, T[] b, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	merge(T[] a, T[] b, T[] c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	mergge(java.util.Collection<? extends java.util.Iterator<? extends T>> c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
abstract Optional<T>	min(java.util.Comparator<? super T> comparator) Returns the minimum element of this stream according to the provided Comparator.
Optional<T>	minBy(Function<? super T,? extends java.lang.Comparable> keyExtractor)
abstract <E extends java.lang.Exception> boolean	noneMatch(Try.Predicate<? super T,E> predicate)
abstract <U,E extends java.lang.Exception> boolean	noneMatch(U seed, Try.BiPredicate<? super T,? super U,E> predicate)
static <T> Stream<T>	observe(java.util.concurrent.BlockingQueue<T> queue, Duration duration)
static <T> Stream<T>	observe(java.util.concurrent.BlockingQueue<T> queue, Predicate<? super T> isLast, long maxWaitIntervalInMillis)
static Stream<java.lang.Boolean>	of(boolean[] a)
static Stream<java.lang.Boolean>	of(boolean[] a, int fromIndex, int toIndex)
static Stream<java.lang.Byte>	of(byte[] a)
static Stream<java.lang.Byte>	of(byte[] a, int fromIndex, int toIndex)
static Stream<java.lang.Character>	of(char[] a)
static Stream<java.lang.Character>	of(char[] a, int fromIndex, int toIndex)
static <T> Stream<T>	of(java.lang.Class<T> targetClass, java.sql.ResultSet resultSet) It's user's responsibility to close the input resultSet after the stream is finished.
static <T> Try<Stream<T>>	of(java.lang.Class<T> targetClass, java.sql.ResultSet resultSet, boolean closeResultSet)
static <T> Stream<T>	of(java.lang.Class<T> targetClass, RowIterator rowIterator) It's user's responsibility to close the input rowIterator after the stream is finished.
static <T> Try<Stream<T>>	of(java.lang.Class<T> targetClass, RowIterator rowIterator, boolean closeRowIterator)
static <T> Stream<T>	of(java.util.Collection<? extends T> c) Returns a sequential, stateful and immutable Stream.
static <T> Stream<T>	of(java.util.Collection<? extends T> c, int startIndex, int endIndex) Returns a sequential, stateful and immutable Stream.
static Stream<java.lang.Double>	of(double[] a)
static Stream<java.lang.Double>	of(double[] a, int fromIndex, int toIndex)
static Try<Stream<java.lang.String>>	of(java.io.File file)
static Try<Stream<java.lang.String>>	of(java.io.File file, java.nio.charset.Charset charset)
static Stream<java.lang.Float>	of(float[] a)
static Stream<java.lang.Float>	of(float[] a, int fromIndex, int toIndex)
static Stream<java.lang.Integer>	of(int[] a)
static Stream<java.lang.Integer>	of(int[] a, int fromIndex, int toIndex)
static <T> Stream<T>	of(java.lang.Iterable<? extends T> iterable)
static <T> Stream<T>	of(java.util.Iterator<? extends T> iterator) Returns a sequential, stateful and immutable Stream.
static Stream<java.lang.Long>	of(long[] a)
static Stream<java.lang.Long>	of(long[] a, int fromIndex, int toIndex)
static <K,V> Stream<java.util.Map.Entry<K,V>>	of(java.util.Map<K,V> map)
static Try<Stream<java.lang.String>>	of(java.nio.file.Path path)
static Try<Stream<java.lang.String>>	of(java.nio.file.Path path, java.nio.charset.Charset charset)
static Stream<java.lang.String>	of(java.io.Reader reader) It's user's responsibility to close the input reader after the stream is finished.
static Stream<java.lang.Object[]>	of(java.sql.ResultSet resultSet) It's user's responsibility to close the input resultSet after the stream is finished.
static Try<Stream<java.lang.Object[]>>	of(java.sql.ResultSet resultSet, boolean closeResultSet)
static <T> Stream<T>	of(java.sql.ResultSet resultSet, int columnIndex) It's user's responsibility to close the input resultSet after the stream is finished.
static <T> Try<Stream<T>>	of(java.sql.ResultSet resultSet, int columnIndex, boolean closeResultSet)
static <T> Stream<T>	of(java.sql.ResultSet resultSet, java.lang.String columnName) It's user's responsibility to close the input resultSet after the stream is finished.
static <T> Try<Stream<T>>	of(java.sql.ResultSet resultSet, java.lang.String columnName, boolean closeResultSet)
static Stream<java.lang.Object[]>	of(RowIterator rowIterator) It's user's responsibility to close the input rowIterator after the stream is finished.
static Try<Stream<java.lang.Object[]>>	of(RowIterator rowIterator, boolean closeRowIterator)
static Stream<java.lang.Short>	of(short[] a)
static Stream<java.lang.Short>	of(short[] a, int fromIndex, int toIndex)
static <T> Stream<T>	of(java.util.stream.Stream<T> stream)
static <T> Stream<T>	of(Supplier<java.util.Collection<? extends T>> supplier) Lazy evaluation.
static <T> Stream<T>	of(T... a)
static <T> Stream<T>	of(T[] a, int startIndex, int endIndex) Returns a sequential, stateful and immutable Stream.
static <T> Stream<T>	ofKeys(java.util.Map<T,?> map)
static <T,V> Stream<T>	ofKeys(java.util.Map<T,V> map, Predicate<? super V> valueFilter)
static <T> Stream<T>	ofNullable(T t)
static <T> Stream<T>	ofValues(java.util.Map<?,T> map)
static <K,T> Stream<T>	ofValues(java.util.Map<K,T> map, Predicate<? super K> keyFilter)
abstract Stream<java.util.List<T>>	orderedPermutations() Stream.of(1, 2, 3).orderedPermutations().forEach(Fn.println()); // output [1, 2, 3] [1, 3, 2] [2, 1, 3] [2, 3, 1] [3, 1, 2] [3, 2, 1]
abstract Stream<java.util.List<T>>	orderedPermutations(java.util.Comparator<? super T> comparator)
S	parallel() Returns an equivalent stream that is parallel.
S	parallel(BaseStream.Splitor splitor) Returns an equivalent stream that is parallel.
S	parallel(int maxThreadNum) Returns an equivalent stream that is parallel.
static <T> Stream<T>	parallelConcat(java.util.Collection<? extends Stream<? extends T>> c) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }
static <T> Stream<T>	parallelConcat(java.util.Collection<? extends Stream<? extends T>> c, int readThreadNum) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }
static <T> Stream<T>	parallelConcat(java.util.Collection<? extends Stream<? extends T>> c, int readThreadNum, int queueSize) Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterators in parallel.
static <T> Stream<T>	parallelConcat(java.util.Iterator<? extends T>... a) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }
static <T> Stream<T>	parallelConcat(java.util.Iterator<? extends T>[] a, int readThreadNum, int queueSize) Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterators in parallel.
static <T> Stream<T>	parallelConcat(Stream<? extends T>... a) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }
static <T> Stream<T>	parallelConcat(Stream<? extends T>[] a, int readThreadNum, int queueSize) Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterators in parallel.
static <T> Stream<T>	parallelConcatt(java.util.Collection<? extends java.util.Iterator<? extends T>> c) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }
static <T> Stream<T>	parallelConcatt(java.util.Collection<? extends java.util.Iterator<? extends T>> c, int readThreadNum) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }
static <T> Stream<T>	parallelConcatt(java.util.Collection<? extends java.util.Iterator<? extends T>> c, int readThreadNum, int queueSize) Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterators in parallel.
static <T> Stream<T>	parallelMerge(java.util.Collection<? extends Stream<? extends T>> c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	parallelMerge(java.util.Collection<? extends Stream<? extends T>> c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector, int maxThreadNum)
static <T> Stream<T>	parallelMergge(java.util.Collection<? extends java.util.Iterator<? extends T>> c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)
static <T> Stream<T>	parallelMergge(java.util.Collection<? extends java.util.Iterator<? extends T>> c, BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector, int maxThreadNum)
static <T,R> Stream<R>	parallelZip(java.util.Collection<? extends Stream<? extends T>> c, Function<? super java.util.List<? extends T>,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <T,R> Stream<R>	parallelZip(java.util.Collection<? extends Stream<? extends T>> c, Function<? super java.util.List<? extends T>,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <T,R> Stream<R>	parallelZip(java.util.Collection<? extends Stream<? extends T>> c, java.lang.Object[] valuesForNone, Function<? super java.util.List<? extends T>,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <T,R> Stream<R>	parallelZip(java.util.Collection<? extends Stream<? extends T>> c, java.lang.Object[] valuesForNone, Function<? super java.util.List<? extends T>,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,R> Stream<R>	parallelZip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,R> Stream<R>	parallelZip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,R> Stream<R>	parallelZip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, BiFunction<? super A,? super B,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,R> Stream<R>	parallelZip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, BiFunction<? super A,? super B,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,C,R> Stream<R>	parallelZip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, java.util.Iterator<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,C,R> Stream<R>	parallelZip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, java.util.Iterator<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,C,R> Stream<R>	parallelZip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, java.util.Iterator<? extends C> c, TriFunction<? super A,? super B,? super C,R> zipFunction)
static <A,B,C,R> Stream<R>	parallelZip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, java.util.Iterator<? extends C> c, TriFunction<? super A,? super B,? super C,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,R> Stream<R>	parallelZip(Stream<A> a, Stream<B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,R> Stream<R>	parallelZip(Stream<A> a, Stream<B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,R> Stream<R>	parallelZip(Stream<A> a, Stream<B> b, BiFunction<? super A,? super B,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,R> Stream<R>	parallelZip(Stream<A> a, Stream<B> b, BiFunction<? super A,? super B,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,C,R> Stream<R>	parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,C,R> Stream<R>	parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <A,B,C,R> Stream<R>	parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, TriFunction<? super A,? super B,? super C,R> zipFunction)
static <A,B,C,R> Stream<R>	parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, TriFunction<? super A,? super B,? super C,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <T,R> Stream<R>	parallelZipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c, Function<? super java.util.List<? extends T>,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <T,R> Stream<R>	parallelZipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c, Function<? super java.util.List<? extends T>,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <T,R> Stream<R>	parallelZipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c, java.lang.Object[] valuesForNone, Function<? super java.util.List<? extends T>,R> zipFunction) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
static <T,R> Stream<R>	parallelZipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c, java.lang.Object[] valuesForNone, Function<? super java.util.List<? extends T>,R> zipFunction, int queueSize) Put the stream in try-catch to stop the back-end reading thread if error happens try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }
abstract Stream<java.util.Map.Entry<java.lang.Boolean,java.util.List<T>>>	partitionBy(Predicate<? super T> predicate)
abstract <A,D> Stream<java.util.Map.Entry<java.lang.Boolean,D>>	partitionBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
abstract EntryStream<java.lang.Boolean,java.util.List<T>>	partitionByToEntry(Predicate<? super T> predicate)
abstract <A,D> EntryStream<java.lang.Boolean,D>	partitionByToEntry(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
abstract java.util.Map<java.lang.Boolean,java.util.List<T>>	partitionTo(Predicate<? super T> predicate)
abstract <A,D> java.util.Map<java.lang.Boolean,D>	partitionTo(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
abstract Stream<T>	peekFirst(Consumer<? super T> action)
abstract Stream<T>	peekLast(Consumer<? super T> action)
abstract Optional<java.util.Map<com.landawn.abacus.util.Percentage,T>>	percentiles(java.util.Comparator<? super T> comparator)
abstract Stream<java.util.List<T>>	permutations() Stream.of(1, 2, 3).permutations().forEach(Fn.println()); // output [1, 2, 3] [1, 3, 2] [3, 1, 2] [3, 2, 1] [2, 3, 1] [2, 1, 3]
abstract long	persist(java.sql.Connection conn, java.lang.String insertSQL, int batchSize, int batchInterval, Try.BiConsumer<? super java.sql.PreparedStatement,? super T,java.sql.SQLException> stmtSetter)
abstract <E extends java.lang.Exception> long	persist(java.io.File file, Try.Function<? super T,java.lang.String,E> toLine)
abstract <E extends java.lang.Exception> long	persist(java.io.OutputStream os, Try.Function<? super T,java.lang.String,E> toLine)
abstract long	persist(java.sql.PreparedStatement stmt, int batchSize, int batchInterval, Try.BiConsumer<? super java.sql.PreparedStatement,? super T,java.sql.SQLException> stmtSetter)
abstract <E extends java.lang.Exception> long	persist(java.io.Writer writer, Try.Function<? super T,java.lang.String,E> toLine)
abstract Stream<T>	prepend(java.util.Collection<? extends T> c)
Stream<T>	prepend(T... a)
void	println()
abstract Stream<T>	queued()
abstract Stream<T>	queued(int queueSize) Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterator asynchronously.
abstract <U> Stream<U>	rangeMap(BiPredicate<? super T,? super T> sameRange, BiFunction<? super T,? super T,? extends U> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamex Returns a stream consisting of results of applying the given function to the ranges created from the source elements.
abstract Optional<T>	reduce(BinaryOperator<T> accumulator) Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any.
abstract T	reduce(T identity, BinaryOperator<T> accumulator) Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
abstract <U> U	reduce(U identity, BiFunction<U,? super T,U> accumulator) Deprecated.
abstract <U> U	reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner) Performs a reduction on the elements of this stream, using the provided identity, accumulation and combining functions.
abstract <U> Stream<T>	removeIf(U seed, BiPredicate<? super T,? super U> predicate)
abstract <U> Stream<T>	removeIf(U seed, BiPredicate<? super T,? super U> predicate, Consumer<? super T> consumer)
static <T> Stream<T>	repeat(T element, long n)
abstract <U> Stream<Pair<T,U>>	rightJoin(java.util.Collection<U> b, BiPredicate<? super T,? super U> predicate) The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.
abstract <U> Stream<Pair<T,U>>	rightJoin(java.util.Collection<U> b, Function<? super T,?> leftKeyMapper, Function<? super U,?> rightKeyMapper) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
abstract Stream<T>	scan(BiFunction<? super T,? super T,T> accumulator) Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream.
abstract <R> Stream<R>	scan(R seed, BiFunction<? super R,? super T,R> accumulator) Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream.
<U> Stream<U>	select(java.lang.Class<U> targetType) Returns a stream consisting of the elements in this stream which are instances of given class.
S	sequential() Returns an equivalent stream that is sequential.
S	shuffled() This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
abstract Stream<T>	skipLast(int n) A queue with size up to n will be maintained to filter out the last n elements.
abstract Stream<T>	skipNull()
Stream<S>	sliding(int windowSize)
abstract <C extends java.util.Collection<T>> Stream<C>	sliding(int windowSize, IntFunction<C> collectionSupplier)
abstract <C extends java.util.Collection<T>> Stream<C>	sliding(int windowSize, int increment, IntFunction<C> collectionSupplier)
abstract <R> Stream<R>	slidingMap(BiFunction<? super T,? super T,R> mapper)
abstract <R> Stream<R>	slidingMap(BiFunction<? super T,? super T,R> mapper, int increment) Slide with windowSize = 2 and the specified increment, then map by the specified mapper.
abstract <R> Stream<R>	slidingMap(BiFunction<? super T,? super T,R> mapper, int increment, boolean ignoreNotPaired)
abstract <R> Stream<R>	slidingMap(TriFunction<? super T,? super T,? super T,R> mapper)
abstract <R> Stream<R>	slidingMap(TriFunction<? super T,? super T,? super T,R> mapper, int increment) Slide with windowSize = 3 and the specified increment, then map by the specified mapper.
abstract <R> Stream<R>	slidingMap(TriFunction<? super T,? super T,? super T,R> mapper, int increment, boolean ignoreNotPaired)
Stream<PL>	slidingToList(int windowSize)
abstract Stream<T>	sorted(java.util.Comparator<? super T> comparator) Returns a stream consisting of the elements of this stream, sorted according to the provided Comparator.
abstract Stream<T>	sortedBy(Function<? super T,? extends java.lang.Comparable> keyExtractor)
abstract Stream<T>	sortedByDouble(ToDoubleFunction<? super T> keyExtractor)
abstract Stream<T>	sortedByInt(ToIntFunction<? super T> keyExtractor)
abstract Stream<T>	sortedByLong(ToLongFunction<? super T> keyExtractor)
abstract <C extends java.util.Collection<T>> Stream<C>	split(int size, IntFunction<C> collectionSupplier) Returns Stream of Stream with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
abstract <C extends java.util.Collection<T>> Stream<C>	split(Predicate<? super T> predicate, Supplier<C> collectionSupplier)
static Stream<java.lang.String>	split(java.lang.String str, char delimiter) Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.
static Stream<java.lang.String>	split(java.lang.String str, char delimiter, boolean trim) Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.
static Stream<java.lang.String>	split(java.lang.String str, java.lang.String delimiter) Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.
static Stream<java.lang.String>	split(java.lang.String str, java.lang.String delimiter, boolean trim) Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.
abstract <U,C extends java.util.Collection<T>> Stream<C>	split(U seed, BiPredicate<? super T,? super U> predicate, Consumer<? super U> seedUpdate, Supplier<C> collectionSupplier) Split the stream by the specified predicate.
BaseStream.Splitor	splitor() Return the underlying splitor if the stream is parallel, otherwise the default value splitor.ITERATOR is returned.
S	splitor(BaseStream.Splitor splitor) Returns a parallel stream with the specified splitor .
abstract Stream<java.util.Set<T>>	splitToSet(int size) Returns Stream of Stream with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
abstract Stream<java.util.Set<T>>	splitToSet(Predicate<? super T> predicate)
abstract <U> Stream<java.util.Set<T>>	splitToSet(U seed, BiPredicate<? super T,? super U> predicate, Consumer<? super U> seedUpdate) Split the stream by the specified predicate.
abstract double	sumDouble(ToDoubleFunction<? super T> mapper)
abstract int	sumInt(ToIntFunction<? super T> mapper)
abstract long	sumLong(ToLongFunction<? super T> mapper)
abstract Stream<T>	tail() Head and tail should be used by pair.
abstract Optional<T>	taill() Deprecated.
abstract <U> Stream<T>	takeWhile(U seed, BiPredicate<? super T,? super U> predicate)
abstract <A> A[]	toArray(IntFunction<A[]> generator) Returns an array containing the elements of this stream, using the provided generator function to allocate the returned array, as well as any additional arrays that might be required for a partitioned execution or for resizing.
abstract DataSet	toDataSet()
abstract DataSet	toDataSet(boolean isFirstHeader)
abstract DataSet	toDataSet(java.util.List<java.lang.String> columnNames)
ImmutableList<T>	toImmutableList()
<K,V> ImmutableMap<K,V>	toImmutableMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueMapper)
<K,V> ImmutableMap<K,V>	toImmutableMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
ImmutableSet<T>	toImmutableSet()
abstract java.util.stream.Stream<T>	toJdkStream()
abstract <R> R	toListAndThen(Function<? super java.util.List<T>,R> func)
abstract <K,A,D> java.util.Map<K,D>	toMap(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
abstract <K,A,D,M extends java.util.Map<K,D>> M	toMap(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream, Supplier<M> mapFactory)
abstract <K,U,A,D> java.util.Map<K,D>	toMap(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper, Collector<? super U,A,D> downstream)
abstract <K,U,A,D,M extends java.util.Map<K,D>> M	toMap(Function<? super T,? extends K> classifier, Function<? super T,? extends U> valueMapper, Collector<? super U,A,D> downstream, Supplier<M> mapFactory)
abstract <K,V> java.util.Map<K,V>	toMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueMapper)
abstract <K,V> java.util.Map<K,V>	toMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
abstract <K,V,M extends java.util.Map<K,V>> M	toMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<M> mapFactory)
abstract <K,V,M extends java.util.Map<K,V>> M	toMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueMapper, Supplier<M> mapFactory)
abstract Matrix<T>	toMatrix(java.lang.Class<T> type)
abstract <K> ListMultimap<K,T>	toMultimap(Function<? super T,? extends K> keyExtractor)
abstract <K,U> ListMultimap<K,U>	toMultimap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends U> valueMapper)
abstract <K,U,V extends java.util.Collection<U>,M extends Multimap<K,U,V>> M	toMultimap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends U> valueMapper, Supplier<M> mapFactory)
abstract <K,V extends java.util.Collection<T>,M extends Multimap<K,T,V>> M	toMultimap(Function<? super T,? extends K> keyExtractor, Supplier<M> mapFactory)
abstract Stream<T>	top(int n) This method only run sequentially, even in parallel stream.
abstract Stream<T>	top(int n, java.util.Comparator<? super T> comparator) This method only run sequentially, even in parallel stream.
abstract <R> R	toSetAndThen(Function<? super java.util.Set<T>,R> func)
Try<S>	tried()
static <A,B,R> Stream<R>	zip(A[] a, B[] b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <A,B,R> Stream<R>	zip(A[] a, B[] b, BiFunction<? super A,? super B,R> zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static <A,B,C,R> Stream<R>	zip(A[] a, B[] b, C[] c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <A,B,C,R> Stream<R>	zip(A[] a, B[] b, C[] c, TriFunction<? super A,? super B,? super C,R> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	zip(byte[] a, byte[] b, byte[] c, byte valueForNoneA, byte valueForNoneB, byte valueForNoneC, ByteTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(byte[] a, byte[] b, byte[] c, ByteTriFunction<R> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	zip(byte[] a, byte[] b, ByteBiFunction<R> zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	zip(byte[] a, byte[] b, byte valueForNoneA, byte valueForNoneB, ByteBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ByteIterator a, ByteIterator b, ByteBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	zip(ByteIterator a, ByteIterator b, byte valueForNoneA, byte valueForNoneB, ByteBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ByteIterator a, ByteIterator b, ByteIterator c, byte valueForNoneA, byte valueForNoneB, byte valueForNoneC, ByteTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ByteIterator a, ByteIterator b, ByteIterator c, ByteTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	zip(ByteStream a, ByteStream b, ByteBiFunction<R> zipFunction) Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	zip(ByteStream a, ByteStream b, byte valueForNoneA, byte valueForNoneB, ByteBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ByteStream a, ByteStream b, ByteStream c, byte valueForNoneA, byte valueForNoneB, byte valueForNoneC, ByteTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ByteStream a, ByteStream b, ByteStream c, ByteTriFunction<R> zipFunction) Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	zip(char[] a, char[] b, char[] c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(char[] a, char[] b, char[] c, CharTriFunction<R> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	zip(char[] a, char[] b, CharBiFunction<R> zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	zip(char[] a, char[] b, char valueForNoneA, char valueForNoneB, CharBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(CharIterator a, CharIterator b, CharBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	zip(CharIterator a, CharIterator b, char valueForNoneA, char valueForNoneB, CharBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(CharIterator a, CharIterator b, CharIterator c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(CharIterator a, CharIterator b, CharIterator c, CharTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	zip(CharStream a, CharStream b, CharBiFunction<R> zipFunction) Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	zip(CharStream a, CharStream b, char valueForNoneA, char valueForNoneB, CharBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(CharStream a, CharStream b, CharStream c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(CharStream a, CharStream b, CharStream c, CharTriFunction<R> zipFunction) Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <A,B,R> Stream<R>	zip(java.util.Collection<? extends A> a, java.util.Collection<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <A,B,R> Stream<R>	zip(java.util.Collection<? extends A> a, java.util.Collection<? extends B> b, BiFunction<? super A,? super B,R> zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static <A,B,C,R> Stream<R>	zip(java.util.Collection<? extends A> a, java.util.Collection<? extends B> b, java.util.Collection<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <A,B,C,R> Stream<R>	zip(java.util.Collection<? extends A> a, java.util.Collection<? extends B> b, java.util.Collection<? extends C> c, TriFunction<? super A,? super B,? super C,R> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends ByteStream> c, byte[] valuesForNone, ByteNFunction<R> zipFunction) Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends ByteStream> c, ByteNFunction<R> zipFunction) Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends CharStream> c, char[] valuesForNone, CharNFunction<R> zipFunction) Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends CharStream> c, CharNFunction<R> zipFunction) Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends DoubleStream> c, double[] valuesForNone, DoubleNFunction<R> zipFunction) Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends DoubleStream> c, DoubleNFunction<R> zipFunction) Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends FloatStream> c, float[] valuesForNone, FloatNFunction<R> zipFunction) Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends FloatStream> c, FloatNFunction<R> zipFunction) Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends IntStream> c, int[] valuesForNone, IntNFunction<R> zipFunction) Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends IntStream> c, IntNFunction<R> zipFunction) Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends LongStream> c, long[] valuesForNone, LongNFunction<R> zipFunction) Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends LongStream> c, LongNFunction<R> zipFunction) Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends ShortStream> c, short[] valuesForNone, ShortNFunction<R> zipFunction) Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	zip(java.util.Collection<? extends ShortStream> c, ShortNFunction<R> zipFunction) Zip together the iterators until one of them runs out of values.
static <T,R> Stream<R>	zip(java.util.Collection<? extends Stream<? extends T>> c, Function<? super java.util.List<? extends T>,R> zipFunction) Zip together the iterators until one of them runs out of values.
static <T,R> Stream<R>	zip(java.util.Collection<? extends Stream<? extends T>> c, java.lang.Object[] valuesForNone, Function<? super java.util.List<? extends T>,R> zipFunction) Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	zip(double[] a, double[] b, double[] c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(double[] a, double[] b, double[] c, DoubleTriFunction<R> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	zip(double[] a, double[] b, DoubleBiFunction<R> zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	zip(double[] a, double[] b, double valueForNoneA, double valueForNoneB, DoubleBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(DoubleIterator a, DoubleIterator b, DoubleBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	zip(DoubleIterator a, DoubleIterator b, double valueForNoneA, double valueForNoneB, DoubleBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(DoubleIterator a, DoubleIterator b, DoubleIterator c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(DoubleIterator a, DoubleIterator b, DoubleIterator c, DoubleTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	zip(DoubleStream a, DoubleStream b, DoubleBiFunction<R> zipFunction) Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	zip(DoubleStream a, DoubleStream b, double valueForNoneA, double valueForNoneB, DoubleBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(DoubleStream a, DoubleStream b, DoubleStream c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(DoubleStream a, DoubleStream b, DoubleStream c, DoubleTriFunction<R> zipFunction) Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	zip(float[] a, float[] b, float[] c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(float[] a, float[] b, float[] c, FloatTriFunction<R> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	zip(float[] a, float[] b, FloatBiFunction<R> zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	zip(float[] a, float[] b, float valueForNoneA, float valueForNoneB, FloatBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(FloatIterator a, FloatIterator b, FloatBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	zip(FloatIterator a, FloatIterator b, float valueForNoneA, float valueForNoneB, FloatBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(FloatIterator a, FloatIterator b, FloatIterator c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(FloatIterator a, FloatIterator b, FloatIterator c, FloatTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	zip(FloatStream a, FloatStream b, FloatBiFunction<R> zipFunction) Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	zip(FloatStream a, FloatStream b, float valueForNoneA, float valueForNoneB, FloatBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(FloatStream a, FloatStream b, FloatStream c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(FloatStream a, FloatStream b, FloatStream c, FloatTriFunction<R> zipFunction) Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	zip(int[] a, int[] b, int[] c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(int[] a, int[] b, int[] c, IntTriFunction<R> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	zip(int[] a, int[] b, IntBiFunction<R> zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	zip(int[] a, int[] b, int valueForNoneA, int valueForNoneB, IntBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(IntIterator a, IntIterator b, IntBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	zip(IntIterator a, IntIterator b, int valueForNoneA, int valueForNoneB, IntBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(IntIterator a, IntIterator b, IntIterator c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(IntIterator a, IntIterator b, IntIterator c, IntTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	zip(IntStream a, IntStream b, IntBiFunction<R> zipFunction) Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	zip(IntStream a, IntStream b, int valueForNoneA, int valueForNoneB, IntBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(IntStream a, IntStream b, IntStream c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(IntStream a, IntStream b, IntStream c, IntTriFunction<R> zipFunction) Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <A,B,R> Stream<R>	zip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <A,B,R> Stream<R>	zip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, BiFunction<? super A,? super B,R> zipFunction) Zip together the "a" and "b" iterators until one of them runs out of values.
static <A,B,C,R> Stream<R>	zip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, java.util.Iterator<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <A,B,C,R> Stream<R>	zip(java.util.Iterator<? extends A> a, java.util.Iterator<? extends B> b, java.util.Iterator<? extends C> c, TriFunction<? super A,? super B,? super C,R> zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	zip(long[] a, long[] b, long[] c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(long[] a, long[] b, long[] c, LongTriFunction<R> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	zip(long[] a, long[] b, LongBiFunction<R> zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	zip(long[] a, long[] b, long valueForNoneA, long valueForNoneB, LongBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(LongIterator a, LongIterator b, LongBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	zip(LongIterator a, LongIterator b, LongIterator c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(LongIterator a, LongIterator b, LongIterator c, LongTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	zip(LongIterator a, LongIterator b, long valueForNoneA, long valueForNoneB, LongBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(LongStream a, LongStream b, LongBiFunction<R> zipFunction) Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	zip(LongStream a, LongStream b, long valueForNoneA, long valueForNoneB, LongBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(LongStream a, LongStream b, LongStream c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(LongStream a, LongStream b, LongStream c, LongTriFunction<R> zipFunction) Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	zip(short[] a, short[] b, short[] c, short valueForNoneA, short valueForNoneB, short valueForNoneC, ShortTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(short[] a, short[] b, short[] c, ShortTriFunction<R> zipFunction) Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	zip(short[] a, short[] b, ShortBiFunction<R> zipFunction) Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	zip(short[] a, short[] b, short valueForNoneA, short valueForNoneB, ShortBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ShortIterator a, ShortIterator b, ShortBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	zip(ShortIterator a, ShortIterator b, ShortIterator c, short valueForNoneA, short valueForNoneB, short valueForNoneC, ShortTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ShortIterator a, ShortIterator b, ShortIterator c, ShortTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	zip(ShortIterator a, ShortIterator b, short valueForNoneA, short valueForNoneB, ShortBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ShortStream a, ShortStream b, ShortBiFunction<R> zipFunction) Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	zip(ShortStream a, ShortStream b, short valueForNoneA, short valueForNoneB, ShortBiFunction<R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ShortStream a, ShortStream b, ShortStream c, short valueForNoneA, short valueForNoneB, short valueForNoneC, ShortTriFunction<R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	zip(ShortStream a, ShortStream b, ShortStream c, ShortTriFunction<R> zipFunction) Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <A,B,R> Stream<R>	zip(Stream<? extends A> a, Stream<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,R> zipFunction) Zip together the "a" and "b" iterators until all of them runs out of values.
static <A,B,R> Stream<R>	zip(Stream<? extends A> a, Stream<? extends B> b, BiFunction<? super A,? super B,R> zipFunction) Zip together the "a" and "b" streams until one of them runs out of values.
static <A,B,C,R> Stream<R>	zip(Stream<? extends A> a, Stream<? extends B> b, Stream<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,R> zipFunction) Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <A,B,C,R> Stream<R>	zip(Stream<? extends A> a, Stream<? extends B> b, Stream<? extends C> c, TriFunction<? super A,? super B,? super C,R> zipFunction) Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <T,R> Stream<R>	zipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c, Function<? super java.util.List<? extends T>,R> zipFunction)
static <T,R> Stream<R>	zipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c, java.lang.Object[] valuesForNone, Function<? super java.util.List<? extends T>,R> zipFunction)
abstract <T2,R> Stream<R>	zipWith(Stream<T2> b, BiFunction<? super T,? super T2,R> zipFunction)
abstract <T2,T3,R> Stream<R>	zipWith(Stream<T2> b, Stream<T3> c, TriFunction<? super T,? super T2,? super T3,R> zipFunction)
abstract <T2,T3,R> Stream<R>	zipWith(Stream<T2> b, Stream<T3> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, TriFunction<? super T,? super T2,? super T3,R> zipFunction)
abstract <T2,R> Stream<R>	zipWith(Stream<T2> b, T valueForNoneA, T2 valueForNoneB, BiFunction<? super T,? super T2,R> zipFunction)

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.landawn.abacus.util.stream.BaseStream

append, cached, count, difference, distinct, dropWhile, dropWhile, filter, first, indexed, intersection, join, join, last, limit, onClose, parallel, peek, percentiles, prepend, removeIf, removeIf, reversed, reverseSorted, rotated, shuffled, skip, skip, sliding, slidingToList, sorted, split, split, split, splitAt, splitBy, splitToList, splitToList, splitToList, step, symmetricDifference, takeWhile, toArray, toCollection, toList, toLongMultiset, toLongMultiset, toMultiset, toMultiset, toSet

Method Detail

filter

@ParallelSupported
public abstract <U> Stream<T> filter(U seed,
                                                         BiPredicate<? super T,? super U> predicate)

Parameters:

seed - initial value to check if the value match the condition.

predicate -

Returns:

takeWhile

@ParallelSupported
public abstract <U> Stream<T> takeWhile(U seed,
                                                            BiPredicate<? super T,? super U> predicate)

Parameters:

seed - initial value to check if the value match the condition.

predicate -

Returns:

dropWhile

@ParallelSupported
public abstract <U> Stream<T> dropWhile(U seed,
                                                            BiPredicate<? super T,? super U> predicate)

Parameters:

seed - initial value to check if the value match the condition.

predicate -

Returns:

dropWhile

@ParallelSupported
public abstract <U> Stream<T> dropWhile(U seed,
                                                            BiPredicate<? super T,? super U> predicate,
                                                            Consumer<? super T> consumer)

Returns a stream consisting of the remaining elements of this stream after removing and consuming until the specified predicate return false. If there is no more elements then an empty stream will be returned.

Parameters:

seed -

predicate -

consumer -

Returns:

dropWhile(Object, BiPredicate)

removeIf

@ParallelSupported
public abstract <U> Stream<T> removeIf(U seed,
                                                           BiPredicate<? super T,? super U> predicate)

removeIf

@ParallelSupported
public abstract <U> Stream<T> removeIf(U seed,
                                                           BiPredicate<? super T,? super U> predicate,
                                                           Consumer<? super T> consumer)

select

@ParallelSupported
public <U> Stream<U> select(java.lang.Class<U> targetType)

Returns a stream consisting of the elements in this stream which are instances of given class.

Parameters:

targetType -

Returns:

map

@ParallelSupported
public abstract <R> Stream<R> map(Function<? super T,? extends R> mapper)

Returns a stream consisting of the results of applying the given function to the elements of this stream.

This is an intermediate operation.

Type Parameters:

R - The element type of the new stream

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new stream

map

@ParallelSupported
public abstract <U,R> Stream<R> map(U seed,
                                                        BiFunction<? super T,? super U,? extends R> mapper)

slidingMap

@ParallelSupported
public abstract <R> Stream<R> slidingMap(BiFunction<? super T,? super T,R> mapper)

slidingMap

@ParallelSupported
public abstract <R> Stream<R> slidingMap(BiFunction<? super T,? super T,R> mapper,
                                                             int increment)

Slide with windowSize = 2 and the specified increment, then map by the specified mapper.

Parameters:

mapper -

increment -

Returns:

slidingMap

@ParallelSupported
public abstract <R> Stream<R> slidingMap(BiFunction<? super T,? super T,R> mapper,
                                                             int increment,
                                                             boolean ignoreNotPaired)

slidingMap

@ParallelSupported
public abstract <R> Stream<R> slidingMap(TriFunction<? super T,? super T,? super T,R> mapper)

slidingMap

@ParallelSupported
public abstract <R> Stream<R> slidingMap(TriFunction<? super T,? super T,? super T,R> mapper,
                                                             int increment)

Slide with windowSize = 3 and the specified increment, then map by the specified mapper.

Parameters:

mapper -

increment -

Returns:

slidingMap

@ParallelSupported
public abstract <R> Stream<R> slidingMap(TriFunction<? super T,? super T,? super T,R> mapper,
                                                             int increment,
                                                             boolean ignoreNotPaired)

rangeMap

@SequentialOnly
public abstract <U> Stream<U> rangeMap(BiPredicate<? super T,? super T> sameRange,
                                                        BiFunction<? super T,? super T,? extends U> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex
Returns a stream consisting of results of applying the given function to the ranges created from the source elements.

 
 Stream.of("a", "ab", "ac", "b", "c", "cb").rangeMap((a, b) -> b.startsWith(a), (a, b) -> a + "->" + b).toList(); // a->ac, b->b, c->cb
 
 

This is a quasi-intermediate partial reduction operation.

Type Parameters:

U - the type of the resulting elements

Parameters:

sameRange - a non-interfering, stateless predicate to apply to the leftmost and next elements which returns true for elements which belong to the same range.

mapper - a non-interfering, stateless function to apply to the range borders and produce the resulting element. If value was not merged to the interval, then mapper will receive the same value twice, otherwise it will receive the leftmost and the rightmost values which were merged to the range.

Returns:

the new stream

See Also:

#collapse(BiPredicate, BinaryOperator)

mapFirst

@ParallelSupported
public abstract Stream<T> mapFirst(Function<? super T,? extends T> mapperForFirst)

mapFirstOrElse

@ParallelSupported
public abstract <R> Stream<R> mapFirstOrElse(Function<? super T,? extends R> mapperForFirst,
                                                                 Function<? super T,? extends R> mapperForElse)

mapLast

@ParallelSupported
public abstract Stream<T> mapLast(Function<? super T,? extends T> mapperForLast)

mapLastOrElse

@ParallelSupported
public abstract <R> Stream<R> mapLastOrElse(Function<? super T,? extends R> mapperForLast,
                                                                Function<? super T,? extends R> mapperForElse)

mapToChar

@ParallelSupported
public abstract CharStream mapToChar(ToCharFunction<? super T> mapper)

mapToByte

@ParallelSupported
public abstract ByteStream mapToByte(ToByteFunction<? super T> mapper)

mapToShort

@ParallelSupported
public abstract ShortStream mapToShort(ToShortFunction<? super T> mapper)

mapToInt

@ParallelSupported
public abstract IntStream mapToInt(ToIntFunction<? super T> mapper)

Returns an IntStream consisting of the results of applying the given function to the elements of this stream.

This is an intermediate operation.

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new stream

mapToLong

@ParallelSupported
public abstract LongStream mapToLong(ToLongFunction<? super T> mapper)

Returns a LongStream consisting of the results of applying the given function to the elements of this stream.

This is an intermediate operation.

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new stream

mapToFloat

@ParallelSupported
public abstract FloatStream mapToFloat(ToFloatFunction<? super T> mapper)

mapToDouble

@ParallelSupported
public abstract DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)

Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.

This is an intermediate operation.

Parameters:

mapper - a non-interfering, stateless function to apply to each element

Returns:

the new stream

mapToEntry

@ParallelSupported
public abstract <K,V> EntryStream<K,V> mapToEntry(Function<? super T,? extends java.util.Map.Entry<K,V>> mapper)

mapToEntry

@ParallelSupported
public abstract <K,V> EntryStream<K,V> mapToEntry(Function<? super T,K> keyMapper,
                                                                      Function<? super T,V> valueMapper)

flatMap

@ParallelSupported
public abstract <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.

This is an intermediate operation.

Type Parameters:

R - The element type of the new stream

Parameters:

mapper - a non-interfering, stateless function to apply to each element which produces a stream of new values

Returns:

the new stream

flatMap

@ParallelSupported
public abstract <U,R> Stream<R> flatMap(U seed,
                                                            BiFunction<? super T,? super U,? extends Stream<? extends R>> mapper)

flattMap

@ParallelSupported
public abstract <R> Stream<R> flattMap(Function<? super T,? extends java.util.Collection<? extends R>> mapper)

flattMap

@ParallelSupported
public abstract <U,R> Stream<R> flattMap(U seed,
                                                             BiFunction<? super T,? super U,? extends java.util.Collection<? extends R>> mapper)

flatMapp

@ParallelSupported
public abstract <R> Stream<R> flatMapp(Function<? super T,R[]> mapper)

flatMapp

@ParallelSupported
public abstract <U,R> Stream<R> flatMapp(U seed,
                                                             BiFunction<? super T,? super U,R[]> mapper)

flatMapToChar

@ParallelSupported
public abstract CharStream flatMapToChar(Function<? super T,? extends CharStream> mapper)

flatMapToByte

@ParallelSupported
public abstract ByteStream flatMapToByte(Function<? super T,? extends ByteStream> mapper)

flatMapToShort

@ParallelSupported
public abstract ShortStream flatMapToShort(Function<? super T,? extends ShortStream> mapper)

flatMapToInt

@ParallelSupported
public abstract IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper)

Returns an IntStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element. Each mapped stream is closed after its contents have been placed into this stream. (If a mapped stream is null an empty stream is used, instead.)

This is an intermediate operation.

Parameters:

mapper - a non-interfering, stateless function to apply to each element which produces a stream of new values

Returns:

the new stream

See Also:

flatMap(Function)

flatMapToLong

@ParallelSupported
public abstract LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper)

Returns an LongStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element. Each mapped stream is closed after its contents have been placed into this stream. (If a mapped stream is null an empty stream is used, instead.)

This is an intermediate operation.

Parameters:

mapper - a non-interfering, stateless function to apply to each element which produces a stream of new values

Returns:

the new stream

See Also:

flatMap(Function)

flatMapToFloat

@ParallelSupported
public abstract FloatStream flatMapToFloat(Function<? super T,? extends FloatStream> mapper)

flatMapToDouble

@ParallelSupported
public abstract DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)

Returns an DoubleStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element. Each mapped stream is closed after its contents have placed been into this stream. (If a mapped stream is null an empty stream is used, instead.)

This is an intermediate operation.

Parameters:

mapper - a non-interfering, stateless function to apply to each element which produces a stream of new values

Returns:

the new stream

See Also:

flatMap(Function)

flatMapToEntry

@ParallelSupported
public abstract <K,V> EntryStream<K,V> flatMapToEntry(Function<? super T,? extends Stream<? extends java.util.Map.Entry<K,V>>> mapper)

flattMapToEntry

@ParallelSupported
public abstract <K,V> EntryStream<K,V> flattMapToEntry(Function<? super T,? extends java.util.Map<K,V>> mapper)

flatMappToEntry

@ParallelSupported
public abstract <K,V> EntryStream<K,V> flatMappToEntry(Function<? super T,? extends EntryStream<K,V>> mapper)

groupBy

@ParallelSupported
public abstract <K> Stream<java.util.Map.Entry<K,java.util.List<T>>> groupBy(Function<? super T,? extends K> classifier)

groupBy

@ParallelSupported
public abstract <K> Stream<java.util.Map.Entry<K,java.util.List<T>>> groupBy(Function<? super T,? extends K> classifier,
                                                                                                 Supplier<? extends java.util.Map<K,java.util.List<T>>> mapFactory)

groupBy

@ParallelSupported
public abstract <K,U> Stream<java.util.Map.Entry<K,java.util.List<U>>> groupBy(Function<? super T,? extends K> classifier,
                                                                                                   Function<? super T,? extends U> valueMapper)

Parameters:

classifier -

valueMapper -

Returns:

See Also:

Collectors.toMultimap(Function, Function)

groupBy

@ParallelSupported
public abstract <K,U> Stream<java.util.Map.Entry<K,java.util.List<U>>> groupBy(Function<? super T,? extends K> classifier,
                                                                                                   Function<? super T,? extends U> valueMapper,
                                                                                                   Supplier<? extends java.util.Map<K,java.util.List<U>>> mapFactory)

Parameters:

classifier -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMultimap(Function, Function, Supplier)

groupBy

@ParallelSupported
public abstract <K,A,D> Stream<java.util.Map.Entry<K,D>> groupBy(Function<? super T,? extends K> classifier,
                                                                                     Collector<? super T,A,D> downstream)

groupBy

@ParallelSupported
public abstract <K,A,D> Stream<java.util.Map.Entry<K,D>> groupBy(Function<? super T,? extends K> classifier,
                                                                                     Collector<? super T,A,D> downstream,
                                                                                     Supplier<? extends java.util.Map<K,D>> mapFactory)

groupBy

@ParallelSupported
public abstract <K,U,A,D> Stream<java.util.Map.Entry<K,D>> groupBy(Function<? super T,? extends K> classifier,
                                                                                       Function<? super T,? extends U> valueMapper,
                                                                                       Collector<? super U,A,D> downstream)

groupBy

@ParallelSupported
public abstract <K,U,A,D> Stream<java.util.Map.Entry<K,D>> groupBy(Function<? super T,? extends K> classifier,
                                                                                       Function<? super T,? extends U> valueMapper,
                                                                                       Collector<? super U,A,D> downstream,
                                                                                       Supplier<? extends java.util.Map<K,D>> mapFactory)

groupBy

@ParallelSupported
public abstract <K,V> Stream<java.util.Map.Entry<K,V>> groupBy(Function<? super T,? extends K> classifier,
                                                                                   Function<? super T,? extends V> valueMapper,
                                                                                   BinaryOperator<V> mergeFunction)

groupBy

@ParallelSupported
public abstract <K,V> Stream<java.util.Map.Entry<K,V>> groupBy(Function<? super T,? extends K> classifier,
                                                                                   Function<? super T,? extends V> valueMapper,
                                                                                   BinaryOperator<V> mergeFunction,
                                                                                   Supplier<? extends java.util.Map<K,V>> mapFactory)

partitionBy

@ParallelSupported
public abstract Stream<java.util.Map.Entry<java.lang.Boolean,java.util.List<T>>> partitionBy(Predicate<? super T> predicate)

Parameters:

predicate -

Returns:

See Also:

Collectors.partitioningBy(Predicate)

partitionBy

@ParallelSupported
public abstract <A,D> Stream<java.util.Map.Entry<java.lang.Boolean,D>> partitionBy(Predicate<? super T> predicate,
                                                                                                       Collector<? super T,A,D> downstream)

Parameters:

predicate -

downstream -

Returns:

See Also:

Collectors.partitioningBy(Predicate, Collector)

countBy

public <K> Stream<java.util.Map.Entry<K,java.lang.Integer>> countBy(Function<? super T,? extends K> classifier)

groupByToEntry

@ParallelSupported
public abstract <K> EntryStream<K,java.util.List<T>> groupByToEntry(Function<? super T,? extends K> classifier)

groupByToEntry

@ParallelSupported
public abstract <K> EntryStream<K,java.util.List<T>> groupByToEntry(Function<? super T,? extends K> classifier,
                                                                                        Supplier<? extends java.util.Map<K,java.util.List<T>>> mapFactory)

groupByToEntry

@ParallelSupported
public abstract <K,U> EntryStream<K,java.util.List<U>> groupByToEntry(Function<? super T,? extends K> classifier,
                                                                                          Function<? super T,? extends U> valueMapper)

Parameters:

classifier -

valueMapper -

Returns:

See Also:

Collectors.toMultimap(Function, Function)

groupByToEntry

@ParallelSupported
public abstract <K,U> EntryStream<K,java.util.List<U>> groupByToEntry(Function<? super T,? extends K> classifier,
                                                                                          Function<? super T,? extends U> valueMapper,
                                                                                          Supplier<? extends java.util.Map<K,java.util.List<U>>> mapFactory)

Parameters:

classifier -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMultimap(Function, Function, Supplier)

groupByToEntry

@ParallelSupported
public abstract <K,A,D> EntryStream<K,D> groupByToEntry(Function<? super T,? extends K> classifier,
                                                                            Collector<? super T,A,D> downstream)

groupByToEntry

@ParallelSupported
public abstract <K,A,D> EntryStream<K,D> groupByToEntry(Function<? super T,? extends K> classifier,
                                                                            Collector<? super T,A,D> downstream,
                                                                            Supplier<? extends java.util.Map<K,D>> mapFactory)

groupByToEntry

@ParallelSupported
public abstract <K,U,A,D> EntryStream<K,D> groupByToEntry(Function<? super T,? extends K> classifier,
                                                                              Function<? super T,? extends U> valueMapper,
                                                                              Collector<? super U,A,D> downstream)

groupByToEntry

@ParallelSupported
public abstract <K,U,A,D> EntryStream<K,D> groupByToEntry(Function<? super T,? extends K> classifier,
                                                                              Function<? super T,? extends U> valueMapper,
                                                                              Collector<? super U,A,D> downstream,
                                                                              Supplier<? extends java.util.Map<K,D>> mapFactory)

groupByToEntry

@ParallelSupported
public abstract <K,U> EntryStream<K,U> groupByToEntry(Function<? super T,? extends K> classifier,
                                                                          Function<? super T,? extends U> valueMapper,
                                                                          BinaryOperator<U> mergeFunction)

groupByToEntry

@ParallelSupported
public abstract <K,V> EntryStream<K,V> groupByToEntry(Function<? super T,? extends K> classifier,
                                                                          Function<? super T,? extends V> valueMapper,
                                                                          BinaryOperator<V> mergeFunction,
                                                                          Supplier<? extends java.util.Map<K,V>> mapFactory)

partitionByToEntry

@ParallelSupported
public abstract EntryStream<java.lang.Boolean,java.util.List<T>> partitionByToEntry(Predicate<? super T> predicate)

Parameters:

predicate -

Returns:

See Also:

Collectors.partitioningBy(Predicate)

partitionByToEntry

@ParallelSupported
public abstract <A,D> EntryStream<java.lang.Boolean,D> partitionByToEntry(Predicate<? super T> predicate,
                                                                                              Collector<? super T,A,D> downstream)

Parameters:

predicate -

downstream -

Returns:

See Also:

Collectors.partitioningBy(Predicate, Collector)

countByToEntry

public <K> EntryStream<K,java.lang.Integer> countByToEntry(Function<? super T,? extends K> classifier)

collapse

@SequentialOnly
public abstract Stream<T> collapse(BiPredicate<? super T,? super T> collapsible,
                                                    BiFunction<? super T,? super T,T> mergeFunction)

Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.

Example:

 
 Stream.of(new Integer[0]).collapse((a, b) -> a < b, (a, b) -> a + b) => []
 Stream.of(1).collapse((a, b) -> a < b, (a, b) -> a + b) => [1]
 Stream.of(1, 2).collapse((a, b) -> a < b, (a, b) -> a + b) => [3]
 Stream.of(1, 2, 3).collapse((a, b) -> a < b, (a, b) -> a + b) => [6]
 Stream.of(1, 2, 3, 3, 2, 1).collapse((a, b) -> a < b, (a, b) -> a + b) => [6, 3, 2, 1]
 
 

This method only run sequentially, even in parallel stream.

Parameters:

collapsible -

mergeFunction -

Returns:

collapse

@SequentialOnly
public abstract <R,A> Stream<R> collapse(BiPredicate<? super T,? super T> collapsible,
                                                          Collector<? super T,A,R> collector)

Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.

Example:

 
 Stream.of(new Integer[0]).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => []
 Stream.of(1).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => [1]
 Stream.of(1, 2).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => [3]
 Stream.of(1, 2, 3).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => [6]
 Stream.of(1, 2, 3, 3, 2, 1).collapse((a, b) -> a < b, Collectors.summingInt(Fn.unboxI())) => [6, 3, 2, 1]
 
 

This method only run sequentially, even in parallel stream.

Parameters:

collapsible -

collector -

Returns:

scan

@SequentialOnly
public abstract Stream<T> scan(BiFunction<? super T,? super T,T> accumulator)

Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream. Produces a Stream consisting of seed, acc(seed, value1), acc(acc(seed, value1), value2), etc.

This is an intermediate operation.

Example:

 
 Stream.of(new Integer[0]).scan((a, b) -> a + b) => []
 Stream.of(1).scan((a, b) -> a + b) => [1]
 Stream.of(1, 2).scan((a, b) -> a + b) => [1, 3]
 Stream.of(1, 2, 3).scan((a, b) -> a + b) => [1, 3, 6]
 Stream.of(1, 2, 3, 3, 2, 1).scan((a, b) -> a + b) => [1, 3, 6, 9, 11, 12]
 
 

This method only run sequentially, even in parallel stream.

Parameters:

accumulator - the accumulation function

Returns:

the new stream which has the extract same size as this stream.

scan

@SequentialOnly
public abstract <R> Stream<R> scan(R seed,
                                                    BiFunction<? super R,? super T,R> accumulator)

Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream. Produces a Stream consisting of seed, acc(seed, value1), acc(acc(seed, value1), value2), etc.

This is an intermediate operation.

Example:

 
 Stream.of(new Integer[0]).scan(10, (a, b) -> a + b) => []
 Stream.of(1).scan(10, (a, b) -> a + b) => [11]
 Stream.of(1, 2).scan(10, (a, b) -> a + b) => [11, 13]
 Stream.of(1, 2, 3).scan(10, (a, b) -> a + b) => [11, 13, 16]
 Stream.of(1, 2, 3, 3, 2, 1).scan(10, (a, b) -> a + b) => [11, 13, 16, 19, 21, 22]
 
 

This method only run sequentially, even in parallel stream.

Parameters:

seed - the initial value. it's only used once by accumulator to calculate the fist element in the returned stream. It will be ignored if this stream is empty and won't be the first element of the returned stream.

accumulator - the accumulation function

Returns:

the new stream which has the extract same size as this stream.

splitToSet

@SequentialOnly
public abstract Stream<java.util.Set<T>> splitToSet(int size)

Returns Stream of Stream with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
This method only run sequentially, even in parallel stream.

Parameters:

size -

Returns:

splitToSet

@SequentialOnly
public abstract Stream<java.util.Set<T>> splitToSet(Predicate<? super T> predicate)

splitToSet

@SequentialOnly
public abstract <U> Stream<java.util.Set<T>> splitToSet(U seed,
                                                                         BiPredicate<? super T,? super U> predicate,
                                                                         Consumer<? super U> seedUpdate)

Split the stream by the specified predicate.

 
 // split the number sequence by window 5.
 Stream.of(1, 2, 3, 5, 7, 9, 10, 11, 19).splitToSet(MutableInt.of(5), (e, b) -> e <= b.intValue(), b -> b.addAndGet(5)).forEach(N::println);
 
 

This method only run sequentially, even in parallel stream.

Parameters:

seed -

predicate -

seedUpdate -

Returns:

split

@SequentialOnly
public abstract <C extends java.util.Collection<T>> Stream<C> split(int size,
                                                                                     IntFunction<C> collectionSupplier)

Returns Stream of Stream with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
This method only run sequentially, even in parallel stream.

Parameters:

size -

collectionSupplier -

Returns:

split

@SequentialOnly
public abstract <C extends java.util.Collection<T>> Stream<C> split(Predicate<? super T> predicate,
                                                                                     Supplier<C> collectionSupplier)

split

@SequentialOnly
public abstract <U,C extends java.util.Collection<T>> Stream<C> split(U seed,
                                                                                       BiPredicate<? super T,? super U> predicate,
                                                                                       Consumer<? super U> seedUpdate,
                                                                                       Supplier<C> collectionSupplier)

Split the stream by the specified predicate.

 
 // split the number sequence by window 5.
 Stream.of(1, 2, 3, 5, 7, 9, 10, 11, 19).split(MutableInt.of(5), (e, b) -> e <= b.intValue(), b -> b.addAndGet(5), Suppliers.ofList).forEach(N::println);
 
 

This method only run sequentially, even in parallel stream.

Parameters:

seed -

predicate -

seedUpdate -

collectionSupplier -

Returns:

sliding

@SequentialOnly
public abstract <C extends java.util.Collection<T>> Stream<C> sliding(int windowSize,
                                                                                       IntFunction<C> collectionSupplier)

sliding

@SequentialOnly
public abstract <C extends java.util.Collection<T>> Stream<C> sliding(int windowSize,
                                                                                       int increment,
                                                                                       IntFunction<C> collectionSupplier)

intersperse

@SequentialOnly
public abstract Stream<T> intersperse(T delimiter)

Stream.of(1).intersperse(9) --> [1] Stream.of(1, 2, 3).intersperse(9) --> [1, 9, 2, 9, 3]
This method only run sequentially, even in parallel stream.

Parameters:

delimiter -

Returns:

distinct

public Stream<T> distinct(Predicate<? super java.lang.Long> occurrencesFilter)

Distinct and filter by occurrences.

Parameters:

occurrencesFilter -

Returns:

distinctBy

@ParallelSupported
public abstract Stream<T> distinctBy(Function<? super T,?> keyExtractor)

Distinct by the value mapped from keyExtractor

Parameters:

keyExtractor - don't change value of the input parameter.

Returns:

distinctBy

public <K> Stream<T> distinctBy(Function<? super T,K> keyExtractor,
                                Predicate<? super java.lang.Long> occurrencesFilter)

Distinct and filter by occurrences.

Parameters:

keyExtractor -

occurrencesFilter -

Returns:

top

@SequentialOnly
public abstract Stream<T> top(int n)

This method only run sequentially, even in parallel stream.

Parameters:

n -

Returns:

top

@SequentialOnly
public abstract Stream<T> top(int n,
                                               java.util.Comparator<? super T> comparator)

This method only run sequentially, even in parallel stream.

Parameters:

n -

comparator -

Returns:

sorted

@ParallelSupported
public abstract Stream<T> sorted(java.util.Comparator<? super T> comparator)

Returns a stream consisting of the elements of this stream, sorted according to the provided Comparator.

For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.

This is a stateful intermediate operation.

Parameters:

comparator - a non-interfering, stateless Comparator to be used to compare stream elements

Returns:

the new stream

sortedBy

@ParallelSupported
public abstract Stream<T> sortedBy(Function<? super T,? extends java.lang.Comparable> keyExtractor)

sortedByInt

@ParallelSupported
public abstract Stream<T> sortedByInt(ToIntFunction<? super T> keyExtractor)

sortedByLong

@ParallelSupported
public abstract Stream<T> sortedByLong(ToLongFunction<? super T> keyExtractor)

sortedByDouble

@ParallelSupported
public abstract Stream<T> sortedByDouble(ToDoubleFunction<? super T> keyExtractor)

forEach

@ParallelSupported
public abstract <E extends java.lang.Exception> void forEach(Try.Consumer<? super T,E> action)
                                                                          throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

forEachPair

@ParallelSupported
public abstract <E extends java.lang.Exception> void forEachPair(Try.BiConsumer<? super T,? super T,E> action)
                                                                              throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

forEachPair

@ParallelSupported
public abstract <E extends java.lang.Exception> void forEachPair(Try.BiConsumer<? super T,? super T,E> action,
                                                                                     int increment)
                                                                              throws E extends java.lang.Exception

Slide with windowSize = 2 and the specified increment, then consume by the specified mapper.

Parameters:

mapper -

increment -

Throws:

E extends java.lang.Exception

forEachTriple

@ParallelSupported
public abstract <E extends java.lang.Exception> void forEachTriple(Try.TriConsumer<? super T,? super T,? super T,E> action)
                                                                                throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

forEachTriple

@ParallelSupported
public abstract <E extends java.lang.Exception> void forEachTriple(Try.TriConsumer<? super T,? super T,? super T,E> action,
                                                                                       int increment)
                                                                                throws E extends java.lang.Exception

Slide with windowSize = 3 and the specified increment, then consume by the specified mapper.

Parameters:

mapper -

increment -

Throws:

E extends java.lang.Exception

anyMatch

@ParallelSupported
public abstract <E extends java.lang.Exception> boolean anyMatch(Try.Predicate<? super T,E> predicate)
                                                                              throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

allMatch

@ParallelSupported
public abstract <E extends java.lang.Exception> boolean allMatch(Try.Predicate<? super T,E> predicate)
                                                                              throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

noneMatch

@ParallelSupported
public abstract <E extends java.lang.Exception> boolean noneMatch(Try.Predicate<? super T,E> predicate)
                                                                               throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findFirst

@ParallelSupported
public abstract <E extends java.lang.Exception> Optional<T> findFirst(Try.Predicate<? super T,E> predicate)
                                                                                   throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findLast

@ParallelSupported
public abstract <E extends java.lang.Exception> Optional<T> findLast(Try.Predicate<? super T,E> predicate)
                                                                                  throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findFirstOrLast

@SequentialOnly
public abstract <E extends java.lang.Exception,E2 extends java.lang.Exception> Optional<T> findFirstOrLast(Try.Predicate<? super T,E> predicateForFirst,
                                                                                                                            Try.Predicate<? super T,E2> predicateForLast)
                                                                                                                     throws E extends java.lang.Exception,
                                                                                                                            E2 extends java.lang.Exception

Throws:

E extends java.lang.Exception

findAny

@ParallelSupported
public abstract <E extends java.lang.Exception> Optional<T> findAny(Try.Predicate<? super T,E> predicate)
                                                                                 throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findFirst

@ParallelSupported
public abstract <U,E extends java.lang.Exception> Optional<T> findFirst(U seed,
                                                                                            Try.BiPredicate<? super T,? super U,E> predicate)
                                                                                     throws E extends java.lang.Exception

Parameters:

seed -

predicate -

Returns:

Throws:

E extends java.lang.Exception

findLast

@ParallelSupported
public abstract <U,E extends java.lang.Exception> Optional<T> findLast(U seed,
                                                                                           Try.BiPredicate<? super T,? super U,E> predicate)
                                                                                    throws E extends java.lang.Exception

Parameters:

seed -

predicate -

Returns:

Throws:

E extends java.lang.Exception

findAny

@ParallelSupported
public abstract <U,E extends java.lang.Exception> Optional<T> findAny(U seed,
                                                                                          Try.BiPredicate<? super T,? super U,E> predicate)
                                                                                   throws E extends java.lang.Exception

Parameters:

seed -

predicate -

Returns:

Throws:

E extends java.lang.Exception

findFirstOrLast

@SequentialOnly
public abstract <U,E extends java.lang.Exception,E2 extends java.lang.Exception> Optional<T> findFirstOrLast(U seed,
                                                                                                                              Try.BiPredicate<? super T,? super U,E> predicateForFirst,
                                                                                                                              Try.BiPredicate<? super T,? super U,E2> predicateForLast)
                                                                                                                       throws E extends java.lang.Exception,
                                                                                                                              E2 extends java.lang.Exception

This method only run sequentially, even in parallel stream.

Parameters:

seed -

predicateForFirst -

predicateForLast -

Returns:

Throws:

E extends java.lang.Exception

findFirstOrLast

@SequentialOnly
public abstract <U,E extends java.lang.Exception,E2 extends java.lang.Exception> Optional<T> findFirstOrLast(Function<? super T,U> preFunc,
                                                                                                                              Try.BiPredicate<? super T,? super U,E> predicateForFirst,
                                                                                                                              Try.BiPredicate<? super T,? super U,E2> predicateForLast)
                                                                                                                       throws E extends java.lang.Exception,
                                                                                                                              E2 extends java.lang.Exception

This method only run sequentially, even in parallel stream.

Parameters:

preFunc -

predicateForFirst -

predicateForLast -

Returns:

Throws:

E extends java.lang.Exception

anyMatch

@ParallelSupported
public abstract <U,E extends java.lang.Exception> boolean anyMatch(U seed,
                                                                                       Try.BiPredicate<? super T,? super U,E> predicate)
                                                                                throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

allMatch

@ParallelSupported
public abstract <U,E extends java.lang.Exception> boolean allMatch(U seed,
                                                                                       Try.BiPredicate<? super T,? super U,E> predicate)
                                                                                throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

noneMatch

@ParallelSupported
public abstract <U,E extends java.lang.Exception> boolean noneMatch(U seed,
                                                                                        Try.BiPredicate<? super T,? super U,E> predicate)
                                                                                 throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

containsAll

@SequentialOnly
public abstract boolean containsAll(T... a)

containsAll

@SequentialOnly
public abstract boolean containsAll(java.util.Collection<? extends T> c)

toArray

@SequentialOnly
public abstract <A> A[] toArray(IntFunction<A[]> generator)

Returns an array containing the elements of this stream, using the provided generator function to allocate the returned array, as well as any additional arrays that might be required for a partitioned execution or for resizing.

This is a terminal operation.

Type Parameters:

A - the element type of the resulting array

Parameters:

generator - a function which produces a new array of the desired type and the provided length

Returns:

an array containing the elements in this stream

Throws:

java.lang.ArrayStoreException - if the runtime type of the array returned from the array generator is not a supertype of the runtime type of every element in this stream

toImmutableMap

@ParallelSupported
public <K,V> ImmutableMap<K,V> toImmutableMap(Function<? super T,? extends K> keyExtractor,
                                                                  Function<? super T,? extends V> valueMapper)

Parameters:

keyExtractor -

valueMapper -

Returns:

See Also:

Collectors.toMap(Function, Function)

toImmutableMap

@ParallelSupported
public <K,V> ImmutableMap<K,V> toImmutableMap(Function<? super T,? extends K> keyExtractor,
                                                                  Function<? super T,? extends V> valueMapper,
                                                                  BinaryOperator<V> mergeFunction)

Parameters:

keyExtractor -

valueMapper -

mergeFunction -

Returns:

See Also:

Collectors.toMap(Function, Function)

toMap

@ParallelSupported
public abstract <K,V> java.util.Map<K,V> toMap(Function<? super T,? extends K> keyExtractor,
                                                                   Function<? super T,? extends V> valueMapper)

Parameters:

keyExtractor -

valueMapper -

Returns:

See Also:

Collectors.toMap(Function, Function)

toMap

@ParallelSupported
public abstract <K,V> java.util.Map<K,V> toMap(Function<? super T,? extends K> keyExtractor,
                                                                   Function<? super T,? extends V> valueMapper,
                                                                   BinaryOperator<V> mergeFunction)

Parameters:

keyExtractor -

valueMapper -

mergeFunction -

Returns:

See Also:

Collectors.toMap(Function, Function, BinaryOperator)

toMap

@ParallelSupported
public abstract <K,V,M extends java.util.Map<K,V>> M toMap(Function<? super T,? extends K> keyExtractor,
                                                                               Function<? super T,? extends V> valueMapper,
                                                                               Supplier<M> mapFactory)

Parameters:

keyExtractor -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMap(Function, Function, Supplier)

toMap

@ParallelSupported
public abstract <K,V,M extends java.util.Map<K,V>> M toMap(Function<? super T,? extends K> keyExtractor,
                                                                               Function<? super T,? extends V> valueMapper,
                                                                               BinaryOperator<V> mergeFunction,
                                                                               Supplier<M> mapFactory)

Parameters:

keyExtractor -

valueMapper -

mergeFunction -

mapFactory -

Returns:

See Also:

Collectors.toMap(Function, Function, BinaryOperator, Supplier)

toMap

@ParallelSupported
public abstract <K,A,D> java.util.Map<K,D> toMap(Function<? super T,? extends K> classifier,
                                                                     Collector<? super T,A,D> downstream)

Parameters:

classifier -

downstream -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

toMap

@ParallelSupported
public abstract <K,A,D,M extends java.util.Map<K,D>> M toMap(Function<? super T,? extends K> classifier,
                                                                                 Collector<? super T,A,D> downstream,
                                                                                 Supplier<M> mapFactory)

Parameters:

classifier -

downstream -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Collector, Supplier)

toMap

@ParallelSupported
public abstract <K,U,A,D> java.util.Map<K,D> toMap(Function<? super T,? extends K> classifier,
                                                                       Function<? super T,? extends U> valueMapper,
                                                                       Collector<? super U,A,D> downstream)

Parameters:

classifier -

valueMapper -

downstream -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

toMap

@ParallelSupported
public abstract <K,U,A,D,M extends java.util.Map<K,D>> M toMap(Function<? super T,? extends K> classifier,
                                                                                   Function<? super T,? extends U> valueMapper,
                                                                                   Collector<? super U,A,D> downstream,
                                                                                   Supplier<M> mapFactory)

Parameters:

classifier -

valueMapper -

downstream -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Collector, Supplier)

groupTo

@ParallelSupported
public abstract <K> java.util.Map<K,java.util.List<T>> groupTo(Function<? super T,? extends K> classifier)

Parameters:

classifier -

Returns:

See Also:

Collectors.groupingBy(Function)

groupTo

@ParallelSupported
public abstract <K,M extends java.util.Map<K,java.util.List<T>>> M groupTo(Function<? super T,? extends K> classifier,
                                                                                               Supplier<M> mapFactory)

Parameters:

classifier -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Supplier)

groupTo

@ParallelSupported
public abstract <K,U> java.util.Map<K,java.util.List<U>> groupTo(Function<? super T,? extends K> keyExtractor,
                                                                                     Function<? super T,? extends U> valueMapper)

groupTo

@ParallelSupported
public abstract <K,U,M extends java.util.Map<K,java.util.List<U>>> M groupTo(Function<? super T,? extends K> keyExtractor,
                                                                                                 Function<? super T,? extends U> valueMapper,
                                                                                                 Supplier<M> mapFactory)

Parameters:

keyExtractor -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMultimap(Function, Function, Supplier)

partitionTo

@ParallelSupported
public abstract java.util.Map<java.lang.Boolean,java.util.List<T>> partitionTo(Predicate<? super T> predicate)

Parameters:

predicate -

Returns:

See Also:

Collectors.partitioningBy(Predicate)

partitionTo

@ParallelSupported
public abstract <A,D> java.util.Map<java.lang.Boolean,D> partitionTo(Predicate<? super T> predicate,
                                                                                         Collector<? super T,A,D> downstream)

Parameters:

predicate -

downstream -

Returns:

See Also:

Collectors.partitioningBy(Predicate, Collector)

toMultimap

@ParallelSupported
public abstract <K> ListMultimap<K,T> toMultimap(Function<? super T,? extends K> keyExtractor)

Parameters:

keyExtractor -

Returns:

See Also:

Collectors.toMultimap(Function, Function)

toMultimap

@ParallelSupported
public abstract <K,V extends java.util.Collection<T>,M extends Multimap<K,T,V>> M toMultimap(Function<? super T,? extends K> keyExtractor,
                                                                                                                 Supplier<M> mapFactory)

Parameters:

keyExtractor -

mapFactory -

Returns:

See Also:

Collectors.toMultimap(Function, Function, Supplier)

toMultimap

@ParallelSupported
public abstract <K,U> ListMultimap<K,U> toMultimap(Function<? super T,? extends K> keyExtractor,
                                                                       Function<? super T,? extends U> valueMapper)

Parameters:

keyExtractor -

valueMapper -

Returns:

See Also:

Collectors.toMultimap(Function, Function)

toMultimap

@ParallelSupported
public abstract <K,U,V extends java.util.Collection<U>,M extends Multimap<K,U,V>> M toMultimap(Function<? super T,? extends K> keyExtractor,
                                                                                                                   Function<? super T,? extends U> valueMapper,
                                                                                                                   Supplier<M> mapFactory)

Parameters:

keyExtractor -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMultimap(Function, Function, Supplier)

toMatrix

@SequentialOnly
public abstract Matrix<T> toMatrix(java.lang.Class<T> type)

toDataSet

@SequentialOnly
public abstract DataSet toDataSet()

Returns:

toDataSet

@SequentialOnly
public abstract DataSet toDataSet(boolean isFirstHeader)

Parameters:

isFirstHeader -

Returns:

toDataSet

@SequentialOnly
public abstract DataSet toDataSet(java.util.List<java.lang.String> columnNames)

Parameters:

columnNames - it can be null or empty if this is Map or entity stream.

Returns:

reduce

@ParallelSupported
public abstract T reduce(T identity,
                                             BinaryOperator<T> accumulator)

Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value. This is equivalent to:

     T result = identity;
     for (T element : this stream)
         result = accumulator.apply(result, element)
     return result;
 

but is not constrained to execute sequentially.

The identity value must be an identity for the accumulator function. This means that for all t, accumulator.apply(identity, t) is equal to t. The accumulator function must be an associative function.

This is a terminal operation.

Parameters:

identity - the identity value for the accumulating function

accumulator - an associative, non-interfering, stateless function for combining two values

Returns:

the result of the reduction

reduce

@ParallelSupported
public abstract Optional<T> reduce(BinaryOperator<T> accumulator)

Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any. This is equivalent to:

     boolean foundAny = false;
     T result = null;
     for (T element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.apply(result, element);
     }
     return foundAny ? Optional.of(result) : Optional.empty();
 

but is not constrained to execute sequentially.

The accumulator function must be an associative function.

This is a terminal operation.

Parameters:

accumulator - an associative, non-interfering, stateless function for combining two values

Returns:

an Optional describing the result of the reduction

See Also:

reduce(Object, BinaryOperator), min(Comparator), max(Comparator)

reduce

@ParallelSupported
public abstract <U> U reduce(U identity,
                                                 BiFunction<U,? super T,U> accumulator,
                                                 BinaryOperator<U> combiner)

Performs a reduction on the elements of this stream, using the provided identity, accumulation and combining functions. This is equivalent to:

     U result = identity;
     for (T element : this stream)
         result = accumulator.apply(result, element)
     return result;
 

but is not constrained to execute sequentially.

The identity value must be an identity for the zipFunction function. This means that for all u, zipFunction(identity, u) is equal to u. Additionally, the zipFunction function must be compatible with the accumulator function; for all u and t, the following must hold:

     zipFunction.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t)
 

This is a terminal operation.

Type Parameters:

U - The type of the result

Parameters:

identity - the identity value for the zipFunction function

accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result

combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function

Returns:

the result of the reduction

See Also:

reduce(BinaryOperator), reduce(Object, BinaryOperator)

reduce

@Deprecated
 @ParallelSupported
public abstract <U> U reduce(U identity,
                                                               BiFunction<U,? super T,U> accumulator)

Deprecated.

The result will be merged by: a.addAll(b) if result container is Collection/Multiset/LongMultiset/IntList/CharList/..., or a.putAll(b) if result container is Map/Multimap/Sheet, or a.append(b) if result container is StringBuilder, or N.concat(a, b) if result container is array: boolean[]/char[]/int[]/.../Object[] when it's necessary in Parallel Stream.

Parameters:

identity -

accumulator -

Returns:

Throws:

java.lang.RuntimeException - if the result container can't be merged by default when it's necessary in Parallel Stream.

collect

@ParallelSupported
public abstract <R> R collect(Supplier<R> supplier,
                                                  BiConsumer<R,? super T> accumulator,
                                                  BiConsumer<R,R> combiner)

Performs a mutable reduction operation on the elements of this stream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:

     R result = supplier.get();
     for (T element : this stream)
         accumulator.accept(result, element);
     return result;
 

Like reduce(Object, BinaryOperator), collect operations can be parallelized without requiring additional synchronization.

This is a terminal operation.

Type Parameters:

R - type of the result

Parameters:

supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.

accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result

combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function

Returns:

the result of the reduction

collect

@ParallelSupported
public abstract <R> R collect(Supplier<R> supplier,
                                                  BiConsumer<R,? super T> accumulator)

The result will be merged by: a.addAll(b) if result container is Collection/Multiset/LongMultiset/IntList/CharList/..., or a.putAll(b) if result container is Map/Multimap/Sheet, or a.append(b) if result container is StringBuilder when it's necessary in Parallel Stream.

Parameters:

supplier -

accumulator -

Returns:

Throws:

java.lang.RuntimeException - if the result container can't be merged by default when it's necessary in Parallel Stream.

collect

@ParallelSupported
public abstract <R,A> R collect(Collector<? super T,A,R> collector)

Performs a mutable reduction operation on the elements of this stream using a Collector. A Collector encapsulates the functions used as arguments to collect(Supplier, BiConsumer, BiConsumer), allowing for reuse of collection strategies and composition of collect operations such as multiple-level grouping or partitioning.

If the stream is parallel, and the Collector is concurrent, and either the stream is unordered or the collector is unordered, then a concurrent reduction will be performed (see Collector for details on concurrent reduction.)

This is a terminal operation.

When executed in parallel, multiple intermediate results may be instantiated, populated, and merged so as to maintain isolation of mutable data structures. Therefore, even when executed in parallel with non-thread-safe data structures (such as ArrayList), no additional synchronization is needed for a parallel reduction.

Type Parameters:

R - the type of the result

A - the intermediate accumulation type of the Collector

Parameters:

collector - the Collector describing the reduction

Returns:

the result of the reduction

See Also:

collect(Supplier, BiConsumer, BiConsumer), Collectors

collect

@ParallelSupported
public abstract <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)

collectAndThen

@ParallelSupported
public abstract <R,A,RR> RR collectAndThen(Collector<? super T,A,R> downstream,
                                                               Function<R,RR> finisher)

collectAndThen

@ParallelSupported
public abstract <R,A,RR> RR collectAndThen(java.util.stream.Collector<? super T,A,R> downstream,
                                                               Function<R,RR> finisher)

toListAndThen

@SequentialOnly
public abstract <R> R toListAndThen(Function<? super java.util.List<T>,R> func)

toSetAndThen

@SequentialOnly
public abstract <R> R toSetAndThen(Function<? super java.util.Set<T>,R> func)

head

@SequentialOnly
public abstract Optional<T> head()

Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() or tail() is called.

Returns:

tail

@SequentialOnly
public abstract Stream<T> tail()

Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() or tail() is called.

Returns:

headd

@Deprecated
 @SequentialOnly
public abstract Stream<T> headd()

Deprecated.

Head2 and tail2 should be used by pair. Don't call any other methods with this stream after headd() or taill() is called.
All elements will be loaded to memory.

Returns:

taill

@Deprecated
 @SequentialOnly
public abstract Optional<T> taill()

Deprecated.

Head2 and tail2 should be used by pair. Don't call any other methods with this stream after headd() or taill() is called.
All elements will be loaded to memory.

Returns:

headAndTail

@SequentialOnly
public abstract Pair<Optional<T>,Stream<T>> headAndTail()

headAndTaill

@Deprecated
 @SequentialOnly
public abstract Pair<Stream<T>,Optional<T>> headAndTaill()

Deprecated.

All elements will be loaded to memory.

Returns:

last

@SequentialOnly
public abstract Stream<T> last(int n)

A queue with size up to n will be maintained to filter out the last n elements. It may cause out of memory error if n is big enough.

Parameters:

n -

Returns:

skipLast

@SequentialOnly
public abstract Stream<T> skipLast(int n)

A queue with size up to n will be maintained to filter out the last n elements. It may cause out of memory error if n is big enough.
This method only run sequentially, even in parallel stream.

Parameters:

n -

Returns:

min

@ParallelSupported
public abstract Optional<T> min(java.util.Comparator<? super T> comparator)

Returns the minimum element of this stream according to the provided Comparator. This is a special case of a reduction.

This is a terminal operation.

Parameters:

comparator - a non-interfering, stateless Comparator to compare elements of this stream

Returns:

an Optional describing the minimum element of this stream, or an empty Optional if the stream is empty

minBy

@ParallelSupported
public Optional<T> minBy(Function<? super T,? extends java.lang.Comparable> keyExtractor)

max

@ParallelSupported
public abstract Optional<T> max(java.util.Comparator<? super T> comparator)

Returns the maximum element of this stream according to the provided Comparator. This is a special case of a reduction.

This is a terminal operation.

Parameters:

comparator - a non-interfering, stateless Comparator to compare elements of this stream

Returns:

an Optional describing the maximum element of this stream, or an empty Optional if the stream is empty

maxBy

@ParallelSupported
public Optional<T> maxBy(Function<? super T,? extends java.lang.Comparable> keyExtractor)

kthLargest

@ParallelSupported
public abstract Optional<T> kthLargest(int k,
                                                           java.util.Comparator<? super T> comparator)

Parameters:

k -

comparator -

Returns:

Optional.empty() if there is no element or count less than k, otherwise the kth largest element.

sumInt

@ParallelSupported
public abstract int sumInt(ToIntFunction<? super T> mapper)

sumLong

@ParallelSupported
public abstract long sumLong(ToLongFunction<? super T> mapper)

sumDouble

@ParallelSupported
public abstract double sumDouble(ToDoubleFunction<? super T> mapper)

averageInt

@ParallelSupported
public abstract OptionalDouble averageInt(ToIntFunction<? super T> mapper)

averageLong

@ParallelSupported
public abstract OptionalDouble averageLong(ToLongFunction<? super T> mapper)

averageDouble

@ParallelSupported
public abstract OptionalDouble averageDouble(ToDoubleFunction<? super T> mapper)

percentiles

@SequentialOnly
public abstract Optional<java.util.Map<com.landawn.abacus.util.Percentage,T>> percentiles(java.util.Comparator<? super T> comparator)

combinations

@SequentialOnly
public abstract Stream<java.util.List<T>> combinations()

 
 Stream.of(1, 2, 3).combinations().forEach(Fn.println());
 // output
 []
 [1]
 [2]
 [3]
 [1, 2]
 [1, 3]
 [2, 3]
 [1, 2, 3]
 
 

Returns:

combinations

@SequentialOnly
public abstract Stream<java.util.List<T>> combinations(int len)

 
 Stream.of(1, 2, 3).combinations(2).forEach(Fn.println());
 // output
 [1, 2]
 [1, 3]
 [2, 3]
 
 

Parameters:

len -

Returns:

combinations

@SequentialOnly
public abstract Stream<java.util.List<T>> combinations(int len,
                                                                        boolean repeat)

It's same as N.cartesianProduct(N.repeat(toList(), len)) if repeat is true.

 
 Stream.of(1, 2, 3).combinations(2, true).forEach(Fn.println());
 // output
 [1, 1]
 [1, 2]
 [1, 3]
 [2, 1]
 [2, 2]
 [2, 3]
 [3, 1]
 [3, 2]
 [3, 3]
 
 

Parameters:

len -

repeat -

Returns:

permutations

@SequentialOnly
public abstract Stream<java.util.List<T>> permutations()

 
 Stream.of(1, 2, 3).permutations().forEach(Fn.println());
 // output
 [1, 2, 3]
 [1, 3, 2]
 [3, 1, 2]
 [3, 2, 1]
 [2, 3, 1]
 [2, 1, 3]
 
 

Returns:

orderedPermutations

@SequentialOnly
public abstract Stream<java.util.List<T>> orderedPermutations()

 
 Stream.of(1, 2, 3).orderedPermutations().forEach(Fn.println());
 // output
 [1, 2, 3]
 [1, 3, 2]
 [2, 1, 3]
 [2, 3, 1]
 [3, 1, 2]
 [3, 2, 1]
 
 

Returns:

orderedPermutations

@SequentialOnly
public abstract Stream<java.util.List<T>> orderedPermutations(java.util.Comparator<? super T> comparator)

cartesianProduct

@SequentialOnly
 @SafeVarargs
public final Stream<java.util.List<T>> cartesianProduct(java.util.Collection<? extends T>... cs)

cartesianProduct

@SequentialOnly
public abstract Stream<java.util.List<T>> cartesianProduct(java.util.Collection<? extends java.util.Collection<? extends T>> cs)

innerJoin

@ParallelSupported
public abstract <U> Stream<Pair<T,U>> innerJoin(java.util.Collection<U> b,
                                                                    Function<? super T,?> leftKeyMapper,
                                                                    Function<? super U,?> rightKeyMapper)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

Returns:

See Also:

innerJoin

@ParallelSupported
public abstract <U> Stream<Pair<T,U>> innerJoin(java.util.Collection<U> b,
                                                                    BiPredicate<? super T,? super U> predicate)

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Parameters:

b -

predicate -

Returns:

See Also:

fullJoin

@ParallelSupported
public abstract <U> Stream<Pair<T,U>> fullJoin(java.util.Collection<U> b,
                                                                   Function<? super T,?> leftKeyMapper,
                                                                   Function<? super U,?> rightKeyMapper)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

Returns:

See Also:

fullJoin

@ParallelSupported
public abstract <U> Stream<Pair<T,U>> fullJoin(java.util.Collection<U> b,
                                                                   BiPredicate<? super T,? super U> predicate)

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Parameters:

b -

predicate -

Returns:

See Also:

leftJoin

@ParallelSupported
public abstract <U> Stream<Pair<T,U>> leftJoin(java.util.Collection<U> b,
                                                                   Function<? super T,?> leftKeyMapper,
                                                                   Function<? super U,?> rightKeyMapper)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

Returns:

See Also:

leftJoin

@ParallelSupported
public abstract <U> Stream<Pair<T,U>> leftJoin(java.util.Collection<U> b,
                                                                   BiPredicate<? super T,? super U> predicate)

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Parameters:

b -

predicate -

Returns:

See Also:

rightJoin

@ParallelSupported
public abstract <U> Stream<Pair<T,U>> rightJoin(java.util.Collection<U> b,
                                                                    Function<? super T,?> leftKeyMapper,
                                                                    Function<? super U,?> rightKeyMapper)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

Returns:

See Also:

rightJoin

@ParallelSupported
public abstract <U> Stream<Pair<T,U>> rightJoin(java.util.Collection<U> b,
                                                                    BiPredicate<? super T,? super U> predicate)

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Parameters:

b -

predicate -

Returns:

See Also:

hasDuplicates

@SequentialOnly
public abstract boolean hasDuplicates()

skipNull

@SequentialOnly
public abstract Stream<T> skipNull()

peekFirst

@ParallelSupported
public abstract Stream<T> peekFirst(Consumer<? super T> action)

peekLast

@ParallelSupported
public abstract Stream<T> peekLast(Consumer<? super T> action)

intersection

@ParallelSupported
public abstract Stream<T> intersection(Function<? super T,?> mapper,
                                                           java.util.Collection<?> c)

Intersect with the specified Collection by the values mapped by mapper.

Parameters:

mapper -

c -

Returns:

See Also:

IntList.intersection(IntList)

difference

@ParallelSupported
public abstract Stream<T> difference(Function<? super T,?> mapper,
                                                         java.util.Collection<?> c)

Except with the specified Collection by the values mapped by mapper.

Parameters:

mapper -

c -

Returns:

See Also:

IntList.difference(IntList)

append

@SafeVarargs
 @SequentialOnly
public final Stream<T> append(T... a)

append

@SequentialOnly
public abstract Stream<T> append(java.util.Collection<? extends T> c)

prepend

@SafeVarargs
 @SequentialOnly
public final Stream<T> prepend(T... a)

prepend

@SequentialOnly
public abstract Stream<T> prepend(java.util.Collection<? extends T> c)

cached

@SequentialOnly
public abstract Stream<T> cached(IntFunction<T[]> generator)

Returns a reusable stream which can be repeatedly used.
All elements will be loaded to memory.

Parameters:

generator -

Returns:

queued

@SequentialOnly
public abstract Stream<T> queued()

queued

@SequentialOnly
public abstract Stream<T> queued(int queueSize)

Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterator asynchronously.

Parameters:

queueSize - Default value is 8

Returns:

merge

@SequentialOnly
public abstract Stream<T> merge(Stream<? extends T> b,
                                                 BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

zipWith

@SequentialOnly
public abstract <T2,R> Stream<R> zipWith(Stream<T2> b,
                                                          BiFunction<? super T,? super T2,R> zipFunction)

zipWith

@SequentialOnly
public abstract <T2,T3,R> Stream<R> zipWith(Stream<T2> b,
                                                             Stream<T3> c,
                                                             TriFunction<? super T,? super T2,? super T3,R> zipFunction)

zipWith

@SequentialOnly
public abstract <T2,R> Stream<R> zipWith(Stream<T2> b,
                                                          T valueForNoneA,
                                                          T2 valueForNoneB,
                                                          BiFunction<? super T,? super T2,R> zipFunction)

zipWith

@SequentialOnly
public abstract <T2,T3,R> Stream<R> zipWith(Stream<T2> b,
                                                             Stream<T3> c,
                                                             T valueForNoneA,
                                                             T2 valueForNoneB,
                                                             T3 valueForNoneC,
                                                             TriFunction<? super T,? super T2,? super T3,R> zipFunction)

persist

@SequentialOnly
public abstract <E extends java.lang.Exception> long persist(java.io.File file,
                                                                              Try.Function<? super T,java.lang.String,E> toLine)
                                                                       throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

persist

@SequentialOnly
public abstract <E extends java.lang.Exception> long persist(java.io.OutputStream os,
                                                                              Try.Function<? super T,java.lang.String,E> toLine)
                                                                       throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

persist

@SequentialOnly
public abstract <E extends java.lang.Exception> long persist(java.io.Writer writer,
                                                                              Try.Function<? super T,java.lang.String,E> toLine)
                                                                       throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

persist

@SequentialOnly
public abstract long persist(java.sql.Connection conn,
                                              java.lang.String insertSQL,
                                              int batchSize,
                                              int batchInterval,
                                              Try.BiConsumer<? super java.sql.PreparedStatement,? super T,java.sql.SQLException> stmtSetter)

persist

@SequentialOnly
public abstract long persist(java.sql.PreparedStatement stmt,
                                              int batchSize,
                                              int batchInterval,
                                              Try.BiConsumer<? super java.sql.PreparedStatement,? super T,java.sql.SQLException> stmtSetter)

toJdkStream

@SequentialOnly
public abstract java.util.stream.Stream<T> toJdkStream()

iterator

@SequentialOnly
public ObjIterator<T> iterator()

Description copied from interface: BaseStream

Returns an iterator for the elements of this stream.

Returns:

the element iterator for this stream

__

@SequentialOnly
public <R> R __(Function<? super Stream<T>,R> transfer)

mapToEntryER

@SequentialOnly
 @Beta
public abstract <K,V> EntryStream<K,V> mapToEntryER(Function<? super T,K> keyMapper,
                                                                             Function<? super T,V> valueMapper)

To reduce the memory footprint, Only one instance of Map.Entry is created, and the same entry instance is returned and set with different keys/values during iteration of the returned stream. The elements only can be retrieved one by one, can't be modified or saved. The returned Stream doesn't support the operations which require two or more elements at the same time: (e.g. sort/distinct/pairMap/slidingMap/sliding/split/toList/toSet/...). , and can't be parallel stream. Operations: filter/map/toMap/groupBy/groupTo/... are supported.
ER = Entry Reusable

Parameters:

keyMapper -

valueMapper -

Returns:

empty

public static <T> Stream<T> empty()

just

public static <T> Stream<T> just(T a)

of

@SafeVarargs
public static <T> Stream<T> of(T... a)

of

public static <T> Stream<T> of(T[] a,
                               int startIndex,
                               int endIndex)

Returns a sequential, stateful and immutable Stream.

Parameters:

a -

startIndex -

endIndex -

Returns:

of

public static <T> Stream<T> of(java.util.Collection<? extends T> c)

Returns a sequential, stateful and immutable Stream.

Parameters:

c -

Returns:

of

public static <T> Stream<T> of(java.util.Collection<? extends T> c,
                               int startIndex,
                               int endIndex)

Returns a sequential, stateful and immutable Stream.

Parameters:

c -

startIndex -

endIndex -

Returns:

of

public static <K,V> Stream<java.util.Map.Entry<K,V>> of(java.util.Map<K,V> map)

of

public static <T> Stream<T> of(java.lang.Iterable<? extends T> iterable)

of

public static <T> Stream<T> of(java.util.Iterator<? extends T> iterator)

Returns a sequential, stateful and immutable Stream.

Parameters:

iterator -

Returns:

of

public static <T> Stream<T> of(java.util.stream.Stream<T> stream)

of

public static Stream<java.lang.String> of(java.io.Reader reader)

It's user's responsibility to close the input reader after the stream is finished.

Parameters:

reader -

Returns:

of

public static Stream<java.lang.Object[]> of(RowIterator rowIterator)

It's user's responsibility to close the input rowIterator after the stream is finished.

Parameters:

rowIterator -

Returns:

of

public static Try<Stream<java.lang.Object[]>> of(RowIterator rowIterator,
                                                 boolean closeRowIterator)

of

public static <T> Stream<T> of(java.lang.Class<T> targetClass,
                               RowIterator rowIterator)

It's user's responsibility to close the input rowIterator after the stream is finished.

Parameters:

targetClass -

rowIterator -

Returns:

of

public static <T> Try<Stream<T>> of(java.lang.Class<T> targetClass,
                                    RowIterator rowIterator,
                                    boolean closeRowIterator)

of

public static Stream<java.lang.Object[]> of(java.sql.ResultSet resultSet)

It's user's responsibility to close the input resultSet after the stream is finished.

Parameters:

resultSet -

Returns:

of

public static Try<Stream<java.lang.Object[]>> of(java.sql.ResultSet resultSet,
                                                 boolean closeResultSet)

of

public static <T> Stream<T> of(java.lang.Class<T> targetClass,
                               java.sql.ResultSet resultSet)

It's user's responsibility to close the input resultSet after the stream is finished.

Parameters:

targetClass -

resultSet -

Returns:

of

public static <T> Try<Stream<T>> of(java.lang.Class<T> targetClass,
                                    java.sql.ResultSet resultSet,
                                    boolean closeResultSet)

of

public static <T> Stream<T> of(java.sql.ResultSet resultSet,
                               int columnIndex)

It's user's responsibility to close the input resultSet after the stream is finished.

Parameters:

resultSet -

columnIndex - starts from 0, not 1.

Returns:

of

public static <T> Try<Stream<T>> of(java.sql.ResultSet resultSet,
                                    int columnIndex,
                                    boolean closeResultSet)

Parameters:

resultSet -

columnIndex - starts from 0, not 1.

closeResultSet -

Returns:

of

public static <T> Stream<T> of(java.sql.ResultSet resultSet,
                               java.lang.String columnName)

It's user's responsibility to close the input resultSet after the stream is finished.

Parameters:

resultSet -

columnName -

Returns:

of

public static <T> Try<Stream<T>> of(java.sql.ResultSet resultSet,
                                    java.lang.String columnName,
                                    boolean closeResultSet)

Parameters:

resultSet -

columnName -

closeResultSet -

Returns:

of

public static Try<Stream<java.lang.String>> of(java.io.File file)

of

public static Try<Stream<java.lang.String>> of(java.io.File file,
                                               java.nio.charset.Charset charset)

of

public static Try<Stream<java.lang.String>> of(java.nio.file.Path path)

of

public static Try<Stream<java.lang.String>> of(java.nio.file.Path path,
                                               java.nio.charset.Charset charset)

ofNullable

public static <T> Stream<T> ofNullable(T t)

of

public static Stream<java.lang.Boolean> of(boolean[] a)

of

public static Stream<java.lang.Boolean> of(boolean[] a,
                                           int fromIndex,
                                           int toIndex)

of

public static Stream<java.lang.Character> of(char[] a)

of

public static Stream<java.lang.Character> of(char[] a,
                                             int fromIndex,
                                             int toIndex)

of

public static Stream<java.lang.Byte> of(byte[] a)

of

public static Stream<java.lang.Byte> of(byte[] a,
                                        int fromIndex,
                                        int toIndex)

of

public static Stream<java.lang.Short> of(short[] a)

of

public static Stream<java.lang.Short> of(short[] a,
                                         int fromIndex,
                                         int toIndex)

of

public static Stream<java.lang.Integer> of(int[] a)

of

public static Stream<java.lang.Integer> of(int[] a,
                                           int fromIndex,
                                           int toIndex)

of

public static Stream<java.lang.Long> of(long[] a)

of

public static Stream<java.lang.Long> of(long[] a,
                                        int fromIndex,
                                        int toIndex)

of

public static Stream<java.lang.Float> of(float[] a)

of

public static Stream<java.lang.Float> of(float[] a,
                                         int fromIndex,
                                         int toIndex)

of

public static Stream<java.lang.Double> of(double[] a)

of

public static Stream<java.lang.Double> of(double[] a,
                                          int fromIndex,
                                          int toIndex)

of

public static <T> Stream<T> of(Supplier<java.util.Collection<? extends T>> supplier)

Lazy evaluation.

Parameters:

supplier -

Returns:

ofKeys

public static <T> Stream<T> ofKeys(java.util.Map<T,?> map)

ofKeys

public static <T,V> Stream<T> ofKeys(java.util.Map<T,V> map,
                                     Predicate<? super V> valueFilter)

ofValues

public static <T> Stream<T> ofValues(java.util.Map<?,T> map)

ofValues

public static <K,T> Stream<T> ofValues(java.util.Map<K,T> map,
                                       Predicate<? super K> keyFilter)

repeat

public static <T> Stream<T> repeat(T element,
                                   long n)

iterate

public static <T> Stream<T> iterate(BooleanSupplier hasNext,
                                    Supplier<? extends T> next)

iterate

public static <T> Stream<T> iterate(T seed,
                                    BooleanSupplier hasNext,
                                    UnaryOperator<T> f)

Returns a sequential ordered Stream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.

The first element (position 0) in the Stream will be the provided seed. For n > 0, the element at position n, will be the result of applying the function f to the element at position n - 1.

Parameters:

seed -

hasNext -

f -

Returns:

iterate

public static <T> Stream<T> iterate(T seed,
                                    Predicate<T> hasNext,
                                    UnaryOperator<T> f)

Parameters:

seed -

hasNext - test if has next by hasNext.test(seed) for first time and hasNext.test(f.apply(previous)) for remaining.

f -

Returns:

iterate

public static <T> Stream<T> iterate(T seed,
                                    UnaryOperator<T> f)

generate

public static <T> Stream<T> generate(Supplier<T> s)

interval

public static <T> Stream<T> interval(long intervalInMillis,
                                     Supplier<T> s)

Parameters:

intervalInMillis -

s -

Returns:

interval

public static <T> Stream<T> interval(long delayInMillis,
                                     long intervalInMillis,
                                     Supplier<T> s)

Parameters:

delayInMillis -

intervalInMillis -

s -

Returns:

See Also:

TimeUnit

interval

public static <T> Stream<T> interval(long delay,
                                     long interval,
                                     java.util.concurrent.TimeUnit unit,
                                     Supplier<T> s)

Parameters:

delay -

interval -

unit -

s -

Returns:

interval

public static <T> Stream<T> interval(long intervalInMillis,
                                     LongFunction<T> s)

interval

public static <T> Stream<T> interval(long delayInMillis,
                                     long intervalInMillis,
                                     LongFunction<T> s)

Parameters:

delayInMillis -

intervalInMillis -

s -

Returns:

See Also:

TimeUnit

interval

public static <T> Stream<T> interval(long delay,
                                     long interval,
                                     java.util.concurrent.TimeUnit unit,
                                     LongFunction<T> s)

Parameters:

delay -

interval -

unit -

s -

Returns:

split

public static Stream<java.lang.String> split(java.lang.String str,
                                             java.lang.String delimiter)

Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.

Parameters:

str -

delimiter -

Returns:

split

public static Stream<java.lang.String> split(java.lang.String str,
                                             java.lang.String delimiter,
                                             boolean trim)

Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.

Parameters:

str -

delimiter -

trim -

Returns:

split

public static Stream<java.lang.String> split(java.lang.String str,
                                             char delimiter)

Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.

Parameters:

str -

delimiter -

Returns:

split

public static Stream<java.lang.String> split(java.lang.String str,
                                             char delimiter,
                                             boolean trim)

Splits the provided text into an array, separator specified, preserving all tokens, including empty tokens created by adjacent separators.

Parameters:

str -

delimiter -

trim -

Returns:

list

public static Stream<java.io.File> list(java.io.File parentPath)

list

public static Stream<java.io.File> list(java.io.File parentPath,
                                        boolean recursively)

observe

public static <T> Stream<T> observe(java.util.concurrent.BlockingQueue<T> queue,
                                    Duration duration)

observe

public static <T> Stream<T> observe(java.util.concurrent.BlockingQueue<T> queue,
                                    Predicate<? super T> isLast,
                                    long maxWaitIntervalInMillis)

concat

@SafeVarargs
public static <T> Stream<T> concat(T[]... a)

concat

@SafeVarargs
public static <T> Stream<T> concat(java.util.Collection<? extends T>... a)

concat

@SafeVarargs
public static <T> Stream<T> concat(java.util.Iterator<? extends T>... a)

concat

@SafeVarargs
public static <T> Stream<T> concat(Stream<? extends T>... a)

concat

public static <T> Stream<T> concat(java.util.Collection<? extends Stream<? extends T>> c)

concatt

public static <T> Stream<T> concatt(java.util.Collection<? extends java.util.Iterator<? extends T>> c)

parallelConcat

@SafeVarargs
public static <T> Stream<T> parallelConcat(java.util.Iterator<? extends T>... a)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

a -

Returns:

parallelConcat

public static <T> Stream<T> parallelConcat(java.util.Iterator<? extends T>[] a,
                                           int readThreadNum,
                                           int queueSize)

Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterators in parallel. Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

a -

readThreadNum - - count of threads used to read elements from iterator to queue. Default value is min(8, a.length)

queueSize - Default value is N.min(128, a.length * 16)

Returns:

parallelConcat

@SafeVarargs
public static <T> Stream<T> parallelConcat(Stream<? extends T>... a)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

a -

Returns:

parallelConcat

public static <T> Stream<T> parallelConcat(Stream<? extends T>[] a,
                                           int readThreadNum,
                                           int queueSize)

Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterators in parallel. Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

a -

readThreadNum - - count of threads used to read elements from iterator to queue. Default value is min(8, a.length)

queueSize - Default value is N.min(128, a.length * 16)

Returns:

parallelConcat

public static <T> Stream<T> parallelConcat(java.util.Collection<? extends Stream<? extends T>> c)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

c -

Returns:

parallelConcat

public static <T> Stream<T> parallelConcat(java.util.Collection<? extends Stream<? extends T>> c,
                                           int readThreadNum)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

c -

readThreadNum -

Returns:

parallelConcat

public static <T> Stream<T> parallelConcat(java.util.Collection<? extends Stream<? extends T>> c,
                                           int readThreadNum,
                                           int queueSize)

Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterators in parallel. Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

a -

readThreadNum - - count of threads used to read elements from iterator to queue. Default value is min(8, c.size())

queueSize - Default value is N.min(128, c.size() * 16)

Returns:

parallelConcatt

public static <T> Stream<T> parallelConcatt(java.util.Collection<? extends java.util.Iterator<? extends T>> c)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

c -

Returns:

parallelConcatt

public static <T> Stream<T> parallelConcatt(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                            int readThreadNum)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

c -

readThreadNum -

Returns:

parallelConcatt

public static <T> Stream<T> parallelConcatt(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                            int readThreadNum,
                                            int queueSize)

Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterators in parallel. Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelConcat(a,b, ...)) { stream.forEach(N::println); }

Parameters:

a -

readThreadNum - - count of threads used to read elements from iterator to queue. Default value is min(8, c.size())

queueSize - Default value is N.min(128, c.size() * 16)

Returns:

zip

public static <R> Stream<R> zip(char[] a,
                                char[] b,
                                CharBiFunction<R> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(char[] a,
                                char[] b,
                                char[] c,
                                CharTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(CharIterator a,
                                CharIterator b,
                                CharBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(CharIterator a,
                                CharIterator b,
                                CharIterator c,
                                CharTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(CharStream a,
                                CharStream b,
                                CharBiFunction<R> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(CharStream a,
                                CharStream b,
                                CharStream c,
                                CharTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends CharStream> c,
                                CharNFunction<R> zipFunction)

Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(char[] a,
                                char[] b,
                                char valueForNoneA,
                                char valueForNoneB,
                                CharBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(char[] a,
                                char[] b,
                                char[] c,
                                char valueForNoneA,
                                char valueForNoneB,
                                char valueForNoneC,
                                CharTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(CharIterator a,
                                CharIterator b,
                                char valueForNoneA,
                                char valueForNoneB,
                                CharBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(CharIterator a,
                                CharIterator b,
                                CharIterator c,
                                char valueForNoneA,
                                char valueForNoneB,
                                char valueForNoneC,
                                CharTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(CharStream a,
                                CharStream b,
                                char valueForNoneA,
                                char valueForNoneB,
                                CharBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(CharStream a,
                                CharStream b,
                                CharStream c,
                                char valueForNoneA,
                                char valueForNoneB,
                                char valueForNoneC,
                                CharTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends CharStream> c,
                                char[] valuesForNone,
                                CharNFunction<R> zipFunction)

Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(byte[] a,
                                byte[] b,
                                ByteBiFunction<R> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(byte[] a,
                                byte[] b,
                                byte[] c,
                                ByteTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(ByteIterator a,
                                ByteIterator b,
                                ByteBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(ByteIterator a,
                                ByteIterator b,
                                ByteIterator c,
                                ByteTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(ByteStream a,
                                ByteStream b,
                                ByteBiFunction<R> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(ByteStream a,
                                ByteStream b,
                                ByteStream c,
                                ByteTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends ByteStream> c,
                                ByteNFunction<R> zipFunction)

Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(byte[] a,
                                byte[] b,
                                byte valueForNoneA,
                                byte valueForNoneB,
                                ByteBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(byte[] a,
                                byte[] b,
                                byte[] c,
                                byte valueForNoneA,
                                byte valueForNoneB,
                                byte valueForNoneC,
                                ByteTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(ByteIterator a,
                                ByteIterator b,
                                byte valueForNoneA,
                                byte valueForNoneB,
                                ByteBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(ByteIterator a,
                                ByteIterator b,
                                ByteIterator c,
                                byte valueForNoneA,
                                byte valueForNoneB,
                                byte valueForNoneC,
                                ByteTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(ByteStream a,
                                ByteStream b,
                                byte valueForNoneA,
                                byte valueForNoneB,
                                ByteBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(ByteStream a,
                                ByteStream b,
                                ByteStream c,
                                byte valueForNoneA,
                                byte valueForNoneB,
                                byte valueForNoneC,
                                ByteTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends ByteStream> c,
                                byte[] valuesForNone,
                                ByteNFunction<R> zipFunction)

Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(short[] a,
                                short[] b,
                                ShortBiFunction<R> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(short[] a,
                                short[] b,
                                short[] c,
                                ShortTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(ShortIterator a,
                                ShortIterator b,
                                ShortBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(ShortIterator a,
                                ShortIterator b,
                                ShortIterator c,
                                ShortTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(ShortStream a,
                                ShortStream b,
                                ShortBiFunction<R> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(ShortStream a,
                                ShortStream b,
                                ShortStream c,
                                ShortTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends ShortStream> c,
                                ShortNFunction<R> zipFunction)

Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(short[] a,
                                short[] b,
                                short valueForNoneA,
                                short valueForNoneB,
                                ShortBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(short[] a,
                                short[] b,
                                short[] c,
                                short valueForNoneA,
                                short valueForNoneB,
                                short valueForNoneC,
                                ShortTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(ShortIterator a,
                                ShortIterator b,
                                short valueForNoneA,
                                short valueForNoneB,
                                ShortBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(ShortIterator a,
                                ShortIterator b,
                                ShortIterator c,
                                short valueForNoneA,
                                short valueForNoneB,
                                short valueForNoneC,
                                ShortTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(ShortStream a,
                                ShortStream b,
                                short valueForNoneA,
                                short valueForNoneB,
                                ShortBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(ShortStream a,
                                ShortStream b,
                                ShortStream c,
                                short valueForNoneA,
                                short valueForNoneB,
                                short valueForNoneC,
                                ShortTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends ShortStream> c,
                                short[] valuesForNone,
                                ShortNFunction<R> zipFunction)

Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(int[] a,
                                int[] b,
                                IntBiFunction<R> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(int[] a,
                                int[] b,
                                int[] c,
                                IntTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(IntIterator a,
                                IntIterator b,
                                IntBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(IntIterator a,
                                IntIterator b,
                                IntIterator c,
                                IntTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(IntStream a,
                                IntStream b,
                                IntBiFunction<R> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(IntStream a,
                                IntStream b,
                                IntStream c,
                                IntTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends IntStream> c,
                                IntNFunction<R> zipFunction)

Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(int[] a,
                                int[] b,
                                int valueForNoneA,
                                int valueForNoneB,
                                IntBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(int[] a,
                                int[] b,
                                int[] c,
                                int valueForNoneA,
                                int valueForNoneB,
                                int valueForNoneC,
                                IntTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(IntIterator a,
                                IntIterator b,
                                int valueForNoneA,
                                int valueForNoneB,
                                IntBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(IntIterator a,
                                IntIterator b,
                                IntIterator c,
                                int valueForNoneA,
                                int valueForNoneB,
                                int valueForNoneC,
                                IntTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(IntStream a,
                                IntStream b,
                                int valueForNoneA,
                                int valueForNoneB,
                                IntBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(IntStream a,
                                IntStream b,
                                IntStream c,
                                int valueForNoneA,
                                int valueForNoneB,
                                int valueForNoneC,
                                IntTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends IntStream> c,
                                int[] valuesForNone,
                                IntNFunction<R> zipFunction)

Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(long[] a,
                                long[] b,
                                LongBiFunction<R> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(long[] a,
                                long[] b,
                                long[] c,
                                LongTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(LongIterator a,
                                LongIterator b,
                                LongBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(LongIterator a,
                                LongIterator b,
                                LongIterator c,
                                LongTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(LongStream a,
                                LongStream b,
                                LongBiFunction<R> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(LongStream a,
                                LongStream b,
                                LongStream c,
                                LongTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends LongStream> c,
                                LongNFunction<R> zipFunction)

Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(long[] a,
                                long[] b,
                                long valueForNoneA,
                                long valueForNoneB,
                                LongBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(long[] a,
                                long[] b,
                                long[] c,
                                long valueForNoneA,
                                long valueForNoneB,
                                long valueForNoneC,
                                LongTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(LongIterator a,
                                LongIterator b,
                                long valueForNoneA,
                                long valueForNoneB,
                                LongBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(LongIterator a,
                                LongIterator b,
                                LongIterator c,
                                long valueForNoneA,
                                long valueForNoneB,
                                long valueForNoneC,
                                LongTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(LongStream a,
                                LongStream b,
                                long valueForNoneA,
                                long valueForNoneB,
                                LongBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(LongStream a,
                                LongStream b,
                                LongStream c,
                                long valueForNoneA,
                                long valueForNoneB,
                                long valueForNoneC,
                                LongTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends LongStream> c,
                                long[] valuesForNone,
                                LongNFunction<R> zipFunction)

Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(float[] a,
                                float[] b,
                                FloatBiFunction<R> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(float[] a,
                                float[] b,
                                float[] c,
                                FloatTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(FloatIterator a,
                                FloatIterator b,
                                FloatBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(FloatIterator a,
                                FloatIterator b,
                                FloatIterator c,
                                FloatTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(FloatStream a,
                                FloatStream b,
                                FloatBiFunction<R> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(FloatStream a,
                                FloatStream b,
                                FloatStream c,
                                FloatTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends FloatStream> c,
                                FloatNFunction<R> zipFunction)

Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(float[] a,
                                float[] b,
                                float valueForNoneA,
                                float valueForNoneB,
                                FloatBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(float[] a,
                                float[] b,
                                float[] c,
                                float valueForNoneA,
                                float valueForNoneB,
                                float valueForNoneC,
                                FloatTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(FloatIterator a,
                                FloatIterator b,
                                float valueForNoneA,
                                float valueForNoneB,
                                FloatBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(FloatIterator a,
                                FloatIterator b,
                                FloatIterator c,
                                float valueForNoneA,
                                float valueForNoneB,
                                float valueForNoneC,
                                FloatTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(FloatStream a,
                                FloatStream b,
                                float valueForNoneA,
                                float valueForNoneB,
                                FloatBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(FloatStream a,
                                FloatStream b,
                                FloatStream c,
                                float valueForNoneA,
                                float valueForNoneB,
                                float valueForNoneC,
                                FloatTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends FloatStream> c,
                                float[] valuesForNone,
                                FloatNFunction<R> zipFunction)

Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(double[] a,
                                double[] b,
                                DoubleBiFunction<R> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(double[] a,
                                double[] b,
                                double[] c,
                                DoubleTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(DoubleIterator a,
                                DoubleIterator b,
                                DoubleBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(DoubleIterator a,
                                DoubleIterator b,
                                DoubleIterator c,
                                DoubleTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(DoubleStream a,
                                DoubleStream b,
                                DoubleBiFunction<R> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(DoubleStream a,
                                DoubleStream b,
                                DoubleStream c,
                                DoubleTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends DoubleStream> c,
                                DoubleNFunction<R> zipFunction)

Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(double[] a,
                                double[] b,
                                double valueForNoneA,
                                double valueForNoneB,
                                DoubleBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(double[] a,
                                double[] b,
                                double[] c,
                                double valueForNoneA,
                                double valueForNoneB,
                                double valueForNoneC,
                                DoubleTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(DoubleIterator a,
                                DoubleIterator b,
                                double valueForNoneA,
                                double valueForNoneB,
                                DoubleBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(DoubleIterator a,
                                DoubleIterator b,
                                DoubleIterator c,
                                double valueForNoneA,
                                double valueForNoneB,
                                double valueForNoneC,
                                DoubleTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(DoubleStream a,
                                DoubleStream b,
                                double valueForNoneA,
                                double valueForNoneB,
                                DoubleBiFunction<R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(DoubleStream a,
                                DoubleStream b,
                                DoubleStream c,
                                double valueForNoneA,
                                double valueForNoneB,
                                double valueForNoneC,
                                DoubleTriFunction<R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <R> Stream<R> zip(java.util.Collection<? extends DoubleStream> c,
                                double[] valuesForNone,
                                DoubleNFunction<R> zipFunction)

Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

zip

public static <A,B,R> Stream<R> zip(A[] a,
                                    B[] b,
                                    BiFunction<? super A,? super B,R> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <A,B,C,R> Stream<R> zip(A[] a,
                                      B[] b,
                                      C[] c,
                                      TriFunction<? super A,? super B,? super C,R> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <A,B,R> Stream<R> zip(java.util.Collection<? extends A> a,
                                    java.util.Collection<? extends B> b,
                                    BiFunction<? super A,? super B,R> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <A,B,C,R> Stream<R> zip(java.util.Collection<? extends A> a,
                                      java.util.Collection<? extends B> b,
                                      java.util.Collection<? extends C> c,
                                      TriFunction<? super A,? super B,? super C,R> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <A,B,R> Stream<R> zip(java.util.Iterator<? extends A> a,
                                    java.util.Iterator<? extends B> b,
                                    BiFunction<? super A,? super B,R> zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <A,B,C,R> Stream<R> zip(java.util.Iterator<? extends A> a,
                                      java.util.Iterator<? extends B> b,
                                      java.util.Iterator<? extends C> c,
                                      TriFunction<? super A,? super B,? super C,R> zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <A,B,R> Stream<R> zip(Stream<? extends A> a,
                                    Stream<? extends B> b,
                                    BiFunction<? super A,? super B,R> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <A,B,C,R> Stream<R> zip(Stream<? extends A> a,
                                      Stream<? extends B> b,
                                      Stream<? extends C> c,
                                      TriFunction<? super A,? super B,? super C,R> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

Returns:

zip

public static <T,R> Stream<R> zip(java.util.Collection<? extends Stream<? extends T>> c,
                                  Function<? super java.util.List<? extends T>,R> zipFunction)

Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

zipFunction -

Returns:

zipp

public static <T,R> Stream<R> zipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                   Function<? super java.util.List<? extends T>,R> zipFunction)

zip

public static <A,B,R> Stream<R> zip(A[] a,
                                    B[] b,
                                    A valueForNoneA,
                                    B valueForNoneB,
                                    BiFunction<? super A,? super B,R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <A,B,C,R> Stream<R> zip(A[] a,
                                      B[] b,
                                      C[] c,
                                      A valueForNoneA,
                                      B valueForNoneB,
                                      C valueForNoneC,
                                      TriFunction<? super A,? super B,? super C,R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <A,B,R> Stream<R> zip(java.util.Collection<? extends A> a,
                                    java.util.Collection<? extends B> b,
                                    A valueForNoneA,
                                    B valueForNoneB,
                                    BiFunction<? super A,? super B,R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <A,B,C,R> Stream<R> zip(java.util.Collection<? extends A> a,
                                      java.util.Collection<? extends B> b,
                                      java.util.Collection<? extends C> c,
                                      A valueForNoneA,
                                      B valueForNoneB,
                                      C valueForNoneC,
                                      TriFunction<? super A,? super B,? super C,R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <A,B,R> Stream<R> zip(java.util.Iterator<? extends A> a,
                                    java.util.Iterator<? extends B> b,
                                    A valueForNoneA,
                                    B valueForNoneB,
                                    BiFunction<? super A,? super B,R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <A,B,C,R> Stream<R> zip(java.util.Iterator<? extends A> a,
                                      java.util.Iterator<? extends B> b,
                                      java.util.Iterator<? extends C> c,
                                      A valueForNoneA,
                                      B valueForNoneB,
                                      C valueForNoneC,
                                      TriFunction<? super A,? super B,? super C,R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <A,B,R> Stream<R> zip(Stream<? extends A> a,
                                    Stream<? extends B> b,
                                    A valueForNoneA,
                                    B valueForNoneB,
                                    BiFunction<? super A,? super B,R> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <A,B,C,R> Stream<R> zip(Stream<? extends A> a,
                                      Stream<? extends B> b,
                                      Stream<? extends C> c,
                                      A valueForNoneA,
                                      B valueForNoneB,
                                      C valueForNoneC,
                                      TriFunction<? super A,? super B,? super C,R> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <T,R> Stream<R> zip(java.util.Collection<? extends Stream<? extends T>> c,
                                  java.lang.Object[] valuesForNone,
                                  Function<? super java.util.List<? extends T>,R> zipFunction)

Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

zipp

public static <T,R> Stream<R> zipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                   java.lang.Object[] valuesForNone,
                                   Function<? super java.util.List<? extends T>,R> zipFunction)

Parameters:

c -

valuesForNone - value to fill for any iterator runs out of values.

zipFunction -

Returns:

parallelZip

public static <A,B,R> Stream<R> parallelZip(java.util.Iterator<? extends A> a,
                                            java.util.Iterator<? extends B> b,
                                            BiFunction<? super A,? super B,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

zipFunction -

Returns:

parallelZip

public static <A,B,R> Stream<R> parallelZip(java.util.Iterator<? extends A> a,
                                            java.util.Iterator<? extends B> b,
                                            BiFunction<? super A,? super B,R> zipFunction,
                                            int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZip

public static <A,B,C,R> Stream<R> parallelZip(java.util.Iterator<? extends A> a,
                                              java.util.Iterator<? extends B> b,
                                              java.util.Iterator<? extends C> c,
                                              TriFunction<? super A,? super B,? super C,R> zipFunction)

parallelZip

public static <A,B,C,R> Stream<R> parallelZip(java.util.Iterator<? extends A> a,
                                              java.util.Iterator<? extends B> b,
                                              java.util.Iterator<? extends C> c,
                                              TriFunction<? super A,? super B,? super C,R> zipFunction,
                                              int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

c -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZip

public static <A,B,R> Stream<R> parallelZip(Stream<A> a,
                                            Stream<B> b,
                                            BiFunction<? super A,? super B,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

zipFunction -

Returns:

parallelZip

public static <A,B,R> Stream<R> parallelZip(Stream<A> a,
                                            Stream<B> b,
                                            BiFunction<? super A,? super B,R> zipFunction,
                                            int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZip

public static <A,B,C,R> Stream<R> parallelZip(Stream<A> a,
                                              Stream<B> b,
                                              Stream<C> c,
                                              TriFunction<? super A,? super B,? super C,R> zipFunction)

parallelZip

public static <A,B,C,R> Stream<R> parallelZip(Stream<A> a,
                                              Stream<B> b,
                                              Stream<C> c,
                                              TriFunction<? super A,? super B,? super C,R> zipFunction,
                                              int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

c -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZip

public static <T,R> Stream<R> parallelZip(java.util.Collection<? extends Stream<? extends T>> c,
                                          Function<? super java.util.List<? extends T>,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

c -

zipFunction -

Returns:

parallelZip

public static <T,R> Stream<R> parallelZip(java.util.Collection<? extends Stream<? extends T>> c,
                                          Function<? super java.util.List<? extends T>,R> zipFunction,
                                          int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

c -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZipp

public static <T,R> Stream<R> parallelZipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                           Function<? super java.util.List<? extends T>,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

c -

zipFunction -

Returns:

parallelZipp

public static <T,R> Stream<R> parallelZipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                           Function<? super java.util.List<? extends T>,R> zipFunction,
                                           int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

c -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZip

public static <A,B,R> Stream<R> parallelZip(java.util.Iterator<? extends A> a,
                                            java.util.Iterator<? extends B> b,
                                            A valueForNoneA,
                                            B valueForNoneB,
                                            BiFunction<? super A,? super B,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

valueForNoneA -

valueForNoneB -

zipFunction -

Returns:

parallelZip

public static <A,B,R> Stream<R> parallelZip(java.util.Iterator<? extends A> a,
                                            java.util.Iterator<? extends B> b,
                                            A valueForNoneA,
                                            B valueForNoneB,
                                            BiFunction<? super A,? super B,R> zipFunction,
                                            int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

valueForNoneA -

valueForNoneB -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZip

public static <A,B,C,R> Stream<R> parallelZip(java.util.Iterator<? extends A> a,
                                              java.util.Iterator<? extends B> b,
                                              java.util.Iterator<? extends C> c,
                                              A valueForNoneA,
                                              B valueForNoneB,
                                              C valueForNoneC,
                                              TriFunction<? super A,? super B,? super C,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

c -

valueForNoneA -

valueForNoneB -

valueForNoneC -

zipFunction -

Returns:

parallelZip

public static <A,B,C,R> Stream<R> parallelZip(java.util.Iterator<? extends A> a,
                                              java.util.Iterator<? extends B> b,
                                              java.util.Iterator<? extends C> c,
                                              A valueForNoneA,
                                              B valueForNoneB,
                                              C valueForNoneC,
                                              TriFunction<? super A,? super B,? super C,R> zipFunction,
                                              int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

c -

valueForNoneA -

valueForNoneB -

valueForNoneC -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZip

public static <A,B,R> Stream<R> parallelZip(Stream<A> a,
                                            Stream<B> b,
                                            A valueForNoneA,
                                            B valueForNoneB,
                                            BiFunction<? super A,? super B,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

valueForNoneA -

valueForNoneB -

zipFunction -

Returns:

parallelZip

public static <A,B,R> Stream<R> parallelZip(Stream<A> a,
                                            Stream<B> b,
                                            A valueForNoneA,
                                            B valueForNoneB,
                                            BiFunction<? super A,? super B,R> zipFunction,
                                            int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

valueForNoneA -

valueForNoneB -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZip

public static <A,B,C,R> Stream<R> parallelZip(Stream<A> a,
                                              Stream<B> b,
                                              Stream<C> c,
                                              A valueForNoneA,
                                              B valueForNoneB,
                                              C valueForNoneC,
                                              TriFunction<? super A,? super B,? super C,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

c -

valueForNoneA -

valueForNoneB -

valueForNoneC -

zipFunction -

Returns:

parallelZip

public static <A,B,C,R> Stream<R> parallelZip(Stream<A> a,
                                              Stream<B> b,
                                              Stream<C> c,
                                              A valueForNoneA,
                                              B valueForNoneB,
                                              C valueForNoneC,
                                              TriFunction<? super A,? super B,? super C,R> zipFunction,
                                              int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

a -

b -

c -

valueForNoneA -

valueForNoneB -

valueForNoneC -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZip

public static <T,R> Stream<R> parallelZip(java.util.Collection<? extends Stream<? extends T>> c,
                                          java.lang.Object[] valuesForNone,
                                          Function<? super java.util.List<? extends T>,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

c -

valuesForNone -

zipFunction -

Returns:

parallelZip

public static <T,R> Stream<R> parallelZip(java.util.Collection<? extends Stream<? extends T>> c,
                                          java.lang.Object[] valuesForNone,
                                          Function<? super java.util.List<? extends T>,R> zipFunction,
                                          int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

c -

valuesForNone -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

parallelZipp

public static <T,R> Stream<R> parallelZipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                           java.lang.Object[] valuesForNone,
                                           Function<? super java.util.List<? extends T>,R> zipFunction)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

c -

valuesForNone -

zipFunction -

Returns:

parallelZipp

public static <T,R> Stream<R> parallelZipp(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                           java.lang.Object[] valuesForNone,
                                           Function<? super java.util.List<? extends T>,R> zipFunction,
                                           int queueSize)

Put the stream in try-catch to stop the back-end reading thread if error happens
try (Stream stream = Stream.parallelZip(a, b, zipFunction)) { stream.forEach(N::println); }

Parameters:

c -

valuesForNone -

zipFunction -

queueSize - for each iterator. Default value is 8

Returns:

merge

public static <T> Stream<T> merge(T[] a,
                                  T[] b,
                                  BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T> Stream<T> merge(T[] a,
                                  T[] b,
                                  T[] c,
                                  BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T> Stream<T> merge(java.util.Collection<? extends T> a,
                                  java.util.Collection<? extends T> b,
                                  BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T> Stream<T> merge(java.util.Collection<? extends T> a,
                                  java.util.Collection<? extends T> b,
                                  java.util.Collection<? extends T> c,
                                  BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T> Stream<T> merge(java.util.Iterator<? extends T> a,
                                  java.util.Iterator<? extends T> b,
                                  BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T> Stream<T> merge(java.util.Iterator<? extends T> a,
                                  java.util.Iterator<? extends T> b,
                                  java.util.Iterator<? extends T> c,
                                  BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T> Stream<T> merge(Stream<? extends T> a,
                                  Stream<? extends T> b,
                                  BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T> Stream<T> merge(Stream<? extends T> a,
                                  Stream<? extends T> b,
                                  Stream<? extends T> c,
                                  BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

merge

public static <T> Stream<T> merge(java.util.Collection<? extends Stream<? extends T>> c,
                                  BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

mergge

public static <T> Stream<T> mergge(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                   BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

parallelMerge

public static <T> Stream<T> parallelMerge(java.util.Collection<? extends Stream<? extends T>> c,
                                          BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

parallelMerge

public static <T> Stream<T> parallelMerge(java.util.Collection<? extends Stream<? extends T>> c,
                                          BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector,
                                          int maxThreadNum)

Parameters:

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

maxThreadNum -

Returns:

parallelMergge

public static <T> Stream<T> parallelMergge(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                           BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector)

Parameters:

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

parallelMergge

public static <T> Stream<T> parallelMergge(java.util.Collection<? extends java.util.Iterator<? extends T>> c,
                                           BiFunction<? super T,? super T,com.landawn.abacus.util.Nth> nextSelector,
                                           int maxThreadNum)

Parameters:

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

maxThreadNum -

Returns:

carry

public S carry(C action)

Description copied from interface: BaseStream

Same as peek

Specified by:

carry in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.peek(Object)

sliding

public Stream<S> sliding(int windowSize)

Specified by:

sliding in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.sliding(int, int)

slidingToList

public Stream<PL> slidingToList(int windowSize)

Specified by:

slidingToList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.sliding(int, int)

shuffled

public S shuffled()

Description copied from interface: BaseStream

This method only run sequentially, even in parallel stream and all elements will be loaded to memory.

Specified by:

shuffled in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

toImmutableList

public ImmutableList<T> toImmutableList()

Specified by:

toImmutableList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

toImmutableSet

public ImmutableSet<T> toImmutableSet()

Specified by:

toImmutableSet in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

println

public void println()

Specified by:

println in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

isParallel

public boolean isParallel()

Description copied from interface: BaseStream

Returns whether this stream, if a terminal operation were to be executed, would execute in parallel. Calling this method after invoking an terminal stream operation method may yield unpredictable results.

Specified by:

isParallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

true if this stream would execute in parallel if executed

sequential

public S sequential()

Description copied from interface: BaseStream

Returns an equivalent stream that is sequential. May return itself, either because the stream was already sequential, or because the underlying stream state was modified to be sequential.

Specified by:

sequential in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

a sequential stream

parallel

public S parallel()

Description copied from interface: BaseStream

Returns an equivalent stream that is parallel. May return itself if the stream was already parallel. Any parallel should be closed by try-catch or call tried before last step.

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

a parallel stream

See Also:

BaseStream.parallel(int, Splitor)

parallel

public S parallel(int maxThreadNum)

Description copied from interface: BaseStream

Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same maxThreadNum as the specified one.

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.parallel(int, Splitor)

parallel

public S parallel(BaseStream.Splitor splitor)

Description copied from interface: BaseStream

Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same splitor as the specified one.

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.parallel(int, Splitor)

maxThreadNum

public int maxThreadNum()

Description copied from interface: BaseStream

Return the underlying maxThreadNum if the stream is parallel, otherwise 1 is returned.

Specified by:

maxThreadNum in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

maxThreadNum

public S maxThreadNum(int maxThreadNum)

Description copied from interface: BaseStream

Returns a parallel stream with the specified maxThreadNum . Or return itself, either because the stream was already parallel with same maxThreadNum, or because it's a sequential stream.

Specified by:

maxThreadNum in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

splitor

public BaseStream.Splitor splitor()

Description copied from interface: BaseStream

Return the underlying splitor if the stream is parallel, otherwise the default value splitor.ITERATOR is returned.

Specified by:

splitor in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

splitor

public S splitor(BaseStream.Splitor splitor)

Description copied from interface: BaseStream

Returns a parallel stream with the specified splitor . Or return itself, either because the stream was already parallel with same splitor, or because it's a sequential stream.

Specified by:

splitor in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

tried

public Try<S> tried()

Specified by:

tried in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

close

public void close()

Description copied from interface: BaseStream

Closes this stream, causing all close handlers for this stream pipeline to be called.

Specified by:

close in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Specified by:

close in interface java.lang.AutoCloseable

See Also:

AutoCloseable.close()