Uses of Class
com.landawn.abacus.util.stream.Stream

Packages that use Stream

Package	Description
com.landawn.abacus.guava
com.landawn.abacus.http
com.landawn.abacus.util
com.landawn.abacus.util.stream

Uses of Stream in com.landawn.abacus.guava

Methods in com.landawn.abacus.guava that return Stream

Modifier and Type	Method	Description
Stream<T>	Traverser.breadthFirst(T startNode)	Returns an unmodifiable Iterable over the nodes reachable from startNode, in the order of a breadth-first traversal.
Stream<T>	Traverser.depthFirstPostOrder(T startNode)	Returns an unmodifiable Iterable over the nodes reachable from startNode, in the order of a depth-first post-order traversal.
Stream<T>	Traverser.depthFirstPreOrder(T startNode)	Returns an unmodifiable Iterable over the nodes reachable from startNode, in the order of a depth-first pre-order traversal.

Uses of Stream in com.landawn.abacus.http

Methods in com.landawn.abacus.http that return Stream

Modifier and Type	Method	Description
static Stream<Tuple.Tuple2<Map<String,Object>,HttpResponse>>	HARUtil.streamMultiRequstsByHAR(File har, Predicate<String> filterForTargetUrl)	http://www.softwareishard.com/har/viewer/ https://confluence.atlassian.com/kb/generating-har-files-and-analyzing-web-requests-720420612.html
static Stream<Tuple.Tuple2<Map<String,Object>,HttpResponse>>	HARUtil.streamMultiRequstsByHAR(String har, Predicate<String> filterForTargetUrl)	http://www.softwareishard.com/har/viewer/ https://confluence.atlassian.com/kb/generating-har-files-and-analyzing-web-requests-720420612.html

Uses of Stream in com.landawn.abacus.util

Methods in com.landawn.abacus.util that return Stream

Modifier and Type	Method	Description
Stream<Stream<Sheet.Cell<R,C,E>>>	Sheet.cellsC()
Stream<Stream<Sheet.Cell<R,C,E>>>	Sheet.cellsC(int fromColumnIndex, int toColumnIndex)
Stream<Sheet.Cell<R,C,E>>	Sheet.cellsH()
Stream<Sheet.Cell<R,C,E>>	Sheet.cellsH(int rowIndex)
Stream<Sheet.Cell<R,C,E>>	Sheet.cellsH(int fromRowIndex, int toRowIndex)
Stream<Stream<Sheet.Cell<R,C,E>>>	Sheet.cellsR()
Stream<Stream<Sheet.Cell<R,C,E>>>	Sheet.cellsR(int fromRowIndex, int toRowIndex)
Stream<Sheet.Cell<R,C,E>>	Sheet.cellsV()
Stream<Sheet.Cell<R,C,E>>	Sheet.cellsV(int columnIndex)
Stream<Sheet.Cell<R,C,E>>	Sheet.cellsV(int fromColumnIndex, int toColumnIndex)
Stream<String>	DataSet.columnNames()
Stream<String>	RowDataSet.columnNames()
Stream<ImmutableList<Object>>	DataSet.columns()
Stream<ImmutableList<Object>>	RowDataSet.columns()
Stream<Pair<C,Stream<E>>>	Sheet.columns()
Stream<Pair<C,Stream<E>>>	Sheet.columns(int fromColumnIndex, int toColumnIndex)
Stream<DataSet>	DataSet.cube(Collection<String> columnNames)
<E extends Exception> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper)
<T, E extends Exception, E2 extends Exception> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E2> func)
<T, E extends Exception> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Collector<T,?,?> collector)
<U, E extends Exception, E2 extends Exception> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,U,E2> rowMapper, Collector<? super U,?,?> collector)
<E extends Exception> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass)
<E extends Exception> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[],?,?> collector)
<T, E extends Exception> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Collector<T,?,?> collector)
<U, E extends Exception> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,U,E> rowMapper, Collector<? super U,?,?> collector)
Stream<DataSet>	DataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass)
Stream<DataSet>	DataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[],?,?> collector)
Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames)
<E extends Exception> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper)
<T, E extends Exception, E2 extends Exception> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E2> func)
<T, E extends Exception> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Collector<T,?,?> collector)
<U, E extends Exception, E2 extends Exception> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,U,E2> rowMapper, Collector<? super U,?,?> collector)
<E extends Exception> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass)
<E extends Exception> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[],?,?> collector)
<T, E extends Exception> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Collector<T,?,?> collector)
<U, E extends Exception> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,U,E> rowMapper, Collector<? super U,?,?> collector)
Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass)
Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[],?,?> collector)
Stream<T>	LongMultiset.flatStream()
Stream<T>	Multiset.flatStream()
Stream<Stream<IntPair>>	Sheet.pointsC()
Stream<Stream<IntPair>>	Sheet.pointsC(int fromColumnIndex, int toColumnIndex)
Stream<IntPair>	Sheet.pointsH()
Stream<IntPair>	Sheet.pointsH(int rowIndex)
Stream<IntPair>	Sheet.pointsH(int fromRowIndex, int toRowIndex)
Stream<Stream<IntPair>>	Sheet.pointsR()
Stream<Stream<IntPair>>	Sheet.pointsR(int fromRowIndex, int toRowIndex)
Stream<IntPair>	Sheet.pointsV()
Stream<IntPair>	Sheet.pointsV(int columnIndex)
Stream<IntPair>	Sheet.pointsV(int fromColumnIndex, int toColumnIndex)
Stream<DataSet>	DataSet.rollup(Collection<String> columnNames)
<E extends Exception> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper)
<T, E extends Exception, E2 extends Exception> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E2> func)
<T, E extends Exception> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Collector<T,?,?> collector)
<U, E extends Exception, E2 extends Exception> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,U,E2> rowMapper, Collector<? super U,?,?> collector)
<E extends Exception> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass)
<E extends Exception> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[],?,?> collector)
<T, E extends Exception> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Collector<T,?,?> collector)
<U, E extends Exception> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,U,E> rowMapper, Collector<? super U,?,?> collector)
Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass)
Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[],?,?> collector)
Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames)
<E extends Exception> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper)
<T, E extends Exception, E2 extends Exception> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E2> func)
<T, E extends Exception> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Collector<T,?,?> collector)
<U, E extends Exception, E2 extends Exception> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,U,E2> rowMapper, Collector<? super U,?,?> collector)
<E extends Exception> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass)
<E extends Exception> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,?,E> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[],?,?> collector)
<T, E extends Exception> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Collector<T,?,?> collector)
<U, E extends Exception> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray,U,E> rowMapper, Collector<? super U,?,?> collector)
Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass)
Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[],?,?> collector)
Stream<Pair<R,Stream<E>>>	Sheet.rows()
Stream<Pair<R,Stream<E>>>	Sheet.rows(int fromRowIndex, int toRowIndex)
Stream<DataSet>	DataSet.split(int chunkSize)	Returns consecutive sub lists of this DataSet, each of the same chunkSize (the list may be smaller), or an empty List if this DataSet is empty.
Stream<DataSet>	DataSet.split(Collection<String> columnNames, int chunkSize)	Returns consecutive sub lists of this DataSet, each of the same chunkSize (the list may be smaller), or an empty List if this DataSet is empty.
Stream<DataSet>	RowDataSet.split(int chunkSize)
Stream<DataSet>	RowDataSet.split(Collection<String> columnNames, int chunkSize)
static <T> Stream<T>	N.splitByCount(int maxCount, int totalSize, boolean sizeSmallerFirst, IntBiFunction<? extends T> func)	final int[] a = Array.rangeClosed(1, 7); splitByCount(5, 7, true, (fromIndex, toIndex) -> copyOfRange(a, fromIndex, toIndex)).forEach(Fn.println()); // [[1], [2], [3], [4, 5], [6, 7]] splitByCount(5, 7, false, (fromIndex, toIndex) -> copyOfRange(a, fromIndex, toIndex)).forEach(Fn.println()); // [[1, 2], [3, 4], [5], [6], [7]]
Stream<Map.Entry<String,String>>	Splitter.MapSplitter.splitToStream(CharSequence source)	Split to stream.
Stream<String>	Splitter.splitToStream(CharSequence source)	Split to stream.
<R> Stream<R>	BiIterator.stream(BiFunction<? super A,? super B,? extends R> mapper)
Stream<Boolean>	BooleanIterator.stream()
Stream<Boolean>	BooleanList.stream()
Stream<Boolean>	BooleanList.stream(int fromIndex, int toIndex)
Stream<T>	Builder.stream()
static <T> Stream<T>	CSVUtil.stream(Class<? extends T> targetType, File csvFile)
static <T> Stream<T>	CSVUtil.stream(Class<? extends T> targetType, File csvFile, Collection<String> selectColumnNames)
static <T> Stream<T>	CSVUtil.stream(Class<? extends T> targetType, File csvFile, Collection<String> selectColumnNames, long offset, long count, Predicate<String[]> filter)
static <T> Stream<T>	CSVUtil.stream(Class<? extends T> targetType, Reader csvReader, boolean closeReaderWhenStreamIsClosed)
static <T> Stream<T>	CSVUtil.stream(Class<? extends T> targetType, Reader csvReader, Collection<String> selectColumnNames, boolean closeReaderWhenStreamIsClosed)
static <T> Stream<T>	CSVUtil.stream(Class<? extends T> targetType, Reader csvReader, Collection<String> selectColumnNames, long offset, long count, boolean closeReaderWhenStreamIsClosed, Predicate<String[]> filter)
<T> Stream<T>	DataSet.stream(int fromRowIndex, int toRowIndex, IntFunction<? extends T> rowSupplier)
<T> Stream<T>	DataSet.stream(Class<? extends T> rowClass)
<T> Stream<T>	DataSet.stream(Class<? extends T> rowClass, int fromRowIndex, int toRowIndex)
<T> Stream<T>	DataSet.stream(Class<? extends T> entityClass, int fromRowIndex, int toRowIndex, Map<String,String> prefixAndFieldNameMap)
<T> Stream<T>	DataSet.stream(Class<? extends T> rowClass, Collection<String> columnNames)
<T> Stream<T>	DataSet.stream(Class<? extends T> rowClass, Collection<String> columnNames, int fromRowIndex, int toRowIndex)
<T> Stream<T>	DataSet.stream(Class<? extends T> entityClass, Collection<String> columnNames, int fromRowIndex, int toRowIndex, Map<String,String> prefixAndFieldNameMap)
<T> Stream<T>	DataSet.stream(Class<? extends T> entityClass, Collection<String> columnNames, Map<String,String> prefixAndFieldNameMap)
<T> Stream<T>	DataSet.stream(Class<? extends T> entityClass, Map<String,String> prefixAndFieldNameMap)
<T> Stream<T>	DataSet.stream(String columnName)
<T> Stream<T>	DataSet.stream(String columnName, int fromRowIndex, int toRowIndex)
<T> Stream<T>	DataSet.stream(Collection<String> columnNames, int fromRowIndex, int toRowIndex, IntFunction<? extends T> rowSupplier)
<T> Stream<T>	DataSet.stream(Collection<String> columnNames, IntFunction<? extends T> rowSupplier)
<T> Stream<T>	DataSet.stream(IntFunction<? extends T> rowSupplier)
Stream<T>	Holder.stream()
Stream<T>	ImmutableArray.stream()
Stream<String>	Joiner.stream()	The underline StringBuilder will be recycled after this method is called if resueStringBuilder is set to true, and should not continue to this instance.
Stream<T>	LongMultiset.stream()
Stream<Map.Entry<K,V>>	Multimap.stream()
Stream<T>	Multiset.stream()
Stream<T>	ObjIterator.stream()
Stream<DataSet>	PaginatedDataSet.stream()
Stream<Pair<L,R>>	Pair.stream()
<T, E extends Exception> Stream<T>	Pair.stream(Throwables.Function<? super Pair<L,R>,Stream<T>,E> func)
<T> Stream<T>	RowDataSet.stream(int fromRowIndex, int toRowIndex, IntFunction<? extends T> rowSupplier)
<T> Stream<T>	RowDataSet.stream(Class<? extends T> rowClass)
<T> Stream<T>	RowDataSet.stream(Class<? extends T> rowClass, int fromRowIndex, int toRowIndex)
<T> Stream<T>	RowDataSet.stream(Class<? extends T> entityClass, int fromRowIndex, int toRowIndex, Map<String,String> prefixAndFieldNameMap)
<T> Stream<T>	RowDataSet.stream(Class<? extends T> rowClass, Collection<String> columnNames)
<T> Stream<T>	RowDataSet.stream(Class<? extends T> rowClass, Collection<String> columnNames, int fromRowIndex, int toRowIndex)
<T> Stream<T>	RowDataSet.stream(Class<? extends T> entityClass, Collection<String> columnNames, int fromRowIndex, int toRowIndex, Map<String,String> prefixAndFieldNameMap)
<T> Stream<T>	RowDataSet.stream(Class<? extends T> entityClass, Collection<String> columnNames, Map<String,String> prefixAndFieldNameMap)
<T> Stream<T>	RowDataSet.stream(Class<? extends T> entityClass, Map<String,String> prefixAndFieldNameMap)
<T> Stream<T>	RowDataSet.stream(String columnName)
<T> Stream<T>	RowDataSet.stream(String columnName, int fromRowIndex, int toRowIndex)
<T> Stream<T>	RowDataSet.stream(Collection<String> columnNames, int fromRowIndex, int toRowIndex, IntFunction<? extends T> rowSupplier)
<T> Stream<T>	RowDataSet.stream(Collection<String> columnNames, IntFunction<? extends T> rowSupplier)
<T> Stream<T>	RowDataSet.stream(IntFunction<? extends T> rowSupplier)
<R> Stream<R>	TriIterator.stream(TriFunction<? super A,? super B,? super C,? extends R> mapper)
Stream<Triple<L,M,R>>	Triple.stream()
<T, E extends Exception> Stream<T>	Triple.stream(Throwables.Function<? super Triple<L,M,R>,Stream<T>,E> func)
Stream<TP>	Tuple.stream()
<T, E extends Exception> Stream<T>	Tuple.stream(Throwables.Function<? super TP,Stream<T>,E> func)
Stream<T>	u.Nullable.stream()
Stream<T>	u.Optional.stream()
Stream<Boolean>	u.OptionalBoolean.stream()
Stream<Stream<E>>	Sheet.streamC()
Stream<Stream<E>>	Sheet.streamC(int fromColumnIndex, int toColumnIndex)
Stream<E>	Sheet.streamH()
Stream<E>	Sheet.streamH(int rowIndex)
Stream<E>	Sheet.streamH(int fromRowIndex, int toRowIndex)
Stream<String>	Joiner.streamIfNotEmpty()	Returns a stream with the String value generated by toString() if at least one element/object/entry is appended, otherwise an empty Stream is returned.
Stream<T>	Holder.streamIfNotNull()	Returns a Stream with the value if value is not null, otherwise an empty Stream is returned.
Stream<T>	u.Nullable.streamIfNotNull()	Stream if not null.
Stream<Stream<E>>	Sheet.streamR()
Stream<Stream<E>>	Sheet.streamR(int fromRowIndex, int toRowIndex)
Stream<E>	Sheet.streamV()
Stream<E>	Sheet.streamV(int columnIndex)
Stream<E>	Sheet.streamV(int fromColumnIndex, int toColumnIndex)
Stream<T>	ExceptionalStream.unchecked()

Methods in com.landawn.abacus.util that return types with arguments of type Stream

Modifier and Type	Method	Description
Stream<Stream<Sheet.Cell<R,C,E>>>	Sheet.cellsC()
Stream<Stream<Sheet.Cell<R,C,E>>>	Sheet.cellsC(int fromColumnIndex, int toColumnIndex)
Stream<Stream<Sheet.Cell<R,C,E>>>	Sheet.cellsR()
Stream<Stream<Sheet.Cell<R,C,E>>>	Sheet.cellsR(int fromRowIndex, int toRowIndex)
ExceptionalStream<Stream<T>,E>	ExceptionalStream.collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible)
ExceptionalStream<Stream<T>,E>	ExceptionalStream.collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible)
Stream<Pair<C,Stream<E>>>	Sheet.columns()
Stream<Pair<C,Stream<E>>>	Sheet.columns(int fromColumnIndex, int toColumnIndex)
Stream<Stream<IntPair>>	Sheet.pointsC()
Stream<Stream<IntPair>>	Sheet.pointsC(int fromColumnIndex, int toColumnIndex)
Stream<Stream<IntPair>>	Sheet.pointsR()
Stream<Stream<IntPair>>	Sheet.pointsR(int fromRowIndex, int toRowIndex)
Stream<Pair<R,Stream<E>>>	Sheet.rows()
Stream<Pair<R,Stream<E>>>	Sheet.rows(int fromRowIndex, int toRowIndex)
ExceptionalStream<Stream<T>,E>	ExceptionalStream.sliding(int windowSize, int increment)
ExceptionalStream<Stream<T>,E>	ExceptionalStream.split(int chunkSize)
Stream<Stream<E>>	Sheet.streamC()
Stream<Stream<E>>	Sheet.streamC(int fromColumnIndex, int toColumnIndex)
Stream<Stream<E>>	Sheet.streamR()
Stream<Stream<E>>	Sheet.streamR(int fromRowIndex, int toRowIndex)

Methods in com.landawn.abacus.util with parameters of type Stream

Modifier and Type	Method	Description
static <T, E extends Exception> ExceptionalStream<T,E>	ExceptionalStream.of(Stream<? extends T> stream)
static <T, E extends Exception> ExceptionalStream<T,E>	ExceptionalStream.of(Stream<? extends T> stream, Class<E> exceptionType)
static <T> ExceptionalStream<T,RuntimeException>	ExceptionalStream.Seq.of(Stream<? extends T> stream)	Deprecated.

Method parameters in com.landawn.abacus.util with type arguments of type Stream

Modifier and Type	Method	Description
<T, E extends Exception> Stream<DataSet>	DataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T, E extends Exception> Stream<DataSet>	RowDataSet.cube(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<R> ExceptionalStream<R,E>	ExceptionalStream.flatMapp(Throwables.Function<? super T,? extends Stream<? extends R>,? extends E> mapper)
<T, E extends Exception> DataSet	DataSet.groupBy(String columnName, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T, E extends Exception> DataSet	DataSet.groupBy(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T, E extends Exception> DataSet	RowDataSet.groupBy(String columnName, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T, E extends Exception> DataSet	RowDataSet.groupBy(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T, E extends Exception> Stream<DataSet>	DataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<T, E extends Exception> Stream<DataSet>	RowDataSet.rollup(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Throwables.Function<Stream<T>,?,E> func)
<R> ExceptionalStream<R,E>	ExceptionalStream.sps(int maxThreadNum, Function<? super Stream<T>,? extends Stream<? extends R>> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
<R> ExceptionalStream<R,E>	ExceptionalStream.sps(int maxThreadNum, Function<? super Stream<T>,? extends Stream<? extends R>> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
<R> ExceptionalStream<R,E>	ExceptionalStream.sps(Function<? super Stream<T>,? extends Stream<? extends R>> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
<R> ExceptionalStream<R,E>	ExceptionalStream.sps(Function<? super Stream<T>,? extends Stream<? extends R>> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
<R> ExceptionalStream<R,E>	ExceptionalStream.spsFlatMap(int maxThreadNum, Throwables.Function<? super T,? extends Stream<? extends R>,E> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> ExceptionalStream<R,E>	ExceptionalStream.spsFlatMap(Throwables.Function<? super T,? extends Stream<? extends R>,E> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> ExceptionalStream<R,Exception>	ExceptionalStream.spsFlatMapE(int maxThreadNum, Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> ExceptionalStream<R,Exception>	ExceptionalStream.spsFlatMapE(Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<T, E extends Exception> Stream<T>	Pair.stream(Throwables.Function<? super Pair<L,R>,Stream<T>,E> func)
<T, E extends Exception> Stream<T>	Triple.stream(Throwables.Function<? super Triple<L,M,R>,Stream<T>,E> func)
<T, E extends Exception> Stream<T>	Tuple.stream(Throwables.Function<? super TP,Stream<T>,E> func)

Uses of Stream in com.landawn.abacus.util.stream

Subclasses of Stream in com.landawn.abacus.util.stream

Modifier and Type	Class	Description
static class	Stream.StreamEx<T>

Methods in com.landawn.abacus.util.stream that return Stream

Modifier and Type	Method	Description
abstract Stream<T>	Stream.append(Collection<? extends T> c)
final Stream<T>	Stream.append(T... a)
abstract Stream<T>	Stream.appendIfEmpty(Collection<? extends T> c)
final Stream<T>	Stream.appendIfEmpty(T... a)
abstract Stream<Byte>	ByteStream.boxed()
abstract Stream<Character>	CharStream.boxed()	Returns a Stream consisting of the elements of this stream, each boxed to an Chareger.
abstract Stream<Double>	DoubleStream.boxed()
abstract Stream<Float>	FloatStream.boxed()
abstract Stream<Integer>	IntStream.boxed()
abstract Stream<Long>	LongStream.boxed()
abstract Stream<Short>	ShortStream.boxed()
abstract Stream<T>	Stream.buffered()	Returns a new Stream with elements from a temporary queue which is filled by reading the elements from this Stream asynchronously with a new thread.
abstract Stream<T>	Stream.buffered(int bufferSize)	Returns a new Stream with elements from a temporary queue which is filled by reading the elements from this Stream asynchronously with a new thread.
abstract Stream<List<T>>	Stream.cartesianProduct(Collection<? extends Collection<? extends T>> cs)
final Stream<List<T>>	Stream.cartesianProduct(Collection<? extends T>... cs)
abstract Stream<ByteList>	ByteStream.collapse(ByteBiPredicate collapsible)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract Stream<CharList>	CharStream.collapse(CharBiPredicate collapsible)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract Stream<DoubleList>	DoubleStream.collapse(DoubleBiPredicate collapsible)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract Stream<FloatList>	FloatStream.collapse(FloatBiPredicate collapsible)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract Stream<IntList>	IntStream.collapse(IntBiPredicate collapsible)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract Stream<LongList>	LongStream.collapse(LongBiPredicate collapsible)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract Stream<ShortList>	ShortStream.collapse(ShortBiPredicate collapsible)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract Stream<Stream<T>>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible)
abstract Stream<T>	Stream.collapse(TriPredicate<? super T,? 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 <C extends Collection<T>> Stream<C>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible, Supplier<? extends C> supplier)
abstract <R> Stream<R>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible, Supplier<R> supplier, BiConsumer<? super R,? super T> accumulator)
abstract <R, A> Stream<R>	Stream.collapse(TriPredicate<? super T,? 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 <U> Stream<U>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible, U init, BiFunction<U,? super T,U> op)
abstract Stream<Stream<T>>	Stream.collapse(BiPredicate<? super T,? super T> collapsible)
abstract Stream<T>	Stream.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 <C extends Collection<T>> Stream<C>	Stream.collapse(BiPredicate<? super T,? super T> collapsible, Supplier<? extends C> supplier)
abstract <R> Stream<R>	Stream.collapse(BiPredicate<? super T,? super T> collapsible, Supplier<R> supplier, BiConsumer<? super R,? super T> accumulator)
abstract <R, A> Stream<R>	Stream.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 <U> Stream<U>	Stream.collapse(BiPredicate<? super T,? super T> collapsible, U init, BiFunction<U,? super T,U> op)
Stream<List<V>>	EntryStream.collapseByKey(BiPredicate<? super K,? super K> collapsible)
<R, A> Stream<R>	EntryStream.collapseByKey(BiPredicate<? super K,? super K> collapsible, Collector<? super V,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract Stream<List<T>>	Stream.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<List<T>>	Stream.combinations(int len)	Stream.of(1, 2, 3).combinations(2).forEach(Fn.println()); // output [1, 2] [1, 3] [2, 3]
abstract Stream<List<T>>	Stream.combinations(int len, boolean repeat)	It's same as N.cartesianProduct(N.repeat(toList(), len)) if repeat is true.
static <T> Stream<T>	Stream.concat(Stream<? extends T>... a)
static <T> Stream<T>	Stream.concat(Iterable<? extends T>... a)
static <T> Stream<T>	Stream.concat(Collection<? extends Stream<? extends T>> c)
static <T> Stream<T>	Stream.concat(Iterator<? extends T>... a)
static <T> Stream<T>	Stream.concat(T[]... a)
static <T> Stream<T>	Stream.concatIterables(Collection<? extends Iterable<? extends T>> c)
static <T> Stream<T>	Stream.concatIterators(Collection<? extends Iterator<? extends T>> c)
<K> Stream<Map.Entry<K,Integer>>	Stream.countBy(Function<? super T,? extends K> keyMapper)
final Stream<T>	Stream.defaultIfEmpty(Supplier<? extends Stream<T>> supplier)
final Stream<T>	Stream.defaultIfEmpty(T defaultValue)
static <T> Stream<T>	Stream.defer(Supplier<? extends Stream<T>> supplier)	Lazy evaluation.
abstract <U> Stream<T>	Stream.difference(Function<? super T,? extends U> mapper, Collection<U> c)	Except with the specified Collection by the values mapped by mapper.
Stream<T>	Stream.distinct(BinaryOperator<T> mergeFunction)	Distinct and merge duplicated elements.
Stream<T>	Stream.distinct(Predicate<? super Long> occurrencesFilter)	Distinct and filter by occurrences.
abstract Stream<T>	Stream.distinctBy(Function<? super T,?> keyMapper)	Distinct by the value mapped from keyMapper
<K> Stream<T>	Stream.distinctBy(Function<? super T,K> keyMapper, BinaryOperator<T> mergeFunction)	Distinct and merge duplicated elements.
<K> Stream<T>	Stream.distinctBy(Function<? super T,K> keyMapper, Predicate<? super Long> occurrencesFilter)	Distinct and filter by occurrences.
static <T> Stream<T>	Stream.empty()
Stream<Map.Entry<K,V>>	EntryStream.entries()
Stream<T>	Stream.filterE(Throwables.Predicate<? super T,? extends Exception> predicate)
abstract <R> Stream<R>	Stream.flatmap(Function<? super T,? extends Collection<? extends R>> mapper)
abstract <R> Stream<R>	Stream.flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
<R> Stream<R>	Stream.flatmapE(Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)
<R> Stream<R>	Stream.flatMapE(Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)
<R> Stream<R>	Stream.flatMapIfNotNull(Function<? super T,? extends Collection<? extends R>> mapper)
<U, R> Stream<R>	Stream.flatMapIfNotNull(Function<? super T,? extends Collection<? extends U>> mapper, Function<? super U,? extends Collection<? extends R>> mapper2)
abstract <T> Stream<T>	ByteStream.flatmapToObj(ByteFunction<? extends Collection<? extends T>> mapper)
abstract <T> Stream<T>	CharStream.flatmapToObj(CharFunction<? extends Collection<? extends T>> mapper)
abstract <T> Stream<T>	DoubleStream.flatmapToObj(DoubleFunction<? extends Collection<? extends T>> mapper)
abstract <T> Stream<T>	FloatStream.flatmapToObj(FloatFunction<? extends Collection<? extends T>> mapper)
abstract <T> Stream<T>	IntStream.flatmapToObj(IntFunction<? extends Collection<? extends T>> mapper)
abstract <T> Stream<T>	LongStream.flatmapToObj(LongFunction<? extends Collection<? extends T>> mapper)
abstract <T> Stream<T>	ShortStream.flatmapToObj(ShortFunction<? extends Collection<? extends T>> mapper)
abstract <T> Stream<T>	ByteStream.flatMapToObj(ByteFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	CharStream.flatMapToObj(CharFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	DoubleStream.flatMapToObj(DoubleFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	FloatStream.flatMapToObj(FloatFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	IntStream.flatMapToObj(IntFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	LongStream.flatMapToObj(LongFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	ShortStream.flatMapToObj(ShortFunction<? extends Stream<? extends T>> mapper)
static <T> Stream<T>	Stream.flatten(Collection<? extends Collection<? extends T>> c)
static <T> Stream<T>	Stream.flatten(T[][] a)
static <T> Stream<T>	Stream.flatten(T[][][] a)
static <T> Stream<T>	Stream.flatten(T[][] a, boolean vertically)
static <T> Stream<T>	Stream.flatten(T[][] a, T valueForNone, boolean vertically)
abstract <R> Stream<R>	Stream.flattMap(Function<? super T,R[]> mapper)
abstract <T> Stream<T>	ByteStream.flattMapToObj(ByteFunction<T[]> mapper)
abstract <T> Stream<T>	CharStream.flattMapToObj(CharFunction<T[]> mapper)
abstract <T> Stream<T>	DoubleStream.flattMapToObj(DoubleFunction<T[]> mapper)
abstract <T> Stream<T>	FloatStream.flattMapToObj(FloatFunction<T[]> mapper)
abstract <T> Stream<T>	IntStream.flattMapToObj(IntFunction<T[]> mapper)
abstract <T> Stream<T>	LongStream.flattMapToObj(LongFunction<T[]> mapper)
abstract <T> Stream<T>	ShortStream.flattMapToObj(ShortFunction<T[]> mapper)
static <T> Stream<T>	Stream.generate(Supplier<T> supplier)
abstract <K> Stream<Map.Entry<K,List<T>>>	Stream.groupBy(Function<? super T,? extends K> keyMapper)
abstract <K, V> Stream<Map.Entry<K,List<V>>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
abstract <K, V> Stream<Map.Entry<K,V>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
abstract <K, V> Stream<Map.Entry<K,V>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K,V>> mapFactory)
abstract <K, V> Stream<Map.Entry<K,List<V>>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Supplier<? extends Map<K,List<V>>> mapFactory)
abstract <K, V, A, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,A,D> downstream)
abstract <K, V, A, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
abstract <K> Stream<Map.Entry<K,List<T>>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Supplier<? extends Map<K,List<T>>> mapFactory)
abstract <K, A, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream)
abstract <K, A, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
Stream<IT>	BaseStream.indexed()	This method only runs sequentially, even in parallel stream.
Stream<Indexed<Map.Entry<K,V>>>	EntryStream.indexed()
abstract <U> Stream<T>	Stream.intersection(Function<? super T,? extends U> mapper, Collection<U> c)	Intersect with the specified Collection by the values mapped by mapper.
abstract Stream<T>	Stream.intersperse(T delimiter)	Stream.of(1).intersperse(9) --> [1] Stream.of(1, 2, 3).intersperse(9) --> [1, 9, 2, 9, 3] This method only runs sequentially, even in parallel stream.
static <T> Stream<T>	Stream.interval(long delay, long interval, TimeUnit unit, LongFunction<T> s)
static <T> Stream<T>	Stream.interval(long delay, long interval, TimeUnit unit, Supplier<T> s)
static <T> Stream<T>	Stream.interval(long delayInMillis, long intervalInMillis, LongFunction<T> s)
static <T> Stream<T>	Stream.interval(long delayInMillis, long intervalInMillis, Supplier<T> s)
static <T> Stream<T>	Stream.interval(long intervalInMillis, LongFunction<T> s)
static <T> Stream<T>	Stream.interval(long intervalInMillis, Supplier<T> s)
static <T> Stream<T>	Stream.iterate(BooleanSupplier hasNext, Supplier<? extends T> next)
static <T> Stream<T>	Stream.iterate(T init, BooleanSupplier hasNext, UnaryOperator<T> f)	Returns a sequential ordered Stream produced by iterative application of a function f to an initial element init, producing a Stream consisting of init, f(init), f(f(init)), etc.
static <T> Stream<T>	Stream.iterate(T init, Predicate<? super T> hasNext, UnaryOperator<T> f)
static <T> Stream<T>	Stream.iterate(T init, UnaryOperator<T> f)
static <T> Stream<T>	Stream.just(T e)
Stream<K>	EntryStream.keys()
abstract Stream<T>	Stream.last(int n)	A queue with size up to n will be maintained to filter out the last n elements.
static Stream<String>	Stream.lines(File file)
static Stream<String>	Stream.lines(File file, Charset charset)
static Stream<String>	Stream.lines(Reader reader)	It's user's responsibility to close the input reader after the stream is finished.
static Stream<String>	Stream.lines(Path path)
static Stream<String>	Stream.lines(Path path, Charset charset)
static Stream<File>	Stream.listFiles(File parentPath)
static Stream<File>	Stream.listFiles(File parentPath, boolean recursively)
abstract <R> Stream<R>	Stream.map(Function<? super T,? extends R> mapper)
<R> Stream<R>	Stream.mapE(Throwables.Function<? super T,? extends R,? extends Exception> mapper)
abstract Stream<T>	Stream.mapFirst(Function<? super T,? extends T> mapperForFirst)
abstract <R> Stream<R>	Stream.mapFirstOrElse(Function<? super T,? extends R> mapperForFirst, Function<? super T,? extends R> mapperForElse)
abstract Stream<T>	Stream.mapLast(Function<? super T,? extends T> mapperForLast)
abstract <R> Stream<R>	Stream.mapLastOrElse(Function<? super T,? extends R> mapperForLast, Function<? super T,? extends R> mapperForElse)
abstract <R> Stream<R>	Stream.mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper)
abstract <R> Stream<R>	Stream.mapPartial(Function<? super T,u.Optional<? extends R>> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract <R> Stream<R>	Stream.mapPartialJdk(Function<? super T,Optional<? extends R>> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
<K, V> Stream<NoCachingNoUpdating.DisposableEntry<K,V>>	Stream.mapToDisposableEntry(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)	Deprecated.
abstract <T> Stream<T>	ByteStream.mapToObj(ByteFunction<? extends T> mapper)
abstract <T> Stream<T>	CharStream.mapToObj(CharFunction<? extends T> mapper)	Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.
abstract <T> Stream<T>	DoubleStream.mapToObj(DoubleFunction<? extends T> mapper)
abstract <T> Stream<T>	FloatStream.mapToObj(FloatFunction<? extends T> mapper)
abstract <T> Stream<T>	IntStream.mapToObj(IntFunction<? extends T> mapper)
abstract <T> Stream<T>	LongStream.mapToObj(LongFunction<? extends T> mapper)
abstract <T> Stream<T>	ShortStream.mapToObj(ShortFunction<? extends T> mapper)
static <T> Stream<T>	Stream.merge(Stream<? extends T> a, Stream<? extends T> b, Stream<? extends T> c, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.merge(Stream<? extends T> a, Stream<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)
Stream<T>	Stream.merge(Stream<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)	Deprecated. replaced by mergeWith(Stream, BiFunction)
static <T> Stream<T>	Stream.merge(Iterable<? extends T> a, Iterable<? extends T> b, Iterable<? extends T> c, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.merge(Iterable<? extends T> a, Iterable<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.merge(Collection<? extends Stream<? extends T>> c, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.merge(Iterator<? extends T> a, Iterator<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.merge(Iterator<? extends T> a, Iterator<? extends T> b, Iterator<? extends T> c, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.merge(T[] a, T[] b, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.merge(T[] a, T[] b, T[] c, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.mergeIterables(Collection<? extends Iterable<? extends T>> collections, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.mergeIterators(Collection<? extends Iterator<? extends T>> iterators, BiFunction<? super T,? super T,MergeResult> nextSelector)
abstract Stream<T>	Stream.mergeWith(Stream<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)
abstract Stream<T>	Stream.mergeWith(Collection<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.observe(BlockingQueue<T> queue, Duration duration)	Sample code:
static <T> Stream<T>	Stream.observe(BlockingQueue<T> queue, BooleanSupplier hasMore, long maxWaitIntervalInMillis)	Sample code:
static Stream<Boolean>	Stream.of(boolean[] a)
static Stream<Boolean>	Stream.of(boolean[] a, int fromIndex, int toIndex)
static Stream<Byte>	Stream.of(byte[] a)
static Stream<Byte>	Stream.of(byte[] a, int fromIndex, int toIndex)
static Stream<Character>	Stream.of(char[] a)
static Stream<Character>	Stream.of(char[] a, int fromIndex, int toIndex)
static Stream<Double>	Stream.of(double[] a)
static Stream<Double>	Stream.of(double[] a, int fromIndex, int toIndex)
static Stream<Float>	Stream.of(float[] a)
static Stream<Float>	Stream.of(float[] a, int fromIndex, int toIndex)
static Stream<Integer>	Stream.of(int[] a)
static Stream<Integer>	Stream.of(int[] a, int fromIndex, int toIndex)
static Stream<Long>	Stream.of(long[] a)
static Stream<Long>	Stream.of(long[] a, int fromIndex, int toIndex)
static Stream<Short>	Stream.of(short[] a)
static Stream<Short>	Stream.of(short[] a, int fromIndex, int toIndex)
static <T> Stream<T>	Stream.of(u.Optional<T> op)
static <T> Stream<T>	Stream.of(Iterable<? extends T> iterable)
static <T> Stream<T>	Stream.of(Collection<? extends T> c)
static <T> Stream<T>	Stream.of(Collection<? extends T> c, int startIndex, int endIndex)
static <T> Stream<T>	Stream.of(Enumeration<? extends T> enumeration)
static <T> Stream<T>	Stream.of(Iterator<? extends T> iterator)
static <K, V> Stream<Map.Entry<K,V>>	Stream.of(Map<? extends K,? extends V> map)
static <T> Stream<T>	Stream.of(Optional<T> op)
static <T> Stream<T>	Stream.of(Stream<? extends T> stream)
static <T> Stream<T>	Stream.of(T... a)
static <T> Stream<T>	Stream.of(T[] a, int startIndex, int endIndex)
static <K> Stream<K>	Stream.ofKeys(Map<? extends K,?> map)
static <K, V> Stream<K>	Stream.ofKeys(Map<? extends K,? extends V> map, BiPredicate<? super K,? super V> filter)
static <K, V> Stream<K>	Stream.ofKeys(Map<? extends K,? extends V> map, Predicate<? super V> valueFilter)
static <T> Stream<T>	Stream.ofNullable(T e)	Returns an empty Stream if the specified t is null.
static <V> Stream<V>	Stream.ofValues(Map<?,? extends V> map)
static <K, V> Stream<V>	Stream.ofValues(Map<? extends K,? extends V> map, BiPredicate<? super K,? super V> filter)
static <K, V> Stream<V>	Stream.ofValues(Map<? extends K,? extends V> map, Predicate<? super K> keyFilter)
Stream<T>	Stream.onEachE(Throwables.Consumer<? super T,? extends Exception> action)
abstract Stream<List<T>>	Stream.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<List<T>>	Stream.orderedPermutations(Comparator<? super T> comparator)
<U> Stream<Pair<T,U>>	Stream.pairWith(Function<? super T,? extends U> extractor)
static <T> Stream<T>	Stream.parallelConcat(Stream<? extends T>... a)
static <T> Stream<T>	Stream.parallelConcat(Stream<? extends T>[] a, int readThreadNum, int bufferSize)	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>	Stream.parallelConcat(Iterable<? extends T>... a)
static <T> Stream<T>	Stream.parallelConcat(Iterable<? extends T>[] a, int readThreadNum, int bufferSize)
static <T> Stream<T>	Stream.parallelConcat(Collection<? extends Stream<? extends T>> c)
static <T> Stream<T>	Stream.parallelConcat(Collection<? extends Stream<? extends T>> c, int readThreadNum)
static <T> Stream<T>	Stream.parallelConcat(Collection<? extends Stream<? extends T>> c, int readThreadNum, int bufferSize)	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>	Stream.parallelConcat(Iterator<? extends T>... a)
static <T> Stream<T>	Stream.parallelConcat(Iterator<? extends T>[] a, int readThreadNum, int bufferSize)
static <T> Stream<T>	Stream.parallelConcatIterables(Collection<? extends Iterable<? extends T>> c)
static <T> Stream<T>	Stream.parallelConcatIterables(Collection<? extends Iterable<? extends T>> c, int readThreadNum)
static <T> Stream<T>	Stream.parallelConcatIterables(Collection<? extends Iterable<? extends T>> c, int readThreadNum, int bufferSize)	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>	Stream.parallelConcatIterators(Collection<? extends Iterator<? extends T>> c)
static <T> Stream<T>	Stream.parallelConcatIterators(Collection<? extends Iterator<? extends T>> c, int readThreadNum)
static <T> Stream<T>	Stream.parallelConcatIterators(Collection<? extends Iterator<? extends T>> c, int readThreadNum, int bufferSize)
static <T> Stream<T>	Stream.parallelMerge(Collection<? extends Stream<? extends T>> c, BiFunction<? super T,? super T,MergeResult> nextSelector)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
static <T> Stream<T>	Stream.parallelMerge(Collection<? extends Stream<? extends T>> c, BiFunction<? super T,? super T,MergeResult> nextSelector, int maxThreadNum)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
static <T> Stream<T>	Stream.parallelMergeIterables(Collection<? extends Iterable<? extends T>> collections, BiFunction<? super T,? super T,MergeResult> nextSelector)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
static <T> Stream<T>	Stream.parallelMergeIterables(Collection<? extends Iterable<? extends T>> collections, BiFunction<? super T,? super T,MergeResult> nextSelector, int maxThreadNum)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
static <T> Stream<T>	Stream.parallelMergeIterators(Collection<? extends Iterator<? extends T>> iterators, BiFunction<? super T,? super T,MergeResult> nextSelector)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
static <T> Stream<T>	Stream.parallelMergeIterators(Collection<? extends Iterator<? extends T>> iterators, BiFunction<? super T,? super T,MergeResult> nextSelector, int maxThreadNum)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
static <A, B, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, BiFunction<? super A,? super B,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Iterable<? extends A> a, Iterable<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Iterable<? extends A> a, Iterable<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterable<? extends A> a, Iterable<? extends B> b, Iterable<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterable<? extends A> a, Iterable<? extends B> b, Iterable<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterable<? extends A> a, Iterable<? extends B> b, Iterable<? extends C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterable<? extends A> a, Iterable<? extends B> b, Iterable<? extends C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Iterable<? extends A> a, Iterable<? extends B> b, BiFunction<? super A,? super B,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Iterable<? extends A> a, Iterable<? extends B> b, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZip(Collection<? extends Stream<? extends T>> c, Function<? super List<? extends T>,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZip(Collection<? extends Stream<? extends T>> c, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZip(Collection<? extends Stream<? extends T>> c, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZip(Collection<? extends Stream<? extends T>> c, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize, int maxThreadNumForZipFunction)
static <A, B, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, BiFunction<? super A,? super B,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize, int maxThreadNumForZipFunction)
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize, int maxThreadNumForZipFunction)
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize, int maxThreadNumForZipFunction)
static <T, R> Stream<R>	Stream.parallelZipIterables(Collection<? extends Iterable<? extends T>> collections, Function<? super List<? extends T>,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZipIterables(Collection<? extends Iterable<? extends T>> collections, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZipIterables(Collection<? extends Iterable<? extends T>> collections, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZipIterables(Collection<? extends Iterable<? extends T>> collections, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZipIterators(Collection<? extends Iterator<? extends T>> iterators, Function<? super List<? extends T>,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZipIterators(Collection<? extends Iterator<? extends T>> iterators, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZipIterators(Collection<? extends Iterator<? extends T>> iterators, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize, int maxThreadNumForZipFunction)
static <T, R> Stream<R>	Stream.parallelZipIterators(Collection<? extends Iterator<? extends T>> iterators, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZipIterators(Collection<? extends Iterator<? extends T>> iterators, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZipIterators(Collection<? extends Iterator<? extends T>> iterators, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize, int maxThreadNumForZipFunction)
abstract Stream<Map.Entry<Boolean,List<T>>>	Stream.partitionBy(Predicate<? super T> predicate)
abstract <A, D> Stream<Map.Entry<Boolean,D>>	Stream.partitionBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
abstract Stream<T>	Stream.peekFirst(Consumer<? super T> action)
Stream<T>	Stream.peekIf(BiPredicate<? super T,? super Long> predicate, Consumer<? super T> action)
Stream<T>	Stream.peekIf(Predicate<? super T> predicate, Consumer<? super T> action)
abstract Stream<T>	Stream.peekLast(Consumer<? super T> action)
abstract Stream<List<T>>	Stream.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 Stream<T>	Stream.prepend(Collection<? extends T> c)
final Stream<T>	Stream.prepend(T... a)
static Stream<Integer>	Stream.range(int startInclusive, int endExclusive)
static Stream<Integer>	Stream.range(int startInclusive, int endExclusive, int by)
static Stream<Long>	Stream.range(long startInclusive, long endExclusive)
static Stream<Long>	Stream.range(long startInclusive, long endExclusive, long by)
static Stream<Integer>	Stream.rangeClosed(int startInclusive, int endInclusive)
static Stream<Integer>	Stream.rangeClosed(int startInclusive, int endInclusive, int by)
static Stream<Long>	Stream.rangeClosed(long startInclusive, long endInclusive)
static Stream<Long>	Stream.rangeClosed(long startInclusive, long endInclusive, long by)
abstract <U> Stream<U>	Stream.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 <T> Stream<T>	ByteStream.rangeMapToObj(ByteBiPredicate sameRange, ByteBiFunction<? extends T> 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 <T> Stream<T>	CharStream.rangeMapToObj(CharBiPredicate sameRange, CharBiFunction<? extends T> 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 <T> Stream<T>	DoubleStream.rangeMapToObj(DoubleBiPredicate sameRange, DoubleBiFunction<? extends T> 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 <T> Stream<T>	FloatStream.rangeMapToObj(FloatBiPredicate sameRange, FloatBiFunction<? extends T> 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 <T> Stream<T>	IntStream.rangeMapToObj(IntBiPredicate sameRange, IntBiFunction<? extends T> 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 <T> Stream<T>	LongStream.rangeMapToObj(LongBiPredicate sameRange, LongBiFunction<? extends T> 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 <T> Stream<T>	ShortStream.rangeMapToObj(ShortBiPredicate sameRange, ShortBiFunction<? extends T> 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<T>	Stream.rateLimited(RateLimiter rateLimiter)
static <T> Stream<T>	Stream.repeat(T element, long n)
abstract Stream<T>	Stream.reverseSorted(Comparator<? super T> comparator)
abstract Stream<List<T>>	Stream.rollup()
abstract Stream<T>	Stream.scan(BiFunction<? super T,? super T,T> accumulator)	Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream.
abstract <U> Stream<U>	Stream.scan(U init, BiFunction<U,? super T,U> accumulator)	Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream.
abstract <U> Stream<U>	Stream.scan(U init, BiFunction<U,? super T,U> accumulator, boolean initIncluded)
<U> Stream<U>	Stream.select(Class<? extends U> targetType)	Select the elements belong to the specified targetType(including its subtype).
<R> Stream<R>	Stream.sjps(Function<? super Stream<T>,? extends Stream<? extends R>> op)	Temporarily switch the stream to Jdk parallel stream for operation ops and then switch back to sequence stream.
abstract Stream<T>	Stream.skipLast(int n)	A queue with size up to n will be maintained to filter out the last n elements.
abstract Stream<T>	Stream.skipNull()
abstract Stream<T>	Stream.skipRange(int startInclusive, int endExclusive)	Skip the range: [fromIndexInclusive, fromIndexInclusive]
Stream<T>	Stream.skipUntil(Predicate<? super T> predicate)
Stream<S>	BaseStream.sliding(int windowSize)
Stream<S>	BaseStream.sliding(int windowSize, int increment)	Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 1).forEach(Stream::println) output: [1, 2, 3] [2, 3, 4] [3, 4, 5] [4, 5, 6] [5, 6, 7] [6, 7, 8] ============================================================================ Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 3).forEach(Stream::println) output: [1, 2, 3] [4, 5, 6] [7, 8] ============================================================================ Stream.of(1, 2, 3, 4, 5, 6, 7, 5).sliding(3, 5).forEach(Stream::println) output: [1, 2, 3] [6, 7, 8] This method only runs sequentially, even in parallel stream.
Stream<EntryStream<K,V>>	EntryStream.sliding(int windowSize, int increment)
abstract <C extends Collection<T>> Stream<C>	Stream.sliding(int windowSize, int increment, IntFunction<? extends C> collectionSupplier)
abstract <A, R> Stream<R>	Stream.sliding(int windowSize, int increment, Collector<? super T,A,R> collector)
abstract <C extends Collection<T>> Stream<C>	Stream.sliding(int windowSize, IntFunction<? extends C> collectionSupplier)
abstract <A, R> Stream<R>	Stream.sliding(int windowSize, Collector<? super T,A,R> collector)
abstract <R> Stream<R>	Stream.slidingMap(TriFunction<? super T,? super T,? super T,? extends R> mapper)
abstract <R> Stream<R>	Stream.slidingMap(TriFunction<? super T,? super T,? super T,? extends R> mapper, int increment)	Slide with windowSize = 3 and the specified increment, then map by the specified mapper.
abstract <R> Stream<R>	Stream.slidingMap(TriFunction<? super T,? super T,? super T,? extends R> mapper, int increment, boolean ignoreNotPaired)
abstract <R> Stream<R>	Stream.slidingMap(BiFunction<? super T,? super T,? extends R> mapper)
abstract <R> Stream<R>	Stream.slidingMap(BiFunction<? super T,? super T,? extends R> mapper, int increment)	Slide with windowSize = 2 and the specified increment, then map by the specified mapper.
abstract <R> Stream<R>	Stream.slidingMap(BiFunction<? super T,? super T,? extends R> mapper, int increment, boolean ignoreNotPaired)
Stream<PL>	BaseStream.slidingToList(int windowSize)
Stream<PL>	BaseStream.slidingToList(int windowSize, int increment)
Stream<List<Map.Entry<K,V>>>	EntryStream.slidingToList(int windowSize, int increment)
Stream<Set<T>>	Stream.slidingToSet(int windowSize)
abstract Stream<Set<T>>	Stream.slidingToSet(int windowSize, int increment)
abstract Stream<T>	Stream.sorted(Comparator<? super T> comparator)
abstract Stream<T>	Stream.sortedBy(Function<? super T,? extends Comparable> keyMapper)
abstract Stream<T>	Stream.sortedByDouble(ToDoubleFunction<? super T> keyMapper)
abstract Stream<T>	Stream.sortedByInt(ToIntFunction<? super T> keyMapper)
abstract Stream<T>	Stream.sortedByLong(ToLongFunction<? super T> keyMapper)
Stream<S>	BaseStream.split(int chunkSize)	Returns Stream of S with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
Stream<S>	BaseStream.split(P predicate)	Split the stream by the specified predicate.
Stream<EntryStream<K,V>>	EntryStream.split(int chunkSize)
Stream<EntryStream<K,V>>	EntryStream.split(Predicate<? super Map.Entry<K,V>> predicate)
abstract <C extends Collection<T>> Stream<C>	Stream.split(int chunkSize, IntFunction<? extends 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 <A, R> Stream<R>	Stream.split(int chunkSize, Collector<? super T,A,R> collector)
static Stream<String>	Stream.split(CharSequence str, CharSequence delimiter)
abstract <C extends Collection<T>> Stream<C>	Stream.split(Predicate<? super T> predicate, Supplier<? extends C> collectionSupplier)
abstract <A, R> Stream<R>	Stream.split(Predicate<? super T> predicate, Collector<? super T,A,R> collector)
Stream<S>	BaseStream.splitAt(int where)	Split the stream into two pieces at where.
Stream<S>	BaseStream.splitAt(P where)	Split the stream into two pieces at where turns to true.
Stream<EntryStream<K,V>>	EntryStream.splitAt(int where)
Stream<EntryStream<K,V>>	EntryStream.splitAt(Predicate<? super Map.Entry<K,V>> where)
abstract <A, R> Stream<R>	Stream.splitAt(int where, Collector<? super T,A,R> collector)	Split the stream into two pieces at where turns to false.
abstract <A, R> Stream<R>	Stream.splitAt(Predicate<? super T> where, Collector<? super T,A,R> collector)	Split the stream into two pieces at where turns to false.
Stream<PL>	BaseStream.splitToList(int chunkSize)	Returns Stream of PL with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
Stream<PL>	BaseStream.splitToList(P predicate)	Split the stream by the specified predicate.
Stream<List<Map.Entry<K,V>>>	EntryStream.splitToList(int chunkSize)
Stream<List<Map.Entry<K,V>>>	EntryStream.splitToList(Predicate<? super Map.Entry<K,V>> predicate)
abstract Stream<Set<T>>	Stream.splitToSet(int chunkSize)	Returns Stream of Stream with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
abstract Stream<Set<T>>	Stream.splitToSet(Predicate<? super T> predicate)
<R> Stream<R>	Stream.sps(int maxThreadNum, int bufferSize, Function<? super Stream<T>,? extends Stream<? extends R>> op)	Temporarily switch the stream to parallel stream for operation op and then switch back to sequence stream.
Stream<T>	Stream.spsFilter(int maxThreadNum, int bufferSize, Predicate<? super T> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
Stream<T>	Stream.spsFilter(int maxThreadNum, Predicate<? super T> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
Stream<T>	Stream.spsFilter(Predicate<? super T> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
Stream<T>	Stream.spsFilterE(int maxThreadNum, Throwables.Predicate<? super T,? extends Exception> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
Stream<T>	Stream.spsFilterE(Throwables.Predicate<? super T,? extends Exception> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatmap(int maxThreadNum, int bufferSize, Function<? super T,? extends Collection<? extends R>> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatmap(int maxThreadNum, Function<? super T,? extends Collection<? extends R>> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatmap(Function<? super T,? extends Collection<? extends R>> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMap(int maxThreadNum, int bufferSize, Function<? super T,? extends Stream<? extends R>> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMap(int maxThreadNum, Function<? super T,? extends Stream<? extends R>> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMap(Function<? super T,? extends Stream<? extends R>> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatmapE(int maxThreadNum, Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatmapE(Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMapE(int maxThreadNum, Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMapE(Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsMap(int maxThreadNum, int bufferSize, Function<? super T,? extends R> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
<R> Stream<R>	Stream.spsMap(int maxThreadNum, Function<? super T,? extends R> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
<R> Stream<R>	Stream.spsMap(Function<? super T,? extends R> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
<R> Stream<R>	Stream.spsMapE(int maxThreadNum, Throwables.Function<? super T,? extends R,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
<R> Stream<R>	Stream.spsMapE(Throwables.Function<? super T,? extends R,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
Stream<T>	Stream.spsOnEach(int maxThreadNum, int bufferSize, Consumer<? super T> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
Stream<T>	Stream.spsOnEach(int maxThreadNum, Consumer<? super T> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
Stream<T>	Stream.spsOnEach(Consumer<? super T> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
Stream<T>	Stream.spsOnEachE(int maxThreadNum, Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
Stream<T>	Stream.spsOnEachE(Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
abstract Stream<T>	Stream.top(int n)	This method only runs sequentially, even in parallel stream.
abstract Stream<T>	Stream.top(int n, Comparator<? super T> comparator)	This method only runs sequentially, even in parallel stream.
Stream<V>	EntryStream.values()
static <R> Stream<R>	Stream.zip(byte[] a, byte[] b, byte[] c, byte valueForNoneA, byte valueForNoneB, byte valueForNoneC, ByteTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(byte[] a, byte[] b, byte[] c, ByteTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(byte[] a, byte[] b, byte valueForNoneA, byte valueForNoneB, ByteBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(byte[] a, byte[] b, ByteBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(char[] a, char[] b, char[] c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(char[] a, char[] b, char[] c, CharTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(char[] a, char[] b, char valueForNoneA, char valueForNoneB, CharBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(char[] a, char[] b, CharBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(double[] a, double[] b, double[] c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(double[] a, double[] b, double[] c, DoubleTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(double[] a, double[] b, double valueForNoneA, double valueForNoneB, DoubleBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(double[] a, double[] b, DoubleBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(float[] a, float[] b, float[] c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(float[] a, float[] b, float[] c, FloatTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(float[] a, float[] b, float valueForNoneA, float valueForNoneB, FloatBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(float[] a, float[] b, FloatBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(int[] a, int[] b, int[] c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(int[] a, int[] b, int[] c, IntTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(int[] a, int[] b, int valueForNoneA, int valueForNoneB, IntBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(int[] a, int[] b, IntBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(long[] a, long[] b, long[] c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(long[] a, long[] b, long[] c, LongTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(long[] a, long[] b, long valueForNoneA, long valueForNoneB, LongBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(long[] a, long[] b, LongBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(short[] a, short[] b, short[] c, short valueForNoneA, short valueForNoneB, short valueForNoneC, ShortTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(short[] a, short[] b, short[] c, ShortTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(short[] a, short[] b, short valueForNoneA, short valueForNoneB, ShortBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(short[] a, short[] b, ShortBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <A, B, R> Stream<R>	Stream.zip(A[] a, B[] b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <A, B, C, R> Stream<R>	Stream.zip(A[] a, B[] b, C[] c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends 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>	Stream.zip(A[] a, B[] b, C[] c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <A, B, R> Stream<R>	Stream.zip(A[] a, B[] b, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(ByteIterator a, ByteIterator b, byte valueForNoneA, byte valueForNoneB, ByteBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(ByteIterator a, ByteIterator b, ByteIterator c, byte valueForNoneA, byte valueForNoneB, byte valueForNoneC, ByteTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(ByteIterator a, ByteIterator b, ByteIterator c, ByteTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(ByteIterator a, ByteIterator b, ByteBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(CharIterator a, CharIterator b, char valueForNoneA, char valueForNoneB, CharBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(CharIterator a, CharIterator b, CharIterator c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(CharIterator a, CharIterator b, CharIterator c, CharTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(CharIterator a, CharIterator b, CharBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(DoubleIterator a, DoubleIterator b, double valueForNoneA, double valueForNoneB, DoubleBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(DoubleIterator a, DoubleIterator b, DoubleIterator c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(DoubleIterator a, DoubleIterator b, DoubleIterator c, DoubleTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(DoubleIterator a, DoubleIterator b, DoubleBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(FloatIterator a, FloatIterator b, float valueForNoneA, float valueForNoneB, FloatBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(FloatIterator a, FloatIterator b, FloatIterator c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(FloatIterator a, FloatIterator b, FloatIterator c, FloatTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(FloatIterator a, FloatIterator b, FloatBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(IntIterator a, IntIterator b, int valueForNoneA, int valueForNoneB, IntBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(IntIterator a, IntIterator b, IntBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(IntIterator a, IntIterator b, IntIterator c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(IntIterator a, IntIterator b, IntIterator c, IntTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(LongIterator a, LongIterator b, long valueForNoneA, long valueForNoneB, LongBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(LongIterator a, LongIterator b, LongBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(LongIterator a, LongIterator b, LongIterator c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(LongIterator a, LongIterator b, LongIterator c, LongTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(ShortIterator a, ShortIterator b, short valueForNoneA, short valueForNoneB, ShortBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(ShortIterator a, ShortIterator b, ShortBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(ShortIterator a, ShortIterator b, ShortIterator c, short valueForNoneA, short valueForNoneB, short valueForNoneC, ShortTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(ShortIterator a, ShortIterator b, ShortIterator c, ShortTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(ByteStream a, ByteStream b, byte valueForNoneA, byte valueForNoneB, ByteBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(ByteStream a, ByteStream b, ByteBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(ByteStream a, ByteStream b, ByteStream c, byte valueForNoneA, byte valueForNoneB, byte valueForNoneC, ByteTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(ByteStream a, ByteStream b, ByteStream c, ByteTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(CharStream a, CharStream b, char valueForNoneA, char valueForNoneB, CharBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(CharStream a, CharStream b, CharBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(CharStream a, CharStream b, CharStream c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(CharStream a, CharStream b, CharStream c, CharTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(DoubleStream a, DoubleStream b, double valueForNoneA, double valueForNoneB, DoubleBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(DoubleStream a, DoubleStream b, DoubleBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(DoubleStream a, DoubleStream b, DoubleStream c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(DoubleStream a, DoubleStream b, DoubleStream c, DoubleTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(FloatStream a, FloatStream b, float valueForNoneA, float valueForNoneB, FloatBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(FloatStream a, FloatStream b, FloatBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(FloatStream a, FloatStream b, FloatStream c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(FloatStream a, FloatStream b, FloatStream c, FloatTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(IntStream a, IntStream b, int valueForNoneA, int valueForNoneB, IntBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(IntStream a, IntStream b, IntBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(IntStream a, IntStream b, IntStream c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(IntStream a, IntStream b, IntStream c, IntTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(LongStream a, LongStream b, long valueForNoneA, long valueForNoneB, LongBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(LongStream a, LongStream b, LongBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(LongStream a, LongStream b, LongStream c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(LongStream a, LongStream b, LongStream c, LongTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(ShortStream a, ShortStream b, short valueForNoneA, short valueForNoneB, ShortBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(ShortStream a, ShortStream b, ShortBiFunction<? extends R> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <R> Stream<R>	Stream.zip(ShortStream a, ShortStream b, ShortStream c, short valueForNoneA, short valueForNoneB, short valueForNoneC, ShortTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(ShortStream a, ShortStream b, ShortStream c, ShortTriFunction<? extends R> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <A, B, R> Stream<R>	Stream.zip(Stream<? extends A> a, Stream<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <A, B, C, R> Stream<R>	Stream.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,? extends 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>	Stream.zip(Stream<? extends A> a, Stream<? extends B> b, Stream<? extends C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <A, B, R> Stream<R>	Stream.zip(Stream<? extends A> a, Stream<? extends B> b, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <A, B, R> Stream<R>	Stream.zip(Iterable<? extends A> a, Iterable<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <A, B, C, R> Stream<R>	Stream.zip(Iterable<? extends A> a, Iterable<? extends B> b, Iterable<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends 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>	Stream.zip(Iterable<? extends A> a, Iterable<? extends B> b, Iterable<? extends C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <A, B, R> Stream<R>	Stream.zip(Iterable<? extends A> a, Iterable<? extends B> b, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends ByteStream> c, byte[] valuesForNone, ByteNFunction<? extends R> zipFunction)	Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends ByteStream> c, ByteNFunction<? extends R> zipFunction)	Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends CharStream> c, char[] valuesForNone, CharNFunction<? extends R> zipFunction)	Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends CharStream> c, CharNFunction<? extends R> zipFunction)	Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends DoubleStream> c, double[] valuesForNone, DoubleNFunction<? extends R> zipFunction)	Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends DoubleStream> c, DoubleNFunction<? extends R> zipFunction)	Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends FloatStream> c, float[] valuesForNone, FloatNFunction<? extends R> zipFunction)	Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends FloatStream> c, FloatNFunction<? extends R> zipFunction)	Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends IntStream> c, int[] valuesForNone, IntNFunction<? extends R> zipFunction)	Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends IntStream> c, IntNFunction<? extends R> zipFunction)	Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends LongStream> c, long[] valuesForNone, LongNFunction<? extends R> zipFunction)	Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends LongStream> c, LongNFunction<? extends R> zipFunction)	Zip together the iterators until one of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends ShortStream> c, short[] valuesForNone, ShortNFunction<? extends R> zipFunction)	Zip together the iterators until all of them runs out of values.
static <R> Stream<R>	Stream.zip(Collection<? extends ShortStream> c, ShortNFunction<? extends R> zipFunction)	Zip together the iterators until one of them runs out of values.
static <T, R> Stream<R>	Stream.zip(Collection<? extends Stream<? extends T>> c, Function<? super List<? extends T>,? extends R> zipFunction)	Zip together the iterators until one of them runs out of values.
static <T, R> Stream<R>	Stream.zip(Collection<? extends Stream<? extends T>> c, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction)	Zip together the iterators until all of them runs out of values.
static <A, B, R> Stream<R>	Stream.zip(Iterator<? extends A> a, Iterator<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <A, B, R> Stream<R>	Stream.zip(Iterator<? extends A> a, Iterator<? extends B> b, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static <A, B, C, R> Stream<R>	Stream.zip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends 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>	Stream.zip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static <T, R> Stream<R>	Stream.zipIterables(Collection<? extends Iterable<? extends T>> collections, Function<? super List<? extends T>,? extends R> zipFunction)
static <T, R> Stream<R>	Stream.zipIterables(Collection<? extends Iterable<? extends T>> collections, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction)
static <T, R> Stream<R>	Stream.zipIterators(Collection<? extends Iterator<? extends T>> iterators, Function<? super List<? extends T>,? extends R> zipFunction)
static <T, R> Stream<R>	Stream.zipIterators(Collection<? extends Iterator<? extends T>> iterators, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction)
abstract <T2, T3, R> Stream<R>	Stream.zipWith(Stream<T2> b, Stream<T3> c, TriFunction<? super T,? super T2,? super T3,? extends R> zipFunction)
abstract <T2, T3, R> Stream<R>	Stream.zipWith(Stream<T2> b, Stream<T3> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, TriFunction<? super T,? super T2,? super T3,? extends R> zipFunction)
abstract <T2, R> Stream<R>	Stream.zipWith(Stream<T2> b, BiFunction<? super T,? super T2,? extends R> zipFunction)
abstract <T2, R> Stream<R>	Stream.zipWith(Stream<T2> b, T valueForNoneA, T2 valueForNoneB, BiFunction<? super T,? super T2,? extends R> zipFunction)
abstract <T2, T3, R> Stream<R>	Stream.zipWith(Collection<T2> b, Collection<T3> c, TriFunction<? super T,? super T2,? super T3,? extends R> zipFunction)
abstract <T2, T3, R> Stream<R>	Stream.zipWith(Collection<T2> b, Collection<T3> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, TriFunction<? super T,? super T2,? super T3,? extends R> zipFunction)
abstract <T2, R> Stream<R>	Stream.zipWith(Collection<T2> b, BiFunction<? super T,? super T2,? extends R> zipFunction)
abstract <T2, R> Stream<R>	Stream.zipWith(Collection<T2> b, T valueForNoneA, T2 valueForNoneB, BiFunction<? super T,? super T2,? extends R> zipFunction)

Methods in com.landawn.abacus.util.stream that return types with arguments of type Stream

Modifier and Type	Method	Description
abstract Stream<Stream<T>>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible)
abstract Stream<Stream<T>>	Stream.collapse(BiPredicate<? super T,? super T> collapsible)

Methods in com.landawn.abacus.util.stream with parameters of type Stream

Modifier and Type	Method	Description
static <T> Stream<T>	Stream.concat(Stream<? extends T>... a)
static <T> Stream<T>	Stream.merge(Stream<? extends T> a, Stream<? extends T> b, Stream<? extends T> c, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.merge(Stream<? extends T> a, Stream<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)
Stream<T>	Stream.merge(Stream<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)	Deprecated. replaced by mergeWith(Stream, BiFunction)
abstract Stream<T>	Stream.mergeWith(Stream<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.parallelConcat(Stream<? extends T>... a)
static <T> Stream<T>	Stream.parallelConcat(Stream<? extends T>[] a, int readThreadNum, int bufferSize)	Returns a Stream with elements from a temporary queue which is filled by reading the elements from the specified iterators in parallel.
static <A, B, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, C, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, Stream<C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, BiFunction<? super A,? super B,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.parallelZip(Stream<A> a, Stream<B> b, BiFunction<? super A,? super B,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <A, B, R> Stream<R>	Stream.zip(Stream<? extends A> a, Stream<? extends B> b, A valueForNoneA, B valueForNoneB, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <A, B, C, R> Stream<R>	Stream.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,? extends 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>	Stream.zip(Stream<? extends A> a, Stream<? extends B> b, Stream<? extends C> c, TriFunction<? super A,? super B,? super C,? extends R> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <A, B, R> Stream<R>	Stream.zip(Stream<? extends A> a, Stream<? extends B> b, BiFunction<? super A,? super B,? extends R> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
abstract <T2, T3, R> Stream<R>	Stream.zipWith(Stream<T2> b, Stream<T3> c, TriFunction<? super T,? super T2,? super T3,? extends R> zipFunction)
abstract <T2, T3, R> Stream<R>	Stream.zipWith(Stream<T2> b, Stream<T3> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, TriFunction<? super T,? super T2,? super T3,? extends R> zipFunction)
abstract <T2, R> Stream<R>	Stream.zipWith(Stream<T2> b, BiFunction<? super T,? super T2,? extends R> zipFunction)
abstract <T2, R> Stream<R>	Stream.zipWith(Stream<T2> b, T valueForNoneA, T2 valueForNoneB, BiFunction<? super T,? super T2,? extends R> zipFunction)

Method parameters in com.landawn.abacus.util.stream with type arguments of type Stream

Modifier and Type	Method	Description
<R> ContinuableFuture<R>	Stream.asyncCall(Throwables.Function<? super Stream<T>,R,? extends Exception> terminalAction)
<R> ContinuableFuture<R>	Stream.asyncCall(Throwables.Function<? super Stream<T>,R,? extends Exception> terminalAction, Executor executor)
ContinuableFuture<Void>	Stream.asyncRun(Throwables.Consumer<? super Stream<T>,? extends Exception> terminalAction)
ContinuableFuture<Void>	Stream.asyncRun(Throwables.Consumer<? super Stream<T>,? extends Exception> terminalAction, Executor executor)
<KK, VV> EntryStream<KK,VV>	EntryStream.chain(Function<? super Stream<Map.Entry<K,V>>,? extends Stream<Map.Entry<KK,VV>>> transfer)
<KK, VV> EntryStream<KK,VV>	EntryStream.chain(Function<? super Stream<Map.Entry<K,V>>,? extends Stream<Map.Entry<KK,VV>>> transfer)
static <T> Stream<T>	Stream.concat(Collection<? extends Stream<? extends T>> c)
final Stream<T>	Stream.defaultIfEmpty(Supplier<? extends Stream<T>> supplier)
static <T> Stream<T>	Stream.defer(Supplier<? extends Stream<T>> supplier)	Lazy evaluation.
abstract <R> Stream<R>	Stream.flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
<R> Stream<R>	Stream.flatMapE(Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)
<KK> EntryStream<KK,V>	EntryStream.flatMapKey(BiFunction<? super K,? super V,? extends Stream<? extends KK>> keyMapper)
<KK> EntryStream<KK,V>	EntryStream.flatMapKey(Function<? super K,? extends Stream<? extends KK>> keyMapper)
<KK> EntryStream<KK,V>	EntryStream.flatMapKeyToDisposableEntry(Function<? super K,? extends Stream<? extends KK>> keyMapper)	Deprecated.
abstract <K, V> EntryStream<K,V>	Stream.flatMapToEntry(Function<? super T,? extends Stream<? extends Map.Entry<? extends K,? extends V>>> mapper)
abstract <T> Stream<T>	ByteStream.flatMapToObj(ByteFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	CharStream.flatMapToObj(CharFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	DoubleStream.flatMapToObj(DoubleFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	FloatStream.flatMapToObj(FloatFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	IntStream.flatMapToObj(IntFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	LongStream.flatMapToObj(LongFunction<? extends Stream<? extends T>> mapper)
abstract <T> Stream<T>	ShortStream.flatMapToObj(ShortFunction<? extends Stream<? extends T>> mapper)
<VV> EntryStream<K,VV>	EntryStream.flatMapValue(BiFunction<? super K,? super V,? extends Stream<? extends VV>> valueMapper)
<VV> EntryStream<K,VV>	EntryStream.flatMapValue(Function<? super V,? extends Stream<? extends VV>> valueMapper)
<VV> EntryStream<K,VV>	EntryStream.flatMapValueToDisposableEntry(Function<? super V,? extends Stream<? extends VV>> valueMapper)	Deprecated.
<KK, VV> EntryStream<KK,VV>	EntryStream.flattMap(BiFunction<? super K,? super V,? extends Stream<? extends Map.Entry<? extends KK,? extends VV>>> mapper)
<KK, VV> EntryStream<KK,VV>	EntryStream.flattMap(Function<? super Map.Entry<K,V>,? extends Stream<? extends Map.Entry<? extends KK,? extends VV>>> mapper)
static <T, T2, U> Collector<T,?,List<U>>	Collectors.flattMaping(Function<? super T,? extends Stream<? extends T2>> flatMapper, BiFunction<? super T,? super T2,? extends U> mapper)
static <T, T2, U, A, R> Collector<T,?,R>	Collectors.flattMaping(Function<? super T,? extends Stream<? extends T2>> flatMapper, BiFunction<? super T,? super T2,? extends U> mapper, Collector<? super U,A,R> downstream)
static <T, U> Collector<T,?,List<U>>	Collectors.flattMaping(Function<? super T,? extends Stream<? extends U>> mapper)
static <T, U, A, R> Collector<T,?,R>	Collectors.flattMaping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)
static <T, K, V> Collector<T,?,ListMultimap<K,V>>	Collectors.flattMapingKeyToMultimap(Function<? super T,Stream<? extends K>> flatKeyMapper, Function<? super T,V> valueMapper)
static <T, K, V, C extends Collection<V>, M extends Multimap<K, V, C>> Collector<T,?,M>	Collectors.flattMapingKeyToMultimap(Function<? super T,Stream<? extends K>> flatKeyMapper, Function<? super T,V> valueMapper, Supplier<? extends M> mapFactory)
static <T> Stream<T>	Stream.merge(Collection<? extends Stream<? extends T>> c, BiFunction<? super T,? super T,MergeResult> nextSelector)
static <T> Stream<T>	Stream.parallelConcat(Collection<? extends Stream<? extends T>> c)
static <T> Stream<T>	Stream.parallelConcat(Collection<? extends Stream<? extends T>> c, int readThreadNum)
static <T> Stream<T>	Stream.parallelConcat(Collection<? extends Stream<? extends T>> c, int readThreadNum, int bufferSize)	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>	Stream.parallelMerge(Collection<? extends Stream<? extends T>> c, BiFunction<? super T,? super T,MergeResult> nextSelector)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
static <T> Stream<T>	Stream.parallelMerge(Collection<? extends Stream<? extends T>> c, BiFunction<? super T,? super T,MergeResult> nextSelector, int maxThreadNum)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
static <T, R> Stream<R>	Stream.parallelZip(Collection<? extends Stream<? extends T>> c, Function<? super List<? extends T>,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZip(Collection<? extends Stream<? extends T>> c, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZip(Collection<? extends Stream<? extends T>> c, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
static <T, R> Stream<R>	Stream.parallelZip(Collection<? extends Stream<? extends T>> c, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction, int bufferSize)	A new thread will be started for each Iterator/Collection/Stream to read the elements to queue for the zipFunction.
<R> Stream<R>	Stream.sps(int maxThreadNum, int bufferSize, Function<? super Stream<T>,? extends Stream<? extends R>> op)	Temporarily switch the stream to parallel stream for operation op and then switch back to sequence stream.
<R> Stream<R>	Stream.sps(int maxThreadNum, int bufferSize, Function<? super Stream<T>,? extends Stream<? extends R>> op)	Temporarily switch the stream to parallel stream for operation op and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMap(int maxThreadNum, int bufferSize, Function<? super T,? extends Stream<? extends R>> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMap(int maxThreadNum, Function<? super T,? extends Stream<? extends R>> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMap(Function<? super T,? extends Stream<? extends R>> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMapE(int maxThreadNum, Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsFlatMapE(Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
static <T, R> Stream<R>	Stream.zip(Collection<? extends Stream<? extends T>> c, Function<? super List<? extends T>,? extends R> zipFunction)	Zip together the iterators until one of them runs out of values.
static <T, R> Stream<R>	Stream.zip(Collection<? extends Stream<? extends T>> c, List<? extends T> valuesForNone, Function<? super List<? extends T>,? extends R> zipFunction)	Zip together the iterators until all of them runs out of values.