Package com.landawn.abacus.util.stream

Class DoubleStream

java.lang.Object

com.landawn.abacus.util.stream.DoubleStream

All Implemented Interfaces:

Immutable, BaseStream<Double,double[],DoublePredicate,DoubleConsumer,DoubleList,u.OptionalDouble,IndexedDouble,DoubleIterator,DoubleStream>, Closeable, AutoCloseable

Direct Known Subclasses:

DoubleStream.DoubleStreamEx

@Immutable
public abstract class DoubleStream
extends Object

The Stream will be automatically closed after execution(A terminal method is executed/triggered).

See Also:

• BaseStream
• Stream

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	DoubleStream.DoubleStreamEx

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

BaseStream.ParallelSettings, BaseStream.Splitor

Method Summary

Modifier and Type	Method	Description
<SS extends BaseStream> SS	__(Function<? super DoubleStream,? extends SS> transfer)	Deprecated. replaced by BaseStream.transform(Function)
abstract <E extends Exception> boolean	allMatch(Throwables.DoublePredicate<E> predicate)
abstract <E extends Exception> boolean	anyMatch(Throwables.DoublePredicate<E> predicate)
abstract DoubleStream	append(double... a)
abstract DoubleStream	appendIfEmpty(double... a)
abstract u.OptionalDouble	average()
abstract Stream<Double>	boxed()
void	close()	It will be called by terminal operations in final.
abstract Stream<DoubleList>	collapse(DoubleBiPredicate collapsible)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract DoubleStream	collapse(DoubleBiPredicate collapsible, DoubleBinaryOperator mergeFunction)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract DoubleStream	collapse(DoubleTriPredicate collapsible, DoubleBinaryOperator mergeFunction)
abstract <R> R	collect(Supplier<R> supplier, ObjDoubleConsumer<? super R> accumulator)	Only call this method when the returned type R is one types: Collection/Map/StringBuilder/Multiset/LongMultiset/Multimap/BooleanList/IntList/.../DoubleList.
abstract <R> R	collect(Supplier<R> supplier, ObjDoubleConsumer<? super R> accumulator, BiConsumer<R,R> combiner)
static DoubleStream	concat(double[]... a)
static DoubleStream	concat(DoubleIterator... a)
static DoubleStream	concat(DoubleStream... a)
static DoubleStream	concat(Collection<? extends DoubleStream> c)
static DoubleStream	concat(List<double[]> c)
static DoubleStream	concatIterators(Collection<? extends DoubleIterator> c)
static DoubleStream	defer(Supplier<DoubleStream> supplier)	Lazy evaluation.
DoubleStream	delay(Duration delay)
u.OptionalDouble	elementAt(long position)
static DoubleStream	empty()
abstract <E extends Exception> u.OptionalDouble	findAny(Throwables.DoublePredicate<E> predicate)
abstract <E extends Exception> u.OptionalDouble	findFirst(Throwables.DoublePredicate<E> predicate)
abstract <E extends Exception> u.OptionalDouble	findFirstOrAny(Throwables.DoublePredicate<E> predicateForFirst)	Returns the first element matched by predicateForFirst if found or the first element if this stream is not empty Otherwise an empty OptionalDouble will be returned.
abstract <E extends Exception> u.OptionalDouble	findFirstOrLast(Throwables.DoublePredicate<E> predicateForFirst)	Returns the first element matched by predicateForFirst if found or the last element if this stream is not empty Otherwise an empty OptionalDouble will be returned.
abstract <E extends Exception> u.OptionalDouble	findLast(Throwables.DoublePredicate<E> predicate)	Consider using: stream.reversed().findFirst(predicate) for better performance if possible.
abstract DoubleStream	flatmap(DoubleFunction<double[]> mapper)
abstract DoubleStream	flatMap(DoubleFunction<? extends DoubleStream> mapper)
abstract FloatStream	flatMapToFloat(DoubleFunction<? extends FloatStream> mapper)
abstract IntStream	flatMapToInt(DoubleFunction<? extends IntStream> mapper)
abstract LongStream	flatMapToLong(DoubleFunction<? extends LongStream> mapper)
abstract <T> Stream<T>	flatmapToObj(DoubleFunction<? extends Collection<? extends T>> mapper)
abstract <T> Stream<T>	flatMapToObj(DoubleFunction<? extends Stream<? extends T>> mapper)
static DoubleStream	flatten(double[][] a)
static DoubleStream	flatten(double[][][] a)
static DoubleStream	flatten(double[][] a, boolean vertically)
static DoubleStream	flatten(double[][] a, double valueForNone, boolean vertically)
abstract DoubleStream	flattmap(DoubleFunction<? extends DoubleStream> mapper)
abstract <T> Stream<T>	flattMapToObj(DoubleFunction<T[]> mapper)
abstract <E extends Exception> void	forEach(Throwables.DoubleConsumer<E> action)
abstract <E extends Exception> void	forEachIndexed(Throwables.IndexedDoubleConsumer<E> action)
static DoubleStream	generate(DoubleSupplier s)
abstract <K, D, E extends Exception> Map<K,D>	groupTo(Throwables.DoubleFunction<? extends K,E> keyMapper, Collector<? super Double,?,D> downstream)
abstract <K, D, M extends Map<K, D>, E extends Exception> M	groupTo(Throwables.DoubleFunction<? extends K,E> keyMapper, Collector<? super Double,?,D> downstream, Supplier<? extends M> mapFactory)
boolean	isParallel()
static DoubleStream	iterate(double init, BooleanSupplier hasNext, DoubleUnaryOperator f)
static DoubleStream	iterate(double init, DoublePredicate hasNext, DoubleUnaryOperator f)
static DoubleStream	iterate(double init, DoubleUnaryOperator f)
static DoubleStream	iterate(BooleanSupplier hasNext, DoubleSupplier next)
DoubleIterator	iterator()	Remember to close this Stream after the iteration is done, if needed.
String	join(CharSequence delimiter)
abstract u.OptionalDouble	kthLargest(int k)
abstract DoubleStream	map(DoubleUnaryOperator mapper)
abstract DoubleStream	mapMulti(DoubleMapMultiConsumer mapper)
abstract DoubleStream	mapPartial(DoubleFunction<u.OptionalDouble> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract DoubleStream	mapPartialJdk(DoubleFunction<OptionalDouble> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract FloatStream	mapToFloat(DoubleToFloatFunction mapper)
abstract IntStream	mapToInt(DoubleToIntFunction mapper)
abstract LongStream	mapToLong(DoubleToLongFunction mapper)
abstract <T> Stream<T>	mapToObj(DoubleFunction<? extends T> mapper)
abstract u.OptionalDouble	max()
static DoubleStream	merge(double[] a, double[] b, double[] c, DoubleBiFunction<MergeResult> nextSelector)
static DoubleStream	merge(double[] a, double[] b, DoubleBiFunction<MergeResult> nextSelector)
static DoubleStream	merge(DoubleIterator a, DoubleIterator b, DoubleIterator c, DoubleBiFunction<MergeResult> nextSelector)
static DoubleStream	merge(DoubleIterator a, DoubleIterator b, DoubleBiFunction<MergeResult> nextSelector)
static DoubleStream	merge(DoubleStream a, DoubleStream b, DoubleBiFunction<MergeResult> nextSelector)
static DoubleStream	merge(DoubleStream a, DoubleStream b, DoubleStream c, DoubleBiFunction<MergeResult> nextSelector)
static DoubleStream	merge(Collection<? extends DoubleStream> c, DoubleBiFunction<MergeResult> nextSelector)
abstract DoubleStream	mergeWith(DoubleStream b, DoubleBiFunction<MergeResult> nextSelector)
abstract u.OptionalDouble	min()
abstract <E extends Exception> boolean	noneMatch(Throwables.DoublePredicate<E> predicate)
static DoubleStream	of(double... a)
static DoubleStream	of(double[] a, int startIndex, int endIndex)
static DoubleStream	of(DoubleIterator iterator)
static DoubleStream	of(u.OptionalDouble op)
static DoubleStream	of(Double[] a)
static DoubleStream	of(Double[] a, int startIndex, int endIndex)
static DoubleStream	of(DoubleBuffer buf)
static DoubleStream	of(Collection<Double> c)
static DoubleStream	of(OptionalDouble op)
static DoubleStream	of(DoubleStream stream)
static DoubleStream	ofNullable(Double e)
DoubleStream	parallel()	Consider using sps(Function) if only next operation need to be parallelized.
DoubleStream	parallel(int maxThreadNum)	Consider using sps(int, Function) if only next operation need to be parallelized.
DoubleStream	parallel(int maxThreadNum, BaseStream.Splitor splitor)	Returns an equivalent stream that is parallel.
DoubleStream	parallel(int maxThreadNum, BaseStream.Splitor splitor, Executor executor)	stream.parallel(maxThreadNum, splitor, executor).map(f).filter(p)...; // Replace above line of code with "sps" if only "f" need to be parallelized.
DoubleStream	parallel(int maxThreadNum, Executor executor)	// Replace above line of code with "sps" if only "f" need to be parallelized.
DoubleStream	parallel(BaseStream.ParallelSettings ps)	stream.parallel(parallelSettings).map(f).filter(p)...; // Replace above line of code with "sps" if only "f" need to be parallelized.
DoubleStream	parallel(BaseStream.Splitor splitor)
DoubleStream	parallel(Executor executor)	stream.parallel(executor).map(f).filter(p)...; // Replace above line of code with "sps" if only "f" need to be parallelized.
static DoubleStream	parallelMerge(Collection<? extends DoubleStream> c, DoubleBiFunction<MergeResult> nextSelector)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
static DoubleStream	parallelMerge(Collection<? extends DoubleStream> c, DoubleBiFunction<MergeResult> nextSelector, int maxThreadNum)	All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads.
DoubleStream	peek(DoubleConsumer action)
abstract DoubleStream	prepend(double... a)
void	println()
<SS extends BaseStream> SS	psp(Function<? super DoubleStream,? extends SS> ops)	Temporarily switch the stream to sequence stream for operation ops and then switch back to parallel stream with same maxThreadNum/splitor/asyncExecutor.
static DoubleStream	random()
abstract DoubleStream	rangeMap(DoubleBiPredicate sameRange, DoubleBinaryOperator 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>	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.
DoubleStream	rateLimited(double permitsPerSecond)
DoubleStream	rateLimited(RateLimiter rateLimiter)
abstract double	reduce(double identity, DoubleBinaryOperator op)
abstract u.OptionalDouble	reduce(DoubleBinaryOperator op)
static DoubleStream	repeat(double element, long n)
abstract DoubleStream	scan(double init, DoubleBinaryOperator accumulator)	Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream.
abstract DoubleStream	scan(double init, DoubleBinaryOperator accumulator, boolean initIncluded)
abstract DoubleStream	scan(DoubleBinaryOperator accumulator)	Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream.
DoubleStream	sequential()
DoubleStream	shuffled()	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
DoubleStream	skipUntil(DoublePredicate predicate)
Stream<DoubleStream>	sliding(int windowSize)
Stream<DoubleList>	slidingToList(int windowSize)
<SS extends BaseStream> SS	sps(int maxThreadNum, Function<? super DoubleStream,? extends SS> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
<SS extends BaseStream> SS	sps(Function<? super DoubleStream,? extends SS> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
abstract double	sum()
abstract DoubleSummaryStatistics	summarize()
abstract Pair<DoubleSummaryStatistics,u.Optional<Map<Percentage,Double>>>	summarizeAndPercentiles()
DoubleStream	throwIfEmpty(Supplier<? extends RuntimeException> exceptionSupplier)
double[]	toArray()
abstract DoubleList	toDoubleList()
ImmutableList<Double>	toImmutableList()
ImmutableSet<Double>	toImmutableSet()
abstract DoubleStream	toJdkStream()
abstract <K, V, E extends Exception, E2 extends Exception> Map<K,V>	toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Throwables.DoubleFunction<? extends V,E2> valueMapper)
abstract <K, V, E extends Exception, E2 extends Exception> Map<K,V>	toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Throwables.DoubleFunction<? extends V,E2> valueMapper, BinaryOperator<V> mergeFunction)
abstract <K, V, M extends Map<K, V>, E extends Exception, E2 extends Exception> M	toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Throwables.DoubleFunction<? extends V,E2> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)
abstract <K, V, M extends Map<K, V>, E extends Exception, E2 extends Exception> M	toMap(Throwables.DoubleFunction<? extends K,E> keyMapper, Throwables.DoubleFunction<? extends V,E2> valueMapper, Supplier<? extends M> mapFactory)
abstract DoubleStream	top(int n)	This method only runs sequentially, even in parallel stream.
abstract DoubleStream	top(int n, Comparator<? super Double> comparator)	This method only runs sequentially, even in parallel stream.
<SS extends BaseStream> SS	transform(Function<? super DoubleStream,? extends SS> transfer)
static DoubleStream	zip(double[] a, double[] b, double[] c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTernaryOperator zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static DoubleStream	zip(double[] a, double[] b, double[] c, DoubleTernaryOperator zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static DoubleStream	zip(double[] a, double[] b, double valueForNoneA, double valueForNoneB, DoubleBinaryOperator zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static DoubleStream	zip(double[] a, double[] b, DoubleBinaryOperator zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static DoubleStream	zip(DoubleIterator a, DoubleIterator b, double valueForNoneA, double valueForNoneB, DoubleBinaryOperator zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static DoubleStream	zip(DoubleIterator a, DoubleIterator b, DoubleIterator c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTernaryOperator zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static DoubleStream	zip(DoubleIterator a, DoubleIterator b, DoubleIterator c, DoubleTernaryOperator zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
static DoubleStream	zip(DoubleIterator a, DoubleIterator b, DoubleBinaryOperator zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static DoubleStream	zip(DoubleStream a, DoubleStream b, double valueForNoneA, double valueForNoneB, DoubleBinaryOperator zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static DoubleStream	zip(DoubleStream a, DoubleStream b, DoubleStream c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTernaryOperator zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static DoubleStream	zip(DoubleStream a, DoubleStream b, DoubleStream c, DoubleTernaryOperator zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static DoubleStream	zip(DoubleStream a, DoubleStream b, DoubleBinaryOperator zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static DoubleStream	zip(Collection<? extends DoubleStream> c, double[] valuesForNone, DoubleNFunction<Double> zipFunction)	Zip together the iterators until all of them runs out of values.
static DoubleStream	zip(Collection<? extends DoubleStream> c, DoubleNFunction<Double> zipFunction)	Zip together the iterators until one of them runs out of values.
abstract DoubleStream	zipWith(DoubleStream b, double valueForNoneA, double valueForNoneB, DoubleBinaryOperator zipFunction)
abstract DoubleStream	zipWith(DoubleStream b, DoubleStream c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTernaryOperator zipFunction)
abstract DoubleStream	zipWith(DoubleStream b, DoubleStream c, DoubleTernaryOperator zipFunction)
abstract DoubleStream	zipWith(DoubleStream b, DoubleBinaryOperator zipFunction)

Methods inherited from class java.lang.Object

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

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

acceptIfNotEmpty, append, append, appendIfEmpty, applyIfNotEmpty, count, cycled, cycled, difference, distinct, dropWhile, dropWhile, filter, filter, first, indexed, intersection, join, last, limit, onClose, onEach, onlyOne, percentiles, prepend, prepend, reversed, reverseSorted, rotated, shuffled, skip, skip, sliding, slidingToList, sorted, split, split, splitAt, splitAt, splitToList, splitToList, step, symmetricDifference, takeWhile, toCollection, toList, toLongMultiset, toLongMultiset, toMultiset, toMultiset, toSet

Method Details

rateLimited

public DoubleStream rateLimited(RateLimiter rateLimiter)

Returns:

See Also:

• RateLimiter.acquire()

delay

public DoubleStream delay(Duration delay)

Returns:

skipUntil

public DoubleStream skipUntil(DoublePredicate predicate)

Returns:

See Also:

• BaseStream.dropWhile(Object)

map

@ParallelSupported
@IntermediateOp
public abstract DoubleStream map(DoubleUnaryOperator mapper)

mapToInt

@ParallelSupported
@IntermediateOp
public abstract IntStream mapToInt(DoubleToIntFunction mapper)

mapToLong

@ParallelSupported
@IntermediateOp
public abstract LongStream mapToLong(DoubleToLongFunction mapper)

mapToFloat

@ParallelSupported
@IntermediateOp
public abstract FloatStream mapToFloat(DoubleToFloatFunction mapper)

mapToObj

@ParallelSupported
@IntermediateOp
public abstract <T> Stream<T> mapToObj(DoubleFunction<? extends T> mapper)

flatMap

@ParallelSupported
@IntermediateOp
public abstract DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper)

flatmap

@ParallelSupported
@IntermediateOp
public abstract DoubleStream flatmap(DoubleFunction<double[]> mapper)

flattmap

@Beta
@ParallelSupported
@IntermediateOp
public abstract DoubleStream flattmap(DoubleFunction<? extends DoubleStream> mapper)

flatMapToInt

@ParallelSupported
@IntermediateOp
public abstract IntStream flatMapToInt(DoubleFunction<? extends IntStream> mapper)

flatMapToLong

@ParallelSupported
@IntermediateOp
public abstract LongStream flatMapToLong(DoubleFunction<? extends LongStream> mapper)

flatMapToFloat

@ParallelSupported
@IntermediateOp
public abstract FloatStream flatMapToFloat(DoubleFunction<? extends FloatStream> mapper)

flatMapToObj

@ParallelSupported
@IntermediateOp
public abstract <T> Stream<T> flatMapToObj(DoubleFunction<? extends Stream<? extends T>> mapper)

flatmapToObj

@ParallelSupported
@IntermediateOp
public abstract <T> Stream<T> flatmapToObj(DoubleFunction<? extends Collection<? extends T>> mapper)

flattMapToObj

@ParallelSupported
@IntermediateOp
public abstract <T> Stream<T> flattMapToObj(DoubleFunction<T[]> mapper)

mapMulti

@ParallelSupported
@IntermediateOp
public abstract DoubleStream mapMulti(DoubleMapMultiConsumer mapper)

mapPartial

@Beta
@ParallelSupported
@IntermediateOp
public abstract DoubleStream mapPartial(DoubleFunction<u.OptionalDouble> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Type Parameters:

R -

Parameters:

mapper -

Returns:

mapPartialJdk

@Beta
@ParallelSupported
@IntermediateOp
public abstract DoubleStream mapPartialJdk(DoubleFunction<OptionalDouble> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Type Parameters:

R -

Parameters:

mapper -

Returns:

rangeMap

@SequentialOnly
@IntermediateOp
public abstract DoubleStream rangeMap(DoubleBiPredicate sameRange,
 DoubleBinaryOperator 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. This is a quasi-intermediate partial reduction operation.

Parameters:

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

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

Returns:

See Also:

• collapse(DoubleBiPredicate, DoubleBinaryOperator)
• Stream.rangeMap(BiPredicate, BiFunction)

rangeMapToObj

@SequentialOnly
@IntermediateOp
public abstract <T> Stream<T> 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. This is a quasi-intermediate partial reduction operation.

Parameters:

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

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

Returns:

See Also:

• Stream.rangeMap(BiPredicate, BiFunction)

collapse

@SequentialOnly
@IntermediateOp
public abstract Stream<DoubleList> collapse(DoubleBiPredicate collapsible)

Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
This method only runs sequentially, even in parallel stream.

Parameters:

collapsible -

Returns:

collapse

@SequentialOnly
@IntermediateOp
public abstract DoubleStream collapse(DoubleBiPredicate collapsible,
 DoubleBinaryOperator mergeFunction)

Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
This method only runs sequentially, even in parallel stream.

Parameters:

collapsible -

mergeFunction -

Returns:

collapse

@SequentialOnly
@IntermediateOp
public abstract DoubleStream collapse(DoubleTriPredicate collapsible,
 DoubleBinaryOperator mergeFunction)

Parameters:

collapsible - test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.

mergeFunction -

Returns:

scan

@SequentialOnly
@IntermediateOp
public abstract DoubleStream scan(DoubleBinaryOperator accumulator)

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

This is an intermediate operation.

Example:

 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [1, 3, 6, 10, 15]
 

This method only runs sequentially, even in parallel stream.

Parameters:

accumulator - the accumulation function

Returns:

scan

@SequentialOnly
@IntermediateOp
public abstract DoubleStream scan(double init,
 DoubleBinaryOperator accumulator)

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

This is an intermediate operation.

Example:

 init:10
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [11, 13, 16, 20, 25]
 

This method only runs sequentially, even in parallel stream.

Parameters:

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

accumulator - the accumulation function

Returns:

scan

@SequentialOnly
@IntermediateOp
public abstract DoubleStream scan(double init,
 DoubleBinaryOperator accumulator,
 boolean initIncluded)

Parameters:

init -

accumulator -

initIncluded -

Returns:

prepend

@SequentialOnly
@IntermediateOp
public abstract DoubleStream prepend(double... a)

append

@SequentialOnly
@IntermediateOp
public abstract DoubleStream append(double... a)

appendIfEmpty

@SequentialOnly
@IntermediateOp
public abstract DoubleStream appendIfEmpty(double... a)

top

@SequentialOnly
@IntermediateOp
public abstract DoubleStream top(int n)

This method only runs sequentially, even in parallel stream.

Parameters:

n -

Returns:

top

@SequentialOnly
@IntermediateOp
public abstract DoubleStream top(int n,
 Comparator<? super Double> comparator)

This method only runs sequentially, even in parallel stream.

Parameters:

n -

comparator -

Returns:

toDoubleList

@SequentialOnly
@TerminalOp
public abstract DoubleList toDoubleList()

toMap

@ParallelSupported
@TerminalOp
public abstract <K,
V,
E extends Exception,
E2 extends Exception>
Map<K,V> toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
 Throwables.DoubleFunction<? extends V,E2> valueMapper)
        throws E,
E2

Parameters:

keyMapper -

valueMapper -

Returns:

Throws:

E extends Exception

E2 extends Exception

See Also:

• Collectors#toMap(Throwables.Function, Throwables.Function)

toMap

@ParallelSupported
@TerminalOp
public abstract <K,
V,
M extends Map<K,
V>,
E extends Exception,
E2 extends Exception>
M toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
 Throwables.DoubleFunction<? extends V,E2> valueMapper,
 Supplier<? extends M> mapFactory)
 throws E,
E2

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

Throws:

E extends Exception

E2 extends Exception

See Also:

• Collectors#toMap(Throwables.Function, Throwables.Function, Supplier)

toMap

@ParallelSupported
@TerminalOp
public abstract <K,
V,
E extends Exception,
E2 extends Exception>
Map<K,V> toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
 Throwables.DoubleFunction<? extends V,E2> valueMapper,
 BinaryOperator<V> mergeFunction)
        throws E,
E2

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

Throws:

E extends Exception

E2 extends Exception

See Also:

• Collectors#toMap(Throwables.Function, Throwables.Function, BinaryOperator)

toMap

@ParallelSupported
@TerminalOp
public abstract <K,
V,
M extends Map<K,
V>,
E extends Exception,
E2 extends Exception>
M toMap(Throwables.DoubleFunction<? extends K,E> keyMapper,
 Throwables.DoubleFunction<? extends V,E2> valueMapper,
 BinaryOperator<V> mergeFunction,
 Supplier<? extends M> mapFactory)
 throws E,
E2

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

Throws:

E extends Exception

E2 extends Exception

See Also:

• Collectors#toMap(Throwables.Function, Throwables.Function, BinaryOperator, Supplier)

groupTo

@ParallelSupported
@TerminalOp
public abstract <K,
D,
E extends Exception> Map<K,D> groupTo(Throwables.DoubleFunction<? extends K,E> keyMapper,
 Collector<? super Double,?,D> downstream)
                                                    throws E

Parameters:

keyMapper -

downstream -

Returns:

Throws:

E extends Exception

See Also:

• Collectors#groupingBy(Throwables.Function, Collector)

groupTo

@ParallelSupported
@TerminalOp
public abstract <K,
D,
M extends Map<K,
D>,
E extends Exception>
M groupTo(Throwables.DoubleFunction<? extends K,E> keyMapper,
 Collector<? super Double,?,D> downstream,
 Supplier<? extends M> mapFactory)
   throws E

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

Throws:

E extends Exception

See Also:

• Collectors#groupingBy(Throwables.Function, Collector, Supplier)

reduce

@ParallelSupported
@TerminalOp
public abstract double reduce(double identity,
 DoubleBinaryOperator op)

reduce

@ParallelSupported
@TerminalOp
public abstract u.OptionalDouble reduce(DoubleBinaryOperator op)

collect

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

Type Parameters:

R -

Parameters:

supplier -

accumulator -

combiner -

Returns:

See Also:

• Stream.collect(Supplier, BiConsumer, BiConsumer)

collect

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

Only call this method when the returned type R is one types: Collection/Map/StringBuilder/Multiset/LongMultiset/Multimap/BooleanList/IntList/.../DoubleList. Otherwise, please call collect(Supplier, ObjDoubleConsumer, BiConsumer).

Parameters:

supplier -

accumulator -

Returns:

See Also:

• collect(Supplier, ObjDoubleConsumer, BiConsumer)
• Stream.collect(Supplier, BiConsumer)
• Stream.collect(Supplier, BiConsumer, BiConsumer)

forEach

@ParallelSupported
@TerminalOp
public abstract <E extends Exception> void forEach(Throwables.DoubleConsumer<E> action)
                                            throws E

Throws:

E extends Exception

forEachIndexed

@ParallelSupported
@TerminalOp
public abstract <E extends Exception> void forEachIndexed(Throwables.IndexedDoubleConsumer<E> action)
                                                   throws E

Throws:

E extends Exception

anyMatch

@ParallelSupported
@TerminalOp
public abstract <E extends Exception> boolean anyMatch(Throwables.DoublePredicate<E> predicate)
                                                throws E

Throws:

E extends Exception

allMatch

@ParallelSupported
@TerminalOp
public abstract <E extends Exception> boolean allMatch(Throwables.DoublePredicate<E> predicate)
                                                throws E

Throws:

E extends Exception

noneMatch

@ParallelSupported
@TerminalOp
public abstract <E extends Exception> boolean noneMatch(Throwables.DoublePredicate<E> predicate)
                                                 throws E

Throws:

E extends Exception

findFirst

@ParallelSupported
@TerminalOp
public abstract <E extends Exception>
u.OptionalDouble findFirst(Throwables.DoublePredicate<E> predicate)
                    throws E

Throws:

E extends Exception

findFirstOrAny

@ParallelSupported
@TerminalOp
public abstract <E extends Exception>
u.OptionalDouble findFirstOrAny(Throwables.DoublePredicate<E> predicateForFirst)
                         throws E

Returns the first element matched by predicateForFirst if found or the first element if this stream is not empty Otherwise an empty OptionalDouble will be returned.

Type Parameters:

E -

Parameters:

predicateForFirst -

Returns:

Throws:

E

findFirstOrLast

@ParallelSupported
@TerminalOp
public abstract <E extends Exception>
u.OptionalDouble findFirstOrLast(Throwables.DoublePredicate<E> predicateForFirst)
                          throws E

Returns the first element matched by predicateForFirst if found or the last element if this stream is not empty Otherwise an empty OptionalDouble will be returned.

Type Parameters:

E -

Parameters:

predicateForFirst -

Returns:

Throws:

E

findLast

@ParallelSupported
@TerminalOp
public abstract <E extends Exception>
u.OptionalDouble findLast(Throwables.DoublePredicate<E> predicate)
                   throws E

Consider using: stream.reversed().findFirst(predicate) for better performance if possible.

Type Parameters:

E -

Parameters:

predicate -

Returns:

Throws:

E

findAny

@ParallelSupported
@TerminalOp
public abstract <E extends Exception>
u.OptionalDouble findAny(Throwables.DoublePredicate<E> predicate)
                  throws E

Throws:

E extends Exception

min

@SequentialOnly
@TerminalOp
public abstract u.OptionalDouble min()

max

@SequentialOnly
@TerminalOp
public abstract u.OptionalDouble max()

kthLargest

@SequentialOnly
@TerminalOp
public abstract u.OptionalDouble kthLargest(int k)

Parameters:

k -

Returns:

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

sum

@SequentialOnly
@TerminalOp
public abstract double sum()

average

@SequentialOnly
@TerminalOp
public abstract u.OptionalDouble average()

summarize

@SequentialOnly
@TerminalOp
public abstract DoubleSummaryStatistics summarize()

summarizeAndPercentiles

@SequentialOnly
@TerminalOp
public abstract Pair<DoubleSummaryStatistics,u.Optional<Map<Percentage,Double>>> summarizeAndPercentiles()

mergeWith

@SequentialOnly
@IntermediateOp
public abstract DoubleStream mergeWith(DoubleStream b,
 DoubleBiFunction<MergeResult> nextSelector)

Parameters:

b -

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

Returns:

zipWith

@ParallelSupported
@IntermediateOp
public abstract DoubleStream zipWith(DoubleStream b,
 DoubleBinaryOperator zipFunction)

zipWith

@ParallelSupported
@IntermediateOp
public abstract DoubleStream zipWith(DoubleStream b,
 DoubleStream c,
 DoubleTernaryOperator zipFunction)

zipWith

@ParallelSupported
@IntermediateOp
public abstract DoubleStream zipWith(DoubleStream b,
 double valueForNoneA,
 double valueForNoneB,
 DoubleBinaryOperator zipFunction)

zipWith

@ParallelSupported
@IntermediateOp
public abstract DoubleStream zipWith(DoubleStream b,
 DoubleStream c,
 double valueForNoneA,
 double valueForNoneB,
 double valueForNoneC,
 DoubleTernaryOperator zipFunction)

toJdkStream

@SequentialOnly
@IntermediateOp
public abstract DoubleStream toJdkStream()

boxed

@SequentialOnly
@IntermediateOp
public abstract Stream<Double> boxed()

iterator

public DoubleIterator iterator()

Remember to close this Stream after the iteration is done, if needed.

Returns:

empty

public static DoubleStream empty()

ofNullable

public static DoubleStream ofNullable(Double e)

of

@SafeVarargs
public static DoubleStream of(double... a)

of

public static DoubleStream of(double[] a,
 int startIndex,
 int endIndex)

of

public static DoubleStream of(Double[] a)

of

public static DoubleStream of(Double[] a,
 int startIndex,
 int endIndex)

of

public static DoubleStream of(Collection<Double> c)

of

public static DoubleStream of(DoubleIterator iterator)

of

public static DoubleStream of(DoubleStream stream)

of

public static DoubleStream of(DoubleBuffer buf)

of

public static DoubleStream of(u.OptionalDouble op)

of

public static DoubleStream of(OptionalDouble op)

defer

public static DoubleStream defer(Supplier<DoubleStream> supplier)

Lazy evaluation.
This is equal to: Stream.just(supplier).flatMapToDouble(it -> it.get()).

Type Parameters:

T -

Parameters:

supplier -

Returns:

flatten

public static DoubleStream flatten(double[][] a)

flatten

public static DoubleStream flatten(double[][] a,
 boolean vertically)

flatten

public static DoubleStream flatten(double[][] a,
 double valueForNone,
 boolean vertically)

flatten

public static DoubleStream flatten(double[][][] a)

repeat

public static DoubleStream repeat(double element,
 long n)

random

public static DoubleStream random()

iterate

public static DoubleStream iterate(BooleanSupplier hasNext,
 DoubleSupplier next)

iterate

public static DoubleStream iterate(double init,
 BooleanSupplier hasNext,
 DoubleUnaryOperator f)

iterate

public static DoubleStream iterate(double init,
 DoublePredicate hasNext,
 DoubleUnaryOperator f)

Parameters:

init -

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

f -

Returns:

iterate

public static DoubleStream iterate(double init,
 DoubleUnaryOperator f)

generate

public static DoubleStream generate(DoubleSupplier s)

concat

@SafeVarargs
public static DoubleStream concat(double[]... a)

concat

@SafeVarargs
public static DoubleStream concat(DoubleIterator... a)

concat

@SafeVarargs
public static DoubleStream concat(DoubleStream... a)

concat

@Beta
public static DoubleStream concat(List<double[]> c)

concat

public static DoubleStream concat(Collection<? extends DoubleStream> c)

concatIterators

@Beta
public static DoubleStream concatIterators(Collection<? extends DoubleIterator> c)

zip

public static DoubleStream zip(double[] a,
 double[] b,
 DoubleBinaryOperator zipFunction)

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

Parameters:

a -

b -

Returns:

zip

public static DoubleStream zip(double[] a,
 double[] b,
 double[] c,
 DoubleTernaryOperator zipFunction)

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

Parameters:

a -

b -

c -

Returns:

zip

public static DoubleStream zip(DoubleIterator a,
 DoubleIterator b,
 DoubleBinaryOperator zipFunction)

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

Parameters:

a -

b -

Returns:

zip

public static DoubleStream zip(DoubleIterator a,
 DoubleIterator b,
 DoubleIterator c,
 DoubleTernaryOperator zipFunction)

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

Parameters:

a -

b -

Returns:

zip

public static DoubleStream zip(DoubleStream a,
 DoubleStream b,
 DoubleBinaryOperator zipFunction)

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

Parameters:

a -

b -

Returns:

zip

public static DoubleStream zip(DoubleStream a,
 DoubleStream b,
 DoubleStream c,
 DoubleTernaryOperator zipFunction)

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

Parameters:

a -

b -

Returns:

zip

public static DoubleStream zip(Collection<? extends DoubleStream> c,
 DoubleNFunction<Double> zipFunction)

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

Parameters:

c -

zipFunction -

Returns:

zip

public static DoubleStream zip(double[] a,
 double[] b,
 double valueForNoneA,
 double valueForNoneB,
 DoubleBinaryOperator zipFunction)

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

Parameters:

a -

b -

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

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

zipFunction -

Returns:

zip

public static DoubleStream zip(double[] a,
 double[] b,
 double[] c,
 double valueForNoneA,
 double valueForNoneB,
 double valueForNoneC,
 DoubleTernaryOperator zipFunction)

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

Parameters:

a -

b -

c -

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

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

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

zipFunction -

Returns:

zip

public static DoubleStream zip(DoubleIterator a,
 DoubleIterator b,
 double valueForNoneA,
 double valueForNoneB,
 DoubleBinaryOperator zipFunction)

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

Parameters:

a -

b -

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

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

zipFunction -

Returns:

zip

public static DoubleStream zip(DoubleIterator a,
 DoubleIterator b,
 DoubleIterator c,
 double valueForNoneA,
 double valueForNoneB,
 double valueForNoneC,
 DoubleTernaryOperator zipFunction)

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

Parameters:

a -

b -

c -

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

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

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

zipFunction -

Returns:

zip

public static DoubleStream zip(DoubleStream a,
 DoubleStream b,
 double valueForNoneA,
 double valueForNoneB,
 DoubleBinaryOperator zipFunction)

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

Parameters:

a -

b -

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

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

zipFunction -

Returns:

zip

public static DoubleStream zip(DoubleStream a,
 DoubleStream b,
 DoubleStream c,
 double valueForNoneA,
 double valueForNoneB,
 double valueForNoneC,
 DoubleTernaryOperator zipFunction)

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

Parameters:

a -

b -

c -

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

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

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

zipFunction -

Returns:

zip

public static DoubleStream zip(Collection<? extends DoubleStream> c,
 double[] valuesForNone,
 DoubleNFunction<Double> zipFunction)

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

Parameters:

c -

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

zipFunction -

Returns:

merge

public static DoubleStream merge(double[] a,
 double[] b,
 DoubleBiFunction<MergeResult> nextSelector)

Parameters:

a -

b -

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

Returns:

merge

public static DoubleStream merge(double[] a,
 double[] b,
 double[] c,
 DoubleBiFunction<MergeResult> nextSelector)

Parameters:

a -

b -

c -

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

Returns:

merge

public static DoubleStream merge(DoubleIterator a,
 DoubleIterator b,
 DoubleBiFunction<MergeResult> nextSelector)

Parameters:

a -

b -

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

Returns:

merge

public static DoubleStream merge(DoubleIterator a,
 DoubleIterator b,
 DoubleIterator c,
 DoubleBiFunction<MergeResult> nextSelector)

Parameters:

a -

b -

c -

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

Returns:

merge

public static DoubleStream merge(DoubleStream a,
 DoubleStream b,
 DoubleBiFunction<MergeResult> nextSelector)

Parameters:

a -

b -

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

Returns:

merge

public static DoubleStream merge(DoubleStream a,
 DoubleStream b,
 DoubleStream c,
 DoubleBiFunction<MergeResult> nextSelector)

Parameters:

a -

b -

c -

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

Returns:

merge

public static DoubleStream merge(Collection<? extends DoubleStream> c,
 DoubleBiFunction<MergeResult> nextSelector)

Parameters:

c -

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

Returns:

parallelMerge

public static DoubleStream parallelMerge(Collection<? extends DoubleStream> c,
 DoubleBiFunction<MergeResult> nextSelector)

All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads. Then these two new queues will be merged into one Iterator/Stream by one thread. So it's not totally lazy evaluation and may cause out of memory error if there are too many elements merged into the new queues. Consider using merge, which is totally lazy evaluation.

Parameters:

c -

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

Returns:

parallelMerge

public static DoubleStream parallelMerge(Collection<? extends DoubleStream> c,
 DoubleBiFunction<MergeResult> nextSelector,
 int maxThreadNum)

All the elements from each input Collection/Iterator/Stream will be merged into two queues by multiple threads. Then these two new queues will be merged into one Iterator/Stream by one thread. So it's not totally lazy evaluation and may cause out of memory error if there are too many elements merged into the new queues. Consider using merge, which is totally lazy evaluation.

Parameters:

c -

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

maxThreadNum -

Returns:

elementAt

public u.OptionalDouble elementAt(long position)

Specified by:

elementAt in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

position -

Returns:

rateLimited

public DoubleStream rateLimited(double permitsPerSecond)

Specified by:

rateLimited in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

permitsPerSecond -

Returns:

See Also:

• RateLimiter.create(double)

peek

public DoubleStream peek(DoubleConsumer action)

Specified by:

peek in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

action -

Returns:

sliding

public Stream<DoubleStream> sliding(int windowSize)

Specified by:

sliding in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

windowSize -

Returns:

See Also:

• BaseStream.sliding(int, int)

slidingToList

public Stream<DoubleList> slidingToList(int windowSize)

Specified by:

slidingToList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

windowSize -

Returns:

See Also:

• BaseStream.sliding(int, int)

shuffled

public DoubleStream shuffled()

Description copied from interface: BaseStream

This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.

Specified by:

shuffled in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

throwIfEmpty

@SequentialOnly
@IntermediateOp
public DoubleStream throwIfEmpty(Supplier<? extends RuntimeException> exceptionSupplier)

Specified by:

throwIfEmpty in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

exceptionSupplier -

Returns:

toImmutableList

public ImmutableList<Double> toImmutableList()

Specified by:

toImmutableList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

toImmutableSet

public ImmutableSet<Double> toImmutableSet()

Specified by:

toImmutableSet in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

join

public String join(CharSequence delimiter)

Specified by:

join in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

delimiter -

Returns:

println

public void println()

Specified by:

println in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

transform

public <SS extends BaseStream> SS transform(Function<? super DoubleStream,? extends SS> transfer)

Specified by:

transform in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Type Parameters:

SS -

Parameters:

transfer -

Returns:

__

@Deprecated
public <SS extends BaseStream> SS __(Function<? super DoubleStream,? extends SS> transfer)

Deprecated.

replaced by BaseStream.transform(Function)

Specified by:

__ in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Type Parameters:

SS -

Parameters:

transfer -

Returns:

isParallel

public boolean isParallel()

Specified by:

isParallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

sequential

public DoubleStream sequential()

Specified by:

sequential in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

parallel

public DoubleStream parallel()

Description copied from interface: BaseStream

Consider using sps(Function) if only next operation need to be parallelized. For example:

 stream.parallel().map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel().map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(Function) is recommended in most of scenarios.

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

• BaseStream.parallel(Executor)
• BaseStream.parallel(int, Executor)
• BaseStream.parallel(int, Splitor, Executor)
• BaseStream.sps(Function)
• BaseStream.sps(int, Function)

parallel

public DoubleStream parallel(int maxThreadNum)

Description copied from interface: BaseStream

Consider using sps(int, Function) if only next operation need to be parallelized. For example:

 stream.parallel(maxThreadNum).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(maxThreadNum, s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(maxThreadNum).map(f).sequential().filter(p)...;

 

In most scenarios, there could be only one operation need be parallelized in the stream. So sps(int, Function) is recommended in most of scenarios.

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

maxThreadNum -

Returns:

See Also:

• #maxThreadNumPerOperation()

parallel

public DoubleStream parallel(BaseStream.Splitor splitor)

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

splitor -

Returns:

See Also:

• BaseStream.parallel(Executor)
• BaseStream.parallel(int, Executor)
• BaseStream.parallel(int, Splitor, Executor)
• BaseStream.sps(Function)
• BaseStream.sps(int, Function)

parallel

public DoubleStream parallel(int maxThreadNum,
 BaseStream.Splitor splitor)

Description copied from interface: BaseStream

Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same maxThreadNum and splitor as the specified ones.

When to use parallel Streams?

• First of all, do NOT and should NOT use parallel Streams if you don't have any problem with sequential Streams, because using parallel Streams has extra cost.
• Consider using parallel Streams only when N(the number of elements) * Q(cost per element of F, the per-element function (usually a lambda)) is big enough(e.g. IO involved. Network: DB/web service request..., Reading/Writing file...).
• It's easy to test out the differences of performance by sequential Streams and parallel Streams with Profiler:

 
 Profiler.run(1, 1, 3, "sequential", () -> Stream.of(list).operation(F)...).printResult();
 Profiler.run(1, 1, 3, "parallel", () -> Stream.of(list).parallel().operation(F)...).printResult();
 
 

Here is a sample performance test with computer: CPU Intel i7-3520M 4-cores 2.9 GHz, JDK 1.8.0_101, Windows 7:

 

     public void test_perf() {
        final String[] strs = new String[10_000];
        N.fill(strs, N.uuid());
    
        final int m = 10;
        final Function<String, Long> mapper = str -> {
            long result = 0;
            for (int i = 0; i < m; i++) {
                result += N.sum(str.toCharArray()) + 1;
            }
            return result;
        };
    
        final MutableLong sum = MutableLong.of(0);
    
        for (int i = 0, len = strs.length; i < len; i++) {
            sum.add(mapper.apply(strs[i]));
        }
    
        final int threadNum = 1, loopNum = 100, roundNum = 3;
    
        Profiler.run(threadNum, loopNum, roundNum, "For Loop", () -> {
            long result = 0;
            for (int i = 0, len = strs.length; i < len; i++) {
                result += mapper.apply(strs[i]);
            }
            assertEquals(sum.longValue(), result);
        }).printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "JDK Sequential",
                () -> assertEquals(sum.longValue(), java.util.stream.Stream.of(strs).map(mapper).mapToLong(e -> e).sum())).printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "JDK Parallel",
                () -> assertEquals(sum.longValue(), java.util.stream.Stream.of(strs).parallel().map(mapper).mapToLong(e -> e).sum())).printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "Abcus Sequential", () -> assertEquals(sum.longValue(), Stream.of(strs).map(mapper).mapToLong(e -> e).sum()))
                .printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "Abcus Parallel",
                () -> assertEquals(sum.longValue(), Stream.of(strs).parallel().map(mapper).mapToLong(e -> e).sum())).printResult();
    
        Profiler.run(threadNum, loopNum, roundNum, "Abcus Parallel by chunck", () -> assertEquals(sum.longValue(),
                Stream.of(strs).splitToList(100).parallel().map(it -> N.sumLong(it, e -> mapper.apply(e))).mapToLong(e -> e).sum())).printResult();
     }
    
 
 

And test result: Unit is milliseconds. N(the number of elements) is 10_000, Q(cost per element of F, the per-element function (usually a lambda), here is mapper) is calculated by: value of 'For loop' / N(10_000).

	m = 1	m = 10	m = 50	m = 100	m = 500	m = 1000
Q	0.00002	0.0002	0.001	0.002	0.01	0.02
For Loop	0.23	2.3	11	22	110	219
JDK Sequential	0.28	2.3	11	22	114	212
JDK Parallel	0.22	1.3	6	12	66	122
Abcus Sequential	0.3	2	11	22	112	212
Abcus Parallel	11	11	11	16	77	128

Comparison:

• Again, do NOT and should NOT use parallel Streams if you don't have any performance problem with sequential Streams, because using parallel Streams has extra cost.
• Again, consider using parallel Streams only when N(the number of elements) * Q(cost per element of F, the per-element function (usually a lambda)) is big enough.
• The implementation of parallel Streams in Abacus is more than 10 times, slower than parallel Streams in JDK when Q is tiny(here is less than 0.0002 milliseconds by the test):
• The implementation of parallel Streams in JDK 8 still can beat the sequential/for loop when Q is tiny(Here is 0.00002 milliseconds by the test). That's amazing, considering the extra cost brought by parallel computation. It's well done.
• The implementation of parallel Streams in Abacus is pretty simple and straight forward. The extra cost(starting threads/synchronization/queue...) brought by parallel Streams in Abacus is too bigger to tiny Q(Here is less than 0.001 milliseconds by the test). But it starts to be faster than sequential Streams when Q is big enough(Here is 0.001 milliseconds by the test) and starts to catch the parallel Streams in JDK when Q is bigger(Here is 0.01 milliseconds by the test).
• Consider using the parallel Streams in Abacus when Q is big enough, specially when IO involved in F. Because one IO operation(e.g. DB/web service request..., Reading/Writing file...) usually takes 1 to 1000 milliseconds, or even longer. By the parallel Streams APIs in Abacus, it's very simple to specify max thread numbers. Sometimes, it's much faster to execute IO/Network requests with a bit more threads. It's fair to say that the parallel Streams in Abacus is high efficient, may same as or faster than the parallel Streams in JDK when Q is big enough, except F is heavy cpu-used operation. Most of the times, the Q is big enough to consider using parallel Stream is because IO/Network is involved in F.
• JDK 7 is supported by the Streams in Abacus. It's perfect to work with retrolambda on Android
• All primitive types are supported by Stream APIs in Abacus except boolean

A bit more about Lambdas/Stream APIs, you may heard that Lambdas/Stream APIs is 5 time slower than imperative programming. It's true when Q and F is VERY, VERY tiny, like f = (int a, int b) -> a + b;. But if we look into the samples in the article and think about it: it just takes less than 1 milliseconds to get the max value in 100k numbers. There is potential performance issue only if the "get the max value in 100K numbers" call many, many times in your API or single request. Otherwise, the difference between 0.1 milliseconds to 0.5 milliseconds can be totally ignored. Usually we meet performance issue only if Q and F is big enough. However, the performance of Lambdas/Streams APIs is closed to for loop when Q and F is big enough. No matter in which scenario, We don't need and should not concern the performance of Lambdas/Stream APIs.

Although it's is parallel Streams, it doesn't means all the methods are executed in parallel. Because the sequential way is as fast, or even faster than the parallel way for some methods, or is pretty difficult, if not possible, to implement the method by parallel approach. Here are the methods which are executed sequentially even in parallel Streams.

splitXXX/splitAt/splitBy/slidingXXX/collapse, distinct, reverse, rotate, shuffle, indexed, cached, top, kthLargest, count, toArray, toList, toList, toSet, toMultiset, toLongMultiset, intersection(Collection c), difference(Collection c), symmetricDifference(Collection c), forEach(identity, accumulator, predicate), findFirstOrLast, findFirstAndLast

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

maxThreadNum -

splitor -

Returns:

See Also:

• #maxThreadNumPerOperation()

parallel

public DoubleStream parallel(int maxThreadNum,
 Executor executor)

Description copied from interface: BaseStream

// Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream. stream.sps(SP.create(maxThreadNum, executor), s -> s.map(f)).filter(p)...; // Or switch the stream back sequential stream if don't use "sps". stream.parallel(maxThreadNum, executor).map(f).sequential().filter(p)...;

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

maxThreadNum -

executor -

Returns:

See Also:

• BaseStream.sps(Function)
• BaseStream.sps(int, Function)

parallel

public DoubleStream parallel(Executor executor)

Description copied from interface: BaseStream

 stream.parallel(executor).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(SP.create(executor), s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(executor).map(f).sequential().filter(p)...;

 

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

executor -

Returns:

See Also:

• BaseStream.sps(Function)
• BaseStream.sps(int, Function)

parallel

public DoubleStream parallel(int maxThreadNum,
 BaseStream.Splitor splitor,
 Executor executor)

Description copied from interface: BaseStream

 stream.parallel(maxThreadNum, splitor, executor).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(SP.create(maxThreadNum, splitor, executor), s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(maxThreadNum, splitor, executor).map(f).sequential().filter(p)...;

 

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

maxThreadNum -

splitor -

executor -

Returns:

See Also:

• BaseStream.sps(Function)
• BaseStream.sps(int, Function)

parallel

public DoubleStream parallel(BaseStream.ParallelSettings ps)

Description copied from interface: BaseStream

 stream.parallel(parallelSettings).map(f).filter(p)...;

 // Replace above line of code with "sps" if only "f" need to be parallelized. And "p" is fast enough to be executed in sequential Stream.
 stream.sps(SP.create(parallelSettings), s -> s.map(f)).filter(p)...;
 // Or switch the stream back sequential stream if don't use "sps".
 stream.parallel(parallelSettings).map(f).sequential().filter(p)...;

 

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

ps -

Returns:

See Also:

• BaseStream.sps(Function)
• BaseStream.sps(int, Function)

sps

public <SS extends BaseStream> SS sps(Function<? super DoubleStream,? extends SS> ops)

Description copied from interface: BaseStream

Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
stream().parallel().ops(map/filter/...).sequence()

Specified by:

sps in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Type Parameters:

SS -

Parameters:

ops -

Returns:

sps

public <SS extends BaseStream> SS sps(int maxThreadNum,
 Function<? super DoubleStream,? extends SS> ops)

Description copied from interface: BaseStream

Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
stream().parallel(maxThreadNum).ops(map/filter/...).sequence()

Specified by:

sps in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Type Parameters:

SS -

Parameters:

maxThreadNum -

ops -

Returns:

psp

public <SS extends BaseStream> SS psp(Function<? super DoubleStream,? extends SS> ops)

Description copied from interface: BaseStream

Temporarily switch the stream to sequence stream for operation ops and then switch back to parallel stream with same maxThreadNum/splitor/asyncExecutor.
stream().sequence().ops(map/filter/...).parallel(sameMaxThreadNum, sameSplitor, sameAsyncExecutor)

Specified by:

psp in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Type Parameters:

SS -

Parameters:

ops -

Returns:

toArray

public double[] toArray()

Specified by:

toArray in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

close

public void close()

Description copied from interface: BaseStream

It will be called by terminal operations in final.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface BaseStream<T,A,P,C,PL,OT,IT,ITER extends Iterator<T>,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Specified by:

close in interface Closeable