com.landawn.abacus.util.stream

Class DoubleStream

java.lang.Object

com.landawn.abacus.util.stream.DoubleStream

All Implemented Interfaces:

BaseStream<java.lang.Double,double[],DoublePredicate,DoubleConsumer,DoubleList,u.OptionalDouble,com.landawn.abacus.util.IndexedDouble,DoubleIterator,DoubleStream>, java.lang.AutoCloseable

Direct Known Subclasses:

DoubleStream.DoubleStreamEx

public abstract class DoubleStream
extends java.lang.Object

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

See Also:

Stream

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	DoubleStream.DoubleStreamEx

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

BaseStream.Splitor

Method Summary

Modifier and Type	Method and Description
<R> R	__(Function<? super DoubleStream,R> transfer)
abstract <E extends java.lang.Exception> boolean	allMatch(Try.DoublePredicate<E> predicate)
abstract <E extends java.lang.Exception> boolean	anyMatch(Try.DoublePredicate<E> predicate)
abstract u.OptionalDouble	average()
abstract Stream<java.lang.Double>	boxed()
S	carry(C action) Same as peek
void	close()
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 <R> R	collect(Supplier<R> supplier, ObjDoubleConsumer<? super R> accumulator)
abstract <R> R	collect(Supplier<R> supplier, ObjDoubleConsumer<? super R> accumulator, BiConsumer<R,R> combiner)
static DoubleStream	concat(java.util.Collection<? extends DoubleStream> c)
static DoubleStream	concat(double[]... a)
static DoubleStream	concat(DoubleIterator... a)
static DoubleStream	concat(DoubleStream... a)
static DoubleStream	empty()
abstract <E extends java.lang.Exception> u.OptionalDouble	findAny(Try.DoublePredicate<E> predicate)
abstract <E extends java.lang.Exception> u.OptionalDouble	findFirst(Try.DoublePredicate<E> predicate)
abstract <E extends java.lang.Exception,E2 extends java.lang.Exception> u.OptionalDouble	findFirstOrLast(Try.DoublePredicate<E> predicateForFirst, Try.DoublePredicate<E> predicateForLast)
abstract <E extends java.lang.Exception> u.OptionalDouble	findLast(Try.DoublePredicate<E> predicate)
static DoubleStream	flat(double[][] a)
static DoubleStream	flat(double[][][] a)
static DoubleStream	flat(double[][] a, boolean vertically)
static DoubleStream	flat(double[][] a, double valueForNone, boolean vertically)
abstract DoubleStream	flatMap(DoubleFunction<? extends DoubleStream> mapper)
abstract <T> Stream<T>	flatMappToObj(DoubleFunction<T[]> 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 Stream<T>> mapper)
abstract DoubleStream	flattMap(DoubleFunction<double[]> mapper)
abstract <T> Stream<T>	flattMapToObj(DoubleFunction<? extends java.util.Collection<T>> mapper)
abstract <E extends java.lang.Exception> void	forEach(Try.DoubleConsumer<E> action)
static DoubleStream	from(float... a)
static DoubleStream	from(float[] a, int fromIndex, int toIndex)
static DoubleStream	generate(DoubleSupplier s)
boolean	isParallel()
static DoubleStream	iterate(BooleanSupplier hasNext, DoubleSupplier next)
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)
DoubleIterator	iterator() Remember to close this Stream after the iteration is done, if required.
java.lang.String	join(java.lang.CharSequence delimiter)
abstract u.OptionalDouble	kthLargest(int k)
abstract DoubleStream	map(DoubleUnaryOperator mapper)
abstract FloatStream	mapToFloat(DoubleToFloatFunction mapper)
abstract IntStream	mapToInt(DoubleToIntFunction mapper)
abstract LongStream	mapToLong(DoubleToLongFunction mapper)
abstract <U> Stream<U>	mapToObj(DoubleFunction<? extends U> mapper)
abstract u.OptionalDouble	max()
static DoubleStream	merge(java.util.Collection<? extends DoubleStream> c, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static DoubleStream	merge(double[] a, double[] b, double[] c, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static DoubleStream	merge(double[] a, double[] b, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static DoubleStream	merge(DoubleIterator a, DoubleIterator b, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static DoubleStream	merge(DoubleIterator a, DoubleIterator b, DoubleIterator c, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)
abstract DoubleStream	merge(DoubleStream b, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static DoubleStream	merge(DoubleStream a, DoubleStream b, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static DoubleStream	merge(DoubleStream a, DoubleStream b, DoubleStream c, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)
abstract u.OptionalDouble	min()
abstract <E extends java.lang.Exception> boolean	noneMatch(Try.DoublePredicate<E> predicate)
static DoubleStream	of(java.util.Collection<java.lang.Double> c)
static DoubleStream	of(double... a)
static DoubleStream	of(java.lang.Double[] a)
static DoubleStream	of(double[] a, int startIndex, int endIndex)
static DoubleStream	of(java.lang.Double[] a, int startIndex, int endIndex)
static DoubleStream	of(DoubleIterator iterator)
static DoubleStream	of(java.util.stream.DoubleStream stream)
static DoubleStream	of(Supplier<DoubleList> supplier) Lazy evaluation.
S	parallel()
S	parallel(BaseStream.Splitor splitor)
S	parallel(java.util.concurrent.Executor exector)
S	parallel(int maxThreadNum)
static DoubleStream	parallelMerge(java.util.Collection<? extends DoubleStream> c, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)
static DoubleStream	parallelMerge(java.util.Collection<? extends DoubleStream> c, DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector, int maxThreadNum)
void	println()
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>	rangeMapp(DoubleBiPredicate sameRange, DoubleBiFunction<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 u.OptionalDouble	reduce(DoubleBinaryOperator op)
abstract double	reduce(double identity, DoubleBinaryOperator op)
static DoubleStream	repeat(double element, long n)
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.
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)
S	sequential()
S	shuffled() This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
S	slice(long from, long to) Same as: stream.skip(from).limit(to - from).
Stream<S>	sliding(int windowSize)
Stream<PL>	slidingToList(int windowSize)
abstract double	sum()
abstract DoubleSummaryStatistics	summarize()
abstract Pair<DoubleSummaryStatistics,u.Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Double>>>	summarizeAndPercentiles()
abstract DoubleList	toDoubleList()
ImmutableList<T>	toImmutableList()
ImmutableSet<T>	toImmutableSet()
abstract java.util.stream.DoubleStream	toJdkStream()
abstract <K,A,D> java.util.Map<K,D>	toMap(DoubleFunction<? extends K> keyMapper, Collector<java.lang.Double,A,D> downstream)
abstract <K,A,D,M extends java.util.Map<K,D>> M	toMap(DoubleFunction<? extends K> keyMapper, Collector<java.lang.Double,A,D> downstream, Supplier<? extends M> mapFactory)
abstract <K,V> java.util.Map<K,V>	toMap(DoubleFunction<? extends K> keyMapper, DoubleFunction<? extends V> valueMapper)
abstract <K,V> java.util.Map<K,V>	toMap(DoubleFunction<? extends K> keyMapper, DoubleFunction<? extends V> valueMapper, BinaryOperator<V> mergeFunction)
abstract <K,V,M extends java.util.Map<K,V>> M	toMap(DoubleFunction<? extends K> keyMapper, DoubleFunction<? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)
abstract <K,V,M extends java.util.Map<K,V>> M	toMap(DoubleFunction<? extends K> keyMapper, DoubleFunction<? extends V> valueMapper, Supplier<? extends M> mapFactory)
abstract DoubleMatrix	toMatrix()
abstract DoubleStream	top(int n) This method only run sequentially, even in parallel stream.
abstract DoubleStream	top(int n, java.util.Comparator<? super java.lang.Double> comparator) This method only run sequentially, even in parallel stream.
static DoubleStream	zip(java.util.Collection<? extends DoubleStream> c, double[] valuesForNone, DoubleNFunction<java.lang.Double> zipFunction) Zip together the iterators until all of them runs out of values.
static DoubleStream	zip(java.util.Collection<? extends DoubleStream> c, DoubleNFunction<java.lang.Double> zipFunction) Zip together the iterators until one of them runs out of values.
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, DoubleBinaryOperator zipFunction) Zip together the "a" and "b" 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(DoubleIterator a, DoubleIterator b, DoubleBinaryOperator zipFunction) Zip together the "a" and "b" iterators 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(DoubleStream a, DoubleStream b, DoubleBinaryOperator zipFunction) Zip together the "a" and "b" streams 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.
abstract DoubleStream	zipWith(DoubleStream b, DoubleBinaryOperator zipFunction)
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)

Methods inherited from class java.lang.Object

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

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

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

Method Detail

map

public abstract DoubleStream map(DoubleUnaryOperator mapper)

mapToInt

public abstract IntStream mapToInt(DoubleToIntFunction mapper)

mapToLong

public abstract LongStream mapToLong(DoubleToLongFunction mapper)

mapToFloat

public abstract FloatStream mapToFloat(DoubleToFloatFunction mapper)

mapToObj

public abstract <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper)

flatMap

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

flattMap

public abstract DoubleStream flattMap(DoubleFunction<double[]> mapper)

flatMapToInt

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

flatMapToLong

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

flatMapToFloat

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

flatMapToObj

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

flattMapToObj

public abstract <T> Stream<T> flattMapToObj(DoubleFunction<? extends java.util.Collection<T>> mapper)

flatMappToObj

public abstract <T> Stream<T> flatMappToObj(DoubleFunction<T[]> mapper)

rangeMap

@SequentialOnly
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:

the new stream

See Also:

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

rangeMapp

@SequentialOnly
public abstract <T> Stream<T> rangeMapp(DoubleBiPredicate sameRange,
                                                         DoubleBiFunction<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:

the new stream

See Also:

Stream.rangeMap(BiPredicate, BiFunction)

collapse

@SequentialOnly
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 run sequentially, even in parallel stream.

Parameters:

collapsible -

Returns:

collapse

@SequentialOnly
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 run sequentially, even in parallel stream.

Parameters:

collapsible -

mergeFunction -

Returns:

scan

@SequentialOnly
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 run sequentially, even in parallel stream.

Parameters:

accumulator - the accumulation function

Returns:

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

scan

@SequentialOnly
public abstract 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 run 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:

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

scan

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

Parameters:

init -

accumulator -

initIncluded -

Returns:

top

@SequentialOnly
public abstract DoubleStream top(int n)

This method only run sequentially, even in parallel stream.

Parameters:

n -

Returns:

top

@SequentialOnly
public abstract DoubleStream top(int n,
                                                  java.util.Comparator<? super java.lang.Double> comparator)

This method only run sequentially, even in parallel stream.

Parameters:

n -

comparator -

Returns:

toDoubleList

public abstract DoubleList toDoubleList()

toMap

public abstract <K,V> java.util.Map<K,V> toMap(DoubleFunction<? extends K> keyMapper,
                                               DoubleFunction<? extends V> valueMapper)

Parameters:

keyMapper -

valueMapper -

Returns:

See Also:

Collectors.toMap(Function, Function)

toMap

public abstract <K,V,M extends java.util.Map<K,V>> M toMap(DoubleFunction<? extends K> keyMapper,
                                                           DoubleFunction<? extends V> valueMapper,
                                                           Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMap(Function, Function, Supplier)

toMap

public abstract <K,V> java.util.Map<K,V> toMap(DoubleFunction<? extends K> keyMapper,
                                               DoubleFunction<? extends V> valueMapper,
                                               BinaryOperator<V> mergeFunction)

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

See Also:

Collectors.toMap(Function, Function, BinaryOperator)

toMap

public abstract <K,V,M extends java.util.Map<K,V>> M toMap(DoubleFunction<? extends K> keyMapper,
                                                           DoubleFunction<? extends V> valueMapper,
                                                           BinaryOperator<V> mergeFunction,
                                                           Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

See Also:

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

toMap

public abstract <K,A,D> java.util.Map<K,D> toMap(DoubleFunction<? extends K> keyMapper,
                                                 Collector<java.lang.Double,A,D> downstream)

Parameters:

keyMapper -

downstream -

Returns:

See Also:

Collectors.groupingBy(Function, Collector)

toMap

public abstract <K,A,D,M extends java.util.Map<K,D>> M toMap(DoubleFunction<? extends K> keyMapper,
                                                             Collector<java.lang.Double,A,D> downstream,
                                                             Supplier<? extends M> mapFactory)

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

See Also:

Collectors.groupingBy(Function, Collector, Supplier)

toMatrix

public abstract DoubleMatrix toMatrix()

reduce

public abstract double reduce(double identity,
                              DoubleBinaryOperator op)

reduce

public abstract u.OptionalDouble reduce(DoubleBinaryOperator op)

collect

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

collect

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

forEach

public abstract <E extends java.lang.Exception> void forEach(Try.DoubleConsumer<E> action)
                                                      throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

anyMatch

public abstract <E extends java.lang.Exception> boolean anyMatch(Try.DoublePredicate<E> predicate)
                                                          throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

allMatch

public abstract <E extends java.lang.Exception> boolean allMatch(Try.DoublePredicate<E> predicate)
                                                          throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

noneMatch

public abstract <E extends java.lang.Exception> boolean noneMatch(Try.DoublePredicate<E> predicate)
                                                           throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findFirst

public abstract <E extends java.lang.Exception> u.OptionalDouble findFirst(Try.DoublePredicate<E> predicate)
                                                                    throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findLast

public abstract <E extends java.lang.Exception> u.OptionalDouble findLast(Try.DoublePredicate<E> predicate)
                                                                   throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

findFirstOrLast

public abstract <E extends java.lang.Exception,E2 extends java.lang.Exception> u.OptionalDouble findFirstOrLast(Try.DoublePredicate<E> predicateForFirst,
                                                                                                                Try.DoublePredicate<E> predicateForLast)
                                                                                                         throws E extends java.lang.Exception,
                                                                                                                E2 extends java.lang.Exception

Throws:

E extends java.lang.Exception

findAny

public abstract <E extends java.lang.Exception> u.OptionalDouble findAny(Try.DoublePredicate<E> predicate)
                                                                  throws E extends java.lang.Exception

Throws:

E extends java.lang.Exception

min

public abstract u.OptionalDouble min()

max

public abstract u.OptionalDouble max()

kthLargest

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

public abstract double sum()

average

public abstract u.OptionalDouble average()

summarize

public abstract DoubleSummaryStatistics summarize()

summarizeAndPercentiles

public abstract Pair<DoubleSummaryStatistics,u.Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Double>>> summarizeAndPercentiles()

merge

public abstract DoubleStream merge(DoubleStream b,
                                   DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

b -

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

Returns:

zipWith

public abstract DoubleStream zipWith(DoubleStream b,
                                     DoubleBinaryOperator zipFunction)

zipWith

public abstract DoubleStream zipWith(DoubleStream b,
                                     DoubleStream c,
                                     DoubleTernaryOperator zipFunction)

zipWith

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

zipWith

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

toJdkStream

public abstract java.util.stream.DoubleStream toJdkStream()

boxed

public abstract Stream<java.lang.Double> boxed()

iterator

public DoubleIterator iterator()

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

Returns:

__

public <R> R __(Function<? super DoubleStream,R> transfer)

empty

public static DoubleStream empty()

of

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

of

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

of

public static DoubleStream of(java.lang.Double[] a)

of

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

of

public static DoubleStream of(java.util.Collection<java.lang.Double> c)

of

public static DoubleStream of(DoubleIterator iterator)

of

public static DoubleStream of(Supplier<DoubleList> supplier)

Lazy evaluation.

Parameters:

supplier -

Returns:

of

public static DoubleStream of(java.util.stream.DoubleStream stream)

flat

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

flat

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

flat

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

flat

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

from

@SafeVarargs
public static DoubleStream from(float... a)

from

public static DoubleStream from(float[] a,
                                int fromIndex,
                                int toIndex)

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

public static DoubleStream concat(java.util.Collection<? extends DoubleStream> 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(java.util.Collection<? extends DoubleStream> c,
                               DoubleNFunction<java.lang.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(java.util.Collection<? extends DoubleStream> c,
                               double[] valuesForNone,
                               DoubleNFunction<java.lang.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<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

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

Returns:

merge

public static DoubleStream merge(double[] a,
                                 double[] b,
                                 double[] c,
                                 DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

c -

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

Returns:

merge

public static DoubleStream merge(DoubleIterator a,
                                 DoubleIterator b,
                                 DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

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

Returns:

merge

public static DoubleStream merge(DoubleIterator a,
                                 DoubleIterator b,
                                 DoubleIterator c,
                                 DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

c -

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

Returns:

merge

public static DoubleStream merge(DoubleStream a,
                                 DoubleStream b,
                                 DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

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

Returns:

merge

public static DoubleStream merge(DoubleStream a,
                                 DoubleStream b,
                                 DoubleStream c,
                                 DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

a -

b -

c -

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

Returns:

merge

public static DoubleStream merge(java.util.Collection<? extends DoubleStream> c,
                                 DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

c -

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

Returns:

parallelMerge

public static DoubleStream parallelMerge(java.util.Collection<? extends DoubleStream> c,
                                         DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector)

Parameters:

c -

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

Returns:

parallelMerge

public static DoubleStream parallelMerge(java.util.Collection<? extends DoubleStream> c,
                                         DoubleBiFunction<com.landawn.abacus.util.Nth> nextSelector,
                                         int maxThreadNum)

Parameters:

c -

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

maxThreadNum -

Returns:

carry

public S carry(C action)

Description copied from interface: BaseStream

Same as peek

Specified by:

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

Returns:

See Also:

BaseStream.peek(Object)

slice

public S slice(long from,
               long to)

Description copied from interface: BaseStream

Same as: stream.skip(from).limit(to - from).

Specified by:

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

Returns:

sliding

public Stream<S> sliding(int windowSize)

Specified by:

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

Returns:

See Also:

BaseStream.sliding(int, int)

slidingToList

public Stream<PL> slidingToList(int windowSize)

Specified by:

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

Returns:

See Also:

BaseStream.sliding(int, int)

shuffled

public S shuffled()

Description copied from interface: BaseStream

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

Specified by:

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

Returns:

toImmutableList

public ImmutableList<T> toImmutableList()

Specified by:

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

toImmutableSet

public ImmutableSet<T> toImmutableSet()

Specified by:

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

join

public java.lang.String join(java.lang.CharSequence delimiter)

Specified by:

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

println

public void println()

Specified by:

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

isParallel

public boolean isParallel()

Specified by:

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

Returns:

sequential

public S sequential()

Specified by:

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

Returns:

parallel

public S parallel()

Specified by:

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

Returns:

parallel

public S parallel(int maxThreadNum)

Specified by:

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

Returns:

parallel

public S parallel(BaseStream.Splitor splitor)

Specified by:

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

Returns:

parallel

public S parallel(java.util.concurrent.Executor exector)

Specified by:

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

Parameters:

exector - should be able to execute sum of maxThreadNum operations in parallel.

Returns:

close

public void close()

Specified by:

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

Specified by:

close in interface java.lang.AutoCloseable