Uses of Class
com.landawn.abacus.util.stream.Stream
Package
Description
-
Uses of Stream in com.landawn.abacus.guava
Modifier and TypeMethodDescriptionTraverser.breadthFirst
(T startNode) Returns an unmodifiableIterable
over the nodes reachable fromstartNode
, in the order of a breadth-first traversal.Traverser.depthFirstPostOrder
(T startNode) Returns an unmodifiableIterable
over the nodes reachable fromstartNode
, in the order of a depth-first post-order traversal.Traverser.depthFirstPreOrder
(T startNode) Returns an unmodifiableIterable
over the nodes reachable fromstartNode
, in the order of a depth-first pre-order traversal. -
Uses of Stream in com.landawn.abacus.http
Modifier and TypeMethodDescriptionstatic 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.htmlstatic 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
Modifier and TypeMethodDescriptionSheet.cellsC()
Sheet.cellsC
(int fromColumnIndex, int toColumnIndex) Stream<Sheet.Cell<R,
C, V>> Sheet.cellsH()
Stream<Sheet.Cell<R,
C, V>> Sheet.cellsH
(int rowIndex) Stream<Sheet.Cell<R,
C, V>> Sheet.cellsH
(int fromRowIndex, int toRowIndex) Sheet.cellsR()
Sheet.cellsR
(int fromRowIndex, int toRowIndex) Stream<Sheet.Cell<R,
C, V>> Sheet.cellsV()
Stream<Sheet.Cell<R,
C, V>> Sheet.cellsV
(int columnIndex) Stream<Sheet.Cell<R,
C, V>> Sheet.cellsV
(int fromColumnIndex, int toColumnIndex) DataSet.columnNames()
RowDataSet.columnNames()
DataSet.columns()
RowDataSet.columns()
Sheet.columns()
Sheet.columns
(int fromColumnIndex, int toColumnIndex) DataSet.cube
(Collection<String> columnNames) DataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper) DataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Collector<?, ?, ?> collector) DataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ? extends T, ? extends Exception> rowMapper, Collector<? super T, ?, ?> collector) DataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass) DataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[], ?, ?> collector) DataSet.cube
(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Collector<?, ?, ?> collector) DataSet.cube
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ? extends T, ? extends Exception> rowMapper, Collector<? super T, ?, ?> collector) DataSet.cube
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass) DataSet.cube
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[], ?, ?> collector) RowDataSet.cube
(Collection<String> columnNames) RowDataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper) RowDataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Collector<?, ?, ?> collector) RowDataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ? extends T, ? extends Exception> rowMapper, Collector<? super T, ?, ?> collector) RowDataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass) RowDataSet.cube
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[], ?, ?> collector) RowDataSet.cube
(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Collector<?, ?, ?> collector) RowDataSet.cube
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ? extends T, ? extends Exception> rowMapper, Collector<? super T, ?, ?> collector) RowDataSet.cube
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass) RowDataSet.cube
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[], ?, ?> collector) LongMultiset.flatStream()
Multiset.flatStream()
Sheet.pointsC()
Sheet.pointsC
(int fromColumnIndex, int toColumnIndex) Sheet.pointsH()
Sheet.pointsH
(int rowIndex) Sheet.pointsH
(int fromRowIndex, int toRowIndex) Sheet.pointsR()
Sheet.pointsR
(int fromRowIndex, int toRowIndex) Sheet.pointsV()
Sheet.pointsV
(int columnIndex) Sheet.pointsV
(int fromColumnIndex, int toColumnIndex) DataSet.rollup
(Collection<String> columnNames) DataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper) DataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Collector<?, ?, ?> collector) DataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ? extends T, ? extends Exception> rowMapper, Collector<? super T, ?, ?> collector) DataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass) DataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[], ?, ?> collector) DataSet.rollup
(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Collector<?, ?, ?> collector) DataSet.rollup
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ? extends T, ? extends Exception> rowMapper, Collector<? super T, ?, ?> collector) DataSet.rollup
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass) DataSet.rollup
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[], ?, ?> collector) RowDataSet.rollup
(Collection<String> columnNames) RowDataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper) RowDataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, String aggregateOnColumnName, Collector<?, ?, ?> collector) RowDataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ? extends T, ? extends Exception> rowMapper, Collector<? super T, ?, ?> collector) RowDataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass) RowDataSet.rollup
(Collection<String> columnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ?, ? extends Exception> keyMapper, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[], ?, ?> collector) RowDataSet.rollup
(Collection<String> columnNames, String aggregateResultColumnName, String aggregateOnColumnName, Collector<?, ?, ?> collector) RowDataSet.rollup
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Throwables.Function<? super NoCachingNoUpdating.DisposableObjArray, ? extends T, ? extends Exception> rowMapper, Collector<? super T, ?, ?> collector) RowDataSet.rollup
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Class<?> rowClass) RowDataSet.rollup
(Collection<String> columnNames, String aggregateResultColumnName, Collection<String> aggregateOnColumnNames, Collector<? super Object[], ?, ?> collector) Sheet.rows()
Sheet.rows
(int fromRowIndex, int toRowIndex) 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.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.RowDataSet.split
(int chunkSize) RowDataSet.split
(Collection<String> columnNames, int chunkSize) static <T> Stream<T>
N.splitByCount
(int maxChunkCount, 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]]
Splitter.MapSplitter.splitToStream
(CharSequence source) Split to stream.Splitter.splitToStream
(CharSequence source) Split to stream.<R> Stream<R>
BiIterator.stream
(BiFunction<? super A, ? super B, ? extends R> mapper) BooleanIterator.stream()
BooleanList.stream()
BooleanList.stream
(int fromIndex, int toIndex) Builder.stream()
static <T> Stream<T>
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, IntObjFunction<? super NoCachingNoUpdating.DisposableObjArray, ? extends T> rowMapper) <T> Stream<T>
DataSet.stream
(int fromRowIndex, int toRowIndex, Tuple.Tuple2<String, String> columnNames, BiFunction<?, ?, ? extends T> rowMapper) <T> Stream<T>
DataSet.stream
(int fromRowIndex, int toRowIndex, Tuple.Tuple3<String, String, String> columnNames, TriFunction<?, ?, ?, ? extends T> rowMapper) <T> Stream<T>
<T> Stream<T>
DataSet.stream
(int fromRowIndex, int toRowIndex, Collection<String> columnNames, IntObjFunction<? super NoCachingNoUpdating.DisposableObjArray, ? extends T> rowMapper) <T> Stream<T>
DataSet.stream
(int fromRowIndex, int toRowIndex, Collection<String> columnNames, IntFunction<? extends T> rowSupplier) <T> Stream<T>
DataSet.stream
(int fromRowIndex, int toRowIndex, IntFunction<? extends T> rowSupplier) <T> Stream<T>
DataSet.stream
(IntObjFunction<? super NoCachingNoUpdating.DisposableObjArray, ? extends T> rowMapper) <T> Stream<T>
DataSet.stream
(Tuple.Tuple2<String, String> columnNames, BiFunction<?, ?, ? extends T> rowMapper) <T> Stream<T>
DataSet.stream
(Tuple.Tuple3<String, String, String> columnNames, TriFunction<?, ?, ?, ? extends T> rowMapper) <T> Stream<T>
<T> Stream<T>
<T> Stream<T>
DataSet.stream
(Class<? extends T> rowClass, int fromRowIndex, int toRowIndex, Collection<String> columnNames) <T> Stream<T>
DataSet.stream
(Class<? extends T> beanClass, int fromRowIndex, int toRowIndex, Collection<String> columnNames, Map<String, String> prefixAndFieldNameMap) <T> Stream<T>
DataSet.stream
(Class<? extends T> beanClass, 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> beanClass, Collection<String> columnNames, Map<String, String> prefixAndFieldNameMap) <T> Stream<T>
<T> Stream<T>
<T> Stream<T>
DataSet.stream
(Collection<String> columnNames, IntObjFunction<? super NoCachingNoUpdating.DisposableObjArray, ? extends T> rowMapper) <T> Stream<T>
DataSet.stream
(Collection<String> columnNames, IntFunction<? extends T> rowSupplier) <T> Stream<T>
DataSet.stream
(IntFunction<? extends T> rowSupplier) Holder.stream()
ImmutableArray.stream()
Joiner.stream()
The underlineStringBuilder
will be recycled after this method is called ifresueStringBuilder
is set totrue
, and should not continue to this instance.LongMultiset.stream()
Multimap.stream()
Multiset.stream()
ObjIterator.stream()
Paginated.stream()
Pair.stream()
<T> Stream<T>
RowDataSet.stream
(int fromRowIndex, int toRowIndex, IntObjFunction<? super NoCachingNoUpdating.DisposableObjArray, ? extends T> rowMapper) <T> Stream<T>
RowDataSet.stream
(int fromRowIndex, int toRowIndex, Tuple.Tuple2<String, String> columnNames, BiFunction<?, ?, ? extends T> rowMapper) <T> Stream<T>
RowDataSet.stream
(int fromRowIndex, int toRowIndex, Tuple.Tuple3<String, String, String> columnNames, TriFunction<?, ?, ?, ? extends T> rowMapper) <T> Stream<T>
<T> Stream<T>
RowDataSet.stream
(int fromRowIndex, int toRowIndex, Collection<String> inputColumnNames, IntObjFunction<? super NoCachingNoUpdating.DisposableObjArray, ? extends T> rowMapper) <T> Stream<T>
RowDataSet.stream
(int fromRowIndex, int toRowIndex, Collection<String> columnNames, IntFunction<? extends T> rowSupplier) <T> Stream<T>
RowDataSet.stream
(int fromRowIndex, int toRowIndex, IntFunction<? extends T> rowSupplier) <T> Stream<T>
RowDataSet.stream
(IntObjFunction<? super NoCachingNoUpdating.DisposableObjArray, ? extends T> rowMapper) <T> Stream<T>
RowDataSet.stream
(Tuple.Tuple2<String, String> columnNames, BiFunction<?, ?, ? extends T> rowMapper) <T> Stream<T>
RowDataSet.stream
(Tuple.Tuple3<String, String, String> columnNames, TriFunction<?, ?, ?, ? extends T> rowMapper) <T> Stream<T>
<T> Stream<T>
<T> Stream<T>
RowDataSet.stream
(Class<? extends T> rowClass, int fromRowIndex, int toRowIndex, Collection<String> columnNames) <T> Stream<T>
RowDataSet.stream
(Class<? extends T> beanClass, int fromRowIndex, int toRowIndex, Collection<String> columnNames, Map<String, String> prefixAndFieldNameMap) <T> Stream<T>
RowDataSet.stream
(Class<? extends T> beanClass, 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> beanClass, Collection<String> columnNames, Map<String, String> prefixAndFieldNameMap) <T> Stream<T>
<T> Stream<T>
<T> Stream<T>
RowDataSet.stream
(Collection<String> columnNames, IntObjFunction<? super NoCachingNoUpdating.DisposableObjArray, ? extends T> rowMapper) <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) Triple.stream()
Tuple.stream()
Tuple.stream
(Throwables.Function<? super TP, Stream<T>, E> func) u.Nullable.stream()
u.Optional.stream()
u.OptionalBoolean.stream()
Sheet.streamC()
Sheet.streamC
(int fromColumnIndex, int toColumnIndex) Sheet.streamH()
Sheet.streamH
(int rowIndex) Sheet.streamH
(int fromRowIndex, int toRowIndex) Joiner.streamIfNotEmpty()
Returns a stream with the String value generated bytoString()
if at least one element/object/entry is appended, otherwise an emptyStream
is returned.Holder.streamIfNotNull()
Returns aStream
with thevalue
ifvalue
is not null, otherwise an emptyStream
is returned.u.Nullable.streamIfNotNull()
Stream if not null.Sheet.streamR()
Sheet.streamR
(int fromRowIndex, int toRowIndex) Sheet.streamV()
Sheet.streamV
(int columnIndex) Sheet.streamV
(int fromColumnIndex, int toColumnIndex) CheckedStream.unchecked()
Modifier and TypeMethodDescriptionSheet.cellsC()
Sheet.cellsC
(int fromColumnIndex, int toColumnIndex) Sheet.cellsR()
Sheet.cellsR
(int fromRowIndex, int toRowIndex) Sheet.columns()
Sheet.columns
(int fromColumnIndex, int toColumnIndex) Sheet.pointsC()
Sheet.pointsC
(int fromColumnIndex, int toColumnIndex) Sheet.pointsR()
Sheet.pointsR
(int fromRowIndex, int toRowIndex) Sheet.rows()
Sheet.rows
(int fromRowIndex, int toRowIndex) CheckedStream.sliding
(int windowSize, int increment) CheckedStream.split
(int chunkSize) Sheet.streamC()
Sheet.streamC
(int fromColumnIndex, int toColumnIndex) Sheet.streamR()
Sheet.streamR
(int fromRowIndex, int toRowIndex) Modifier and TypeMethodDescriptionstatic <T,
E extends Exception>
CheckedStream<T,E> static <T,
E extends Exception>
CheckedStream<T,E> Modifier and TypeMethodDescription<R> CheckedStream<R,
E> CheckedStream.flattmap
(Throwables.Function<? super T, ? extends Stream<? extends R>, ? extends E> mapper) <R> CheckedStream<R,
E> Temporarily switch the stream to parallel stream for operationops
and then switch back to sequence stream.<R> CheckedStream<R,
E> Temporarily switch the stream to parallel stream for operationops
and then switch back to sequence stream.<R> CheckedStream<R,
E> Temporarily switch the stream to parallel stream for operationops
and then switch back to sequence stream.<R> CheckedStream<R,
E> Temporarily switch the stream to parallel stream for operationops
and then switch back to sequence stream.<R> CheckedStream<R,
E> CheckedStream.spsFlatMap
(int maxThreadNum, Throwables.Function<? super T, ? extends Stream<? extends R>, E> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> CheckedStream<R,
E> CheckedStream.spsFlatMap
(Throwables.Function<? super T, ? extends Stream<? extends R>, E> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> CheckedStream<R,
Exception> CheckedStream.spsFlatMapE
(int maxThreadNum, Throwables.Function<? super T, ? extends Stream<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> CheckedStream<R,
Exception> CheckedStream.spsFlatMapE
(Throwables.Function<? super T, ? extends Stream<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.Tuple.stream
(Throwables.Function<? super TP, Stream<T>, E> func) -
Uses of Stream in com.landawn.abacus.util.stream
Modifier and TypeMethodDescriptionStream.addSubscriber
(Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction) Add a new Stream with terminal action to listen/consume the elements from upstream.Stream.addSubscriber
(Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor) Add a new Stream with terminal action to listen/consume the elements from upstream.Stream.append
(Collection<? extends T> c) Stream.appendIfEmpty
(Collection<? extends T> c) Stream.appendIfEmpty
(T... a) ByteStream.boxed()
CharStream.boxed()
Returns aStream
consisting of the elements of this stream, each boxed to anChareger
.DoubleStream.boxed()
FloatStream.boxed()
IntStream.boxed()
LongStream.boxed()
ShortStream.boxed()
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.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.Stream.buffered
(BlockingQueue<T> queueToBuffer) 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.Stream.cartesianProduct
(Collection<? extends Collection<? extends T>> cs) Stream.cartesianProduct
(Collection<? extends T>... cs) ByteStream.collapse
(ByteBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.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.FloatStream.collapse
(FloatBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.IntStream.collapse
(IntBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.LongStream.collapse
(LongBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.ShortStream.collapse
(ShortBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.Stream.collapse
(TriPredicate<? super T, ? super T, ? super T> collapsible) 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> Stream<R>
Stream.collapse
(TriPredicate<? super T, ? super T, ? super T> collapsible, Collector<? super T, ?, 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) Stream.collapse
(BiPredicate<? super T, ? super T> collapsible) 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> Stream<R>
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) EntryStream.collapseByKey
(BiPredicate<? super K, ? super K> collapsible) <R> Stream<R>
EntryStream.collapseByKey
(BiPredicate<? super K, ? super K> collapsible, Collector<? super V, ?, R> collector) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.Stream.combinations()
Stream.of(1, 2, 3).combinations().forEach(Fn.println()); // output [] [1] [2] [3] [1, 2] [1, 3] [2, 3] [1, 2, 3]
Stream.combinations
(int len) Stream.of(1, 2, 3).combinations(2).forEach(Fn.println()); // output [1, 2] [1, 3] [2, 3]
Stream.combinations
(int len, boolean repeat) It's same asN.cartesianProduct(N.repeat(toList(), len))
ifrepeat
istrue
.static <T> Stream<T>
static <T> Stream<T>
static <T> Stream<T>
Stream.concat
(Collection<? extends Stream<? extends T>> c) static <T> Stream<T>
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) Stream.defaultIfEmpty
(Supplier<? extends Stream<T>> supplier) Stream.defaultIfEmpty
(T defaultValue) static <T> Stream<T>
Lazy evaluation.Stream.difference
(Function<? super T, ? extends U> mapper, Collection<U> c) Except with the specified Collection by the values mapped bymapper
.Stream.distinct
(BinaryOperator<T> mergeFunction) Distinct and merge duplicated elements.Distinct and filter by occurrences.Stream.distinctBy
(Function<? super T, ?> keyMapper) Distinct by the value mapped fromkeyMapper
.Stream.distinctBy
(Function<? super T, K> keyMapper, BinaryOperator<T> mergeFunction) Distinct and merge duplicated elements.Stream.distinctBy
(Function<? super T, K> keyMapper, Predicate<? super Map.Entry<Keyed<K, T>, Long>> occurrencesFilter) Distinct and filter by occurrences.Stream.distinctLimitBy
(Function<? super T, K> keyMapper, BiFunction<? super K, ? super List<T>, Integer> limit) Distinct and limit bykeyMapper
Stream.dropWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction) Add a new Stream with terminal action to listen/consume the elements dropped by the specifiedpredicate
.Stream.dropWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor) Add a new Stream with terminal action to listen/consume the elements dropped by the specifiedpredicate
.static <T> Stream<T>
Stream.empty()
EntryStream.entries()
Stream.filterE
(Throwables.Predicate<? super T, ? extends Exception> predicate) Stream.filterWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction) Add a new Stream with terminal action to listen/consume the elements filtered out by the specifiedpredicate
.Stream.filterWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor) Add a new Stream with terminal action to listen/consume the elements filtered out by the specifiedpredicate
.abstract <R> Stream<R>
Stream.flatmap
(Function<? super T, ? extends Collection<? extends R>> mapper) abstract <R> Stream<R>
<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>
abstract <R> Stream<R>
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.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, BinaryOperator<V> mergeFunction) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K, V>> mapFactory) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, Supplier<? extends Map<K, List<V>>> mapFactory) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, Collector<? super V, ?, D> downstream) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, Collector<? super V, ?, D> downstream, Supplier<? extends Map<K, D>> mapFactory) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Supplier<? extends Map<K, List<T>>> mapFactory) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Collector<? super T, ?, D> downstream, Supplier<? extends Map<K, D>> mapFactory) BaseStream.indexed()
This method only runs sequentially, even in parallel stream.EntryStream.indexed()
Stream.intersection
(Function<? super T, ? extends U> mapper, Collection<U> c) Intersect with the specified Collection by the values mapped bymapper
.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>
static <T> Stream<T>
Stream.interval
(long delayInMillis, long intervalInMillis, LongFunction<T> s) static <T> Stream<T>
static <T> Stream<T>
Stream.interval
(long intervalInMillis, LongFunction<T> s) static <T> Stream<T>
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 orderedStream
produced by iterative application of a functionf
to an initial elementinit
, producing aStream
consisting ofinit
,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) EntryStream.keys()
Stream.last
(int n) A queue with size up ton
will be maintained to filter out the lastn
elements.It's user's responsibility to close the inputreader
after the stream is finished.abstract <R> Stream<R>
<R> Stream<R>
Stream.mapE
(Throwables.Function<? super T, ? extends R, ? extends Exception> mapper) abstract <R> Stream<R>
Stream.mapFirstOrElse
(Function<? super T, ? extends R> mapperForFirst, Function<? super T, ? extends R> mapperForElse) <R> Stream<R>
Stream.mapIfNotNul
(Function<? super T, ? extends R> mapper) Convert the element to a new value if it's notnull
, otherwise skip it.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/streamexabstract <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-valuedStream
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) 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) Stream.mergeWith
(Stream<? extends T> b, BiFunction<? super T, ? super T, MergeResult> nextSelector) 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:Stream.of
(boolean[] a) Stream.of
(boolean[] a, int fromIndex, int toIndex) Stream.of
(byte[] a) Stream.of
(byte[] a, int fromIndex, int toIndex) Stream.of
(char[] a) Stream.of
(char[] a, int fromIndex, int toIndex) Stream.of
(double[] a) Stream.of
(double[] a, int fromIndex, int toIndex) Stream.of
(float[] a) Stream.of
(float[] a, int fromIndex, int toIndex) Stream.of
(int[] a) Stream.of
(int[] a, int fromIndex, int toIndex) Stream.of
(long[] a) Stream.of
(long[] a, int fromIndex, int toIndex) Stream.of
(short[] a) Stream.of
(short[] a, int fromIndex, int toIndex) static <T> Stream<T>
Stream.of
(u.Optional<T> op) static <T> Stream<T>
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>
static <T> Stream<T>
static <T> Stream<T>
static <T> Stream<T>
Stream.of
(T... a) static <T> Stream<T>
Stream.of
(T[] a, int startIndex, int endIndex) static <K> Stream<K>
static <K,
V> Stream<K> Stream.ofKeys
(Map<? extends K, ? extends V> map, BiPredicate<? super K, ? super V> filter) static <K,
V> Stream<K> static <T> Stream<T>
Stream.ofNullable
(T e) Returns an emptyStream
if the specifiedt
is null.static <V> Stream<V>
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.onEachE
(Throwables.Consumer<? super T, ? extends Exception> action) 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]
Stream.orderedPermutations
(Comparator<? super T> comparator) 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 inputCollection/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 inputCollection/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 inputCollection/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 inputCollection/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 inputCollection/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 inputCollection/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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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) Stream.partitionBy
(Predicate<? super T> predicate) Stream.partitionBy
(Predicate<? super T> predicate, Collector<? super T, ?, D> downstream) 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]
Stream.prepend
(Collection<? extends T> c) Stream.range
(int startInclusive, int endExclusive) Stream.range
(int startInclusive, int endExclusive, int by) Stream.range
(long startInclusive, long endExclusive) Stream.range
(long startInclusive, long endExclusive, long by) Stream.rangeClosed
(int startInclusive, int endInclusive) Stream.rangeClosed
(int startInclusive, int endInclusive, int by) Stream.rangeClosed
(long startInclusive, long endInclusive) 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.rateLimited
(RateLimiter rateLimiter) static <T> Stream<T>
Stream.repeat
(T element, long n) Stream.reverseSorted
(Comparator<? super T> comparator) Stream.reverseSortedBy
(Function<? super T, ? extends Comparable> keyMapper) Stream.reverseSortedByDouble
(ToDoubleFunction<? super T> keyMapper) Stream.reverseSortedByInt
(ToIntFunction<? super T> keyMapper) Stream.reverseSortedByLong
(ToLongFunction<? super T> keyMapper) Stream.rollup()
Stream.saveEach
(File output, Throwables.BiConsumer<? super T, Writer, IOException> writeLine) Stream.saveEach
(OutputStream output, Function<? super T, String> toLine) Stream.saveEach
(Writer output, Throwables.BiConsumer<? super T, Writer, IOException> writeLine) Stream.saveEach
(Connection conn, String insertSQL, Throwables.BiConsumer<? super T, ? super PreparedStatement, SQLException> stmtSetter) To support batch call, please useonEach
oronEachE
.Stream.saveEach
(PreparedStatement stmt, Throwables.BiConsumer<? super T, ? super PreparedStatement, SQLException> stmtSetter) To support batch call, please useonEach
oronEachE
.Stream.saveEach
(DataSource ds, String insertSQL, Throwables.BiConsumer<? super T, ? super PreparedStatement, SQLException> stmtSetter) To support batch/parallel call, please useonEach
oronEachE
.Stream.scan
(BiFunction<? super T, ? super T, T> accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract <U> Stream<U>
Stream.scan
(U init, BiFunction<U, ? super T, U> accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
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>
Select the elements belong to the specifiedtargetType
(including its subtype).<R> Stream<R>
Temporarily switch the stream to Jdk parallel stream for operationops
and then switch back to sequence stream.Stream.skipLast
(int n) A queue with size up ton
will be maintained to filter out the lastn
elements.Stream.skipNulls()
Stream.skipRange
(int startInclusive, int endExclusive) Skip the range: [fromIndexInclusive, fromIndexInclusive].BaseStream.sliding
(int windowSize) 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 <R> Stream<R>
abstract <C extends Collection<T>>
Stream<C>Stream.sliding
(int windowSize, IntFunction<? extends C> collectionSupplier) abstract <R> Stream<R>
abstract <R> Stream<R>
Stream.slidingMap
(int increment, boolean ignoreNotPaired, TriFunction<? super T, ? super T, ? super T, ? extends R> mapper) abstract <R> Stream<R>
Stream.slidingMap
(int increment, boolean ignoreNotPaired, BiFunction<? super T, ? super T, ? extends R> mapper) abstract <R> Stream<R>
Stream.slidingMap
(int increment, TriFunction<? super T, ? super T, ? super T, ? extends R> mapper) Slide withwindowSize = 3
and the specifiedincrement
, thenmap
by the specifiedmapper
.abstract <R> Stream<R>
Stream.slidingMap
(int increment, BiFunction<? super T, ? super T, ? extends R> mapper) Slide withwindowSize = 2
and the specifiedincrement
, thenmap
by the specifiedmapper
.abstract <R> Stream<R>
Stream.slidingMap
(TriFunction<? super T, ? super T, ? super T, ? extends R> mapper) abstract <R> Stream<R>
Stream.slidingMap
(BiFunction<? super T, ? super T, ? extends R> mapper) BaseStream.slidingToList
(int windowSize) BaseStream.slidingToList
(int windowSize, int increment) EntryStream.slidingToList
(int windowSize, int increment) Stream.slidingToSet
(int windowSize) Stream.slidingToSet
(int windowSize, int increment) Stream.sorted
(Comparator<? super T> comparator) Stream.sortedBy
(Function<? super T, ? extends Comparable> keyMapper) Stream.sortedByDouble
(ToDoubleFunction<? super T> keyMapper) Stream.sortedByInt
(ToIntFunction<? super T> keyMapper) Stream.sortedByLong
(ToLongFunction<? super T> keyMapper) BaseStream.split
(int chunkSize) Returns Stream ofS
with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).Split the stream by the specified predicate.Stream<EntryStream<K,
V>> EntryStream.split
(int chunkSize) Stream<EntryStream<K,
V>> 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 <R> Stream<R>
Stream.split
(CharSequence str, CharSequence delimiter) abstract <C extends Collection<T>>
Stream<C>abstract <R> Stream<R>
BaseStream.splitAt
(int where) Split the stream into two pieces atwhere
.Split the stream into two pieces atwhere
turns totrue
.Stream<EntryStream<K,
V>> EntryStream.splitAt
(int where) Stream<EntryStream<K,
V>> abstract <R> Stream<R>
Split the stream into two pieces atwhere
turns tofalse
.abstract <R> Stream<R>
Split the stream into two pieces atwhere
turns tofalse
.BaseStream.splitToList
(int chunkSize) Returns Stream ofPL
with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).BaseStream.splitToList
(P predicate) Split the stream by the specified predicate.EntryStream.splitToList
(int chunkSize) EntryStream.splitToList
(Predicate<? super Map.Entry<K, V>> predicate) 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).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 operationop
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.Stream.spsFilterE
(int maxThreadNum, Throwables.Predicate<? super T, ? extends Exception> predicate) Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.Stream.spsFilterE
(Throwables.Predicate<? super T, ? extends Exception> predicate) Temporarily switch the stream to parallel stream for operationfilter
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 operationflatMap
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 operationflatMap
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 operationflatMap
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 operationflatMap
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 operationflatMap
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 operationflatMap
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 operationflatMap
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 operationflatMap
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 operationflatMap
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 operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.<R> Stream<R>
Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.<R> Stream<R>
Temporarily switch the stream to parallel stream for operationmap
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 operationmap
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 operationmap
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.Stream.spsOnEachE
(int maxThreadNum, Throwables.Consumer<? super T, ? extends Exception> action) Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.Stream.spsOnEachE
(Throwables.Consumer<? super T, ? extends Exception> action) Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.Stream.takeWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction) Add a new Stream with terminal action to listen/consume the elements not token by the specifiedpredicate
.Stream.takeWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor) Add a new Stream with terminal action to listen/consume the elements not token by the specifiedpredicate
.Stream.top
(int n)
This method only runs sequentially, even in parallel stream.Stream.top
(int n, Comparator<? super T> comparator)
This method only runs sequentially, even in parallel stream.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) Modifier and TypeMethodDescriptionstatic <T> Stream<T>
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.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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) Modifier and TypeMethodDescriptionStream.addSubscriber
(Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction) Add a new Stream with terminal action to listen/consume the elements from upstream.Stream.addSubscriber
(Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor) Add a new Stream with terminal action to listen/consume the elements from upstream.<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) Stream.asyncRun
(Throwables.Consumer<? super Stream<T>, ? extends Exception> terminalAction) 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) Stream.defaultIfEmpty
(Supplier<? extends Stream<T>> supplier) static <T> Stream<T>
Lazy evaluation.Stream.dropWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction) Add a new Stream with terminal action to listen/consume the elements dropped by the specifiedpredicate
.Stream.dropWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor) Add a new Stream with terminal action to listen/consume the elements dropped by the specifiedpredicate
.Stream.filterWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction) Add a new Stream with terminal action to listen/consume the elements filtered out by the specifiedpredicate
.Stream.filterWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor) Add a new Stream with terminal action to listen/consume the elements filtered out by the specifiedpredicate
.abstract <R> Stream<R>
<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) 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) 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 inputCollection/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 inputCollection/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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.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 eachIterator/Collection/Stream
to read the elements to queue for thezipFunction
.<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 operationop
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 operationop
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 operationflatMap
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 operationflatMap
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 operationflatMap
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 operationflatMap
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 operationflatMap
and then switch back to sequence stream.Stream.takeWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction) Add a new Stream with terminal action to listen/consume the elements not token by the specifiedpredicate
.Stream.takeWhileAddSubscriber
(Predicate<? super T> predicate, Throwables.Consumer<? super Stream<T>, ? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor) Add a new Stream with terminal action to listen/consume the elements not token by the specifiedpredicate
.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.