DoubleStream (abacus API Documentation)

java.lang.Object
- com.landawn.abacus.util.stream.DoubleStream

All Implemented Interfaces:

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

Direct Known Subclasses:

DoubleStream.DoubleStreamEx
```
public abstract class DoubleStream
extends java.lang.Object
```
Note: It's copied from OpenJDK at: http://hg.openjdk.java.net/jdk8u/hs-dev/jdk
A sequence of primitive double-valued elements supporting sequential and parallel aggregate operations. This is the double primitive specialization of Stream.
The following example illustrates an aggregate operation using Stream and DoubleStream, computing the sum of the weights of the red widgets:
```
     double sum = widgets.stream()
                         .filter(w -> w.getColor() == RED)
                         .mapToDouble(w -> w.getWeight())
                         .sum();
 
```
See the class documentation for Stream and the package documentation for java.util.stream for additional specification of streams, stream operations, stream pipelines, and parallelism.
Since:

1.8

See Also:

Stream, java.util.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

Nested Classes
Modifier and Type	Class and Description
`static class`	`DoubleStream.DoubleStreamEx`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`<R> R`	`__(Function<? super DoubleStream,R> transfer)`
`abstract OptionalDouble`	`average()` Returns an `OptionalDouble` describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty.
`abstract Stream<java.lang.Double>`	`boxed()` Returns a `Stream` consisting of the elements of this stream, boxed to `Double`.
`S`	`carry(C action)` Same as `peek`
`void`	`close()` Closes this stream, causing all close handlers for this stream pipeline to be called.
`abstract DoubleStream`	`collapse(DoubleBiPredicate collapsible, DoubleBiFunction<java.lang.Double> 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<R> accumulator)`
`abstract <R> R`	`collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R,R> combiner)` Performs a mutable reduction operation on the elements of this stream.
`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()`
`OT`	`findAny(P predicate)` Returns an `Optional` describing some element of the stream, or an empty `Optional` if the stream is empty.
`abstract DoubleStream`	`flatArray(DoubleFunction<double[]> mapper)`
`abstract DoubleStream`	`flatMap(DoubleFunction<? extends DoubleStream> mapper)` Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
`abstract 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)`
`static DoubleStream`	`from(float... a)`
`static DoubleStream`	`from(float[] a, int fromIndex, int toIndex)`
`static DoubleStream`	`generate(DoubleSupplier s)`
`abstract OptionalDouble`	`head()` Head and tail should be used by pair.
`abstract DoubleStream`	`head2()` Head2 and tail2 should be used by pair.
`abstract Pair<OptionalDouble,DoubleStream>`	`headAndTail()`
`abstract Pair<DoubleStream,OptionalDouble>`	`headAndTail2()`
`boolean`	`isParallel()` Returns whether this stream, if a terminal operation were to be executed, would execute in parallel.
`static DoubleStream`	`iterate(double seed, DoublePredicate hasNext, DoubleUnaryOperator f)`
`static DoubleStream`	`iterate(double seed, DoubleUnaryOperator f)`
`static DoubleStream`	`iterate(double seed, Supplier<java.lang.Boolean> hasNext, DoubleUnaryOperator f)`
`static DoubleStream`	`iterate(Supplier<java.lang.Boolean> hasNext, DoubleSupplier next)`
`DoubleIterator`	`iterator()` Returns an iterator for the elements of this stream.
`abstract OptionalDouble`	`kthLargest(int k)`
`abstract DoubleStream`	`map(DoubleUnaryOperator mapper)` Returns a stream consisting of the results of applying the given function to the elements of this stream.
`abstract FloatStream`	`mapToFloat(DoubleToFloatFunction mapper)` Returns a `FloatStream` consisting of the results of applying the given function to the elements of this stream.
`abstract IntStream`	`mapToInt(DoubleToIntFunction mapper)` Returns an `IntStream` consisting of the results of applying the given function to the elements of this stream.
`abstract LongStream`	`mapToLong(DoubleToLongFunction mapper)` Returns a `LongStream` consisting of the results of applying the given function to the elements of this stream.
`abstract <U> Stream<U>`	`mapToObj(DoubleFunction<? extends U> mapper)` Returns an object-valued `Stream` consisting of the results of applying the given function to the elements of this stream.
`abstract OptionalDouble`	`max()` Returns an `OptionalDouble` describing the maximum element of this stream, or an empty OptionalDouble if this stream is empty.
`int`	`maxThreadNum()` Return the underlying `maxThreadNum` if the stream is parallel, otherwise `1` is returned.
`S`	`maxThreadNum(int maxThreadNum)` Returns a parallel stream with the specified `maxThreadNum` .
`static 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 OptionalDouble`	`min()` Returns an `OptionalDouble` describing the minimum element of this stream, or an empty OptionalDouble if this stream is empty.
`static DoubleStream`	`of(double... a)`
`static DoubleStream`	`of(double[][] a)`
`static DoubleStream`	`of(double[][][] a)`
`static DoubleStream`	`of(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()` Returns an equivalent stream that is parallel.
`S`	`parallel(BaseStream.Splitor splitor)` Returns an equivalent stream that is parallel.
`S`	`parallel(int maxThreadNum)` Returns an equivalent stream that is parallel.
`static 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 OptionalDouble`	`reduce(DoubleBinaryOperator op)` Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an `OptionalDouble` describing the reduced value, if any.
`abstract double`	`reduce(double identity, DoubleBinaryOperator op)` Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
`static DoubleStream`	`repeat(double element, long n)`
`abstract DoubleStream`	`scan(DoubleBiFunction<java.lang.Double> accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to an initial element `seed` and next element of the current stream.
`abstract DoubleStream`	`scan(double seed, DoubleBiFunction<java.lang.Double> accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to an initial element `seed` and next element of the current stream.
`S`	`sequential()` Returns an equivalent stream that is sequential.
`Stream<S>`	`sliding(int windowSize)`
`Stream<PL>`	`slidingToList(int windowSize)`
`BaseStream.Splitor`	`splitor()` Return the underlying `splitor` if the stream is parallel, otherwise the default value `splitor.ITERATOR` is returned.
`S`	`splitor(BaseStream.Splitor splitor)` Returns a parallel stream with the specified `splitor` .
`abstract double`	`sum()` Returns the sum of elements in this stream.
`abstract DoubleSummaryStatistics`	`summarize()`
`abstract Pair<DoubleSummaryStatistics,Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Double>>>`	`summarize2()`
`abstract DoubleStream`	`tail()` Head and tail should be used by pair.
`abstract OptionalDouble`	`tail2()` Head2 and tail2 should be used by pair.
`abstract DoubleList`	`toDoubleList()`
`abstract <K,A,D> java.util.Map<K,D>`	`toMap(DoubleFunction<? extends K> classifier, Collector<java.lang.Double,A,D> downstream)`
`abstract <K,A,D,M extends java.util.Map<K,D>> M`	`toMap(DoubleFunction<? extends K> classifier, Collector<java.lang.Double,A,D> downstream, Supplier<M> mapFactory)`
`abstract <K,U> java.util.Map<K,U>`	`toMap(DoubleFunction<? extends K> keyExtractor, DoubleFunction<? extends U> valueMapper)`
`abstract <K,U> java.util.Map<K,U>`	`toMap(DoubleFunction<? extends K> keyExtractor, DoubleFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction)`
`abstract <K,U,M extends java.util.Map<K,U>> M`	`toMap(DoubleFunction<? extends K> keyExtractor, DoubleFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)`
`abstract <K,U,M extends java.util.Map<K,U>> M`	`toMap(DoubleFunction<? extends K> keyExtractor, DoubleFunction<? extends U> valueMapper, Supplier<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.
`Try<S>`	`tried()`
`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, DoubleTriFunction<java.lang.Double> 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, DoubleTriFunction<java.lang.Double> zipFunction)` Zip together the "a", "b" and "c" arrays until one of them runs out of values.
`static DoubleStream`	`zip(double[] a, double[] b, DoubleBiFunction<java.lang.Double> 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, DoubleBiFunction<java.lang.Double> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static DoubleStream`	`zip(DoubleIterator a, DoubleIterator b, DoubleBiFunction<java.lang.Double> 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, DoubleBiFunction<java.lang.Double> 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, DoubleTriFunction<java.lang.Double> 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, DoubleTriFunction<java.lang.Double> zipFunction)` Zip together the "a", "b" and "c" iterators until one of them runs out of values.
`static DoubleStream`	`zip(DoubleStream a, DoubleStream b, DoubleBiFunction<java.lang.Double> 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, DoubleBiFunction<java.lang.Double> 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, DoubleTriFunction<java.lang.Double> 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, DoubleTriFunction<java.lang.Double> zipFunction)` Zip together the "a", "b" and "c" streams until one of them runs out of values.
`abstract DoubleStream`	`zipWith(DoubleStream b, DoubleBiFunction<java.lang.Double> zipFunction)`
`abstract DoubleStream`	`zipWith(DoubleStream b, double valueForNoneA, double valueForNoneB, DoubleBiFunction<java.lang.Double> zipFunction)`
`abstract DoubleStream`	`zipWith(DoubleStream b, DoubleStream c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTriFunction<java.lang.Double> zipFunction)`
`abstract DoubleStream`	`zipWith(DoubleStream b, DoubleStream c, DoubleTriFunction<java.lang.Double> 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
allMatch, anyMatch, append, cached, count, difference, distinct, dropWhile, filter, findFirst, findFirstOrLast, findLast, first, forEach, indexed, intersection, join, join, last, limit, noneMatch, onClose, parallel, peek, percentiles, prepend, remove, removeIf, removeIf, removeWhile, reversed, reverseSorted, rotated, shuffled, shuffled, skip, sliding, slidingToList, sorted, split, split, split, splitAt, splitBy, splitToList, splitToList, splitToList, step, symmetricDifference, takeWhile, toArray, toList, toList, toLongMultiset, toLongMultiset, toMultiset, toMultiset, toSet, toSet

- Method Detail
  - map
```
public abstract DoubleStream map(DoubleUnaryOperator mapper)
```
    Returns a stream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToInt
```
public abstract IntStream mapToInt(DoubleToIntFunction mapper)
```
    Returns an IntStream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToLong
```
public abstract LongStream mapToLong(DoubleToLongFunction mapper)
```
    Returns a LongStream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToFloat
```
public abstract FloatStream mapToFloat(DoubleToFloatFunction mapper)
```
    Returns a FloatStream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToObj
```
public abstract <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper)
```
    Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Type Parameters:
    
    U - the element type of the new stream
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - flatMap
```
public abstract DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper)
```
    Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element which produces a DoubleStream of new values
    
    Returns:
    
    the new stream
    
    See Also:
    
    Stream.flatMap(Function)
  - flatArray
```
public abstract DoubleStream flatArray(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)
```
  - collapse
```
public abstract DoubleStream collapse(DoubleBiPredicate collapsible,
                                      DoubleBiFunction<java.lang.Double> 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
```
public abstract DoubleStream scan(DoubleBiFunction<java.lang.Double> accumulator)
```
    Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream. Produces a Stream consisting of seed, acc(seed, value1), acc(acc(seed, value1), value2), etc.
    This is an intermediate operation.
    Example:
```
 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
```
public abstract DoubleStream scan(double seed,
                                  DoubleBiFunction<java.lang.Double> accumulator)
```
    Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream. Produces a Stream consisting of seed, acc(seed, value1), acc(acc(seed, value1), value2), etc.
    This is an intermediate operation.
    Example:
```
 seed: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:
    
    seed - the initial value. it's only used once by accumulator to calculate the fist element in the returned stream. It will be ignored if this stream is empty and won't be the first element of the returned stream.
    
    accumulator - the accumulation function
    
    Returns:
    
    the new stream which has the extract same size as this stream.
  - top
```
public abstract DoubleStream top(int n)
```
    This method only run sequentially, even in parallel stream.
    
    Parameters:
    
    n -
    
    Returns:
  - top
```
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,U> java.util.Map<K,U> toMap(DoubleFunction<? extends K> keyExtractor,
                                               DoubleFunction<? extends U> valueMapper)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function)
  - toMap
```
public abstract <K,U,M extends java.util.Map<K,U>> M toMap(DoubleFunction<? extends K> keyExtractor,
                                                           DoubleFunction<? extends U> valueMapper,
                                                           Supplier<M> mapFactory)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    mapFactory -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function, Supplier)
  - toMap
```
public abstract <K,U> java.util.Map<K,U> toMap(DoubleFunction<? extends K> keyExtractor,
                                               DoubleFunction<? extends U> valueMapper,
                                               BinaryOperator<U> mergeFunction)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    mergeFunction -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function, BinaryOperator)
  - toMap
```
public abstract <K,U,M extends java.util.Map<K,U>> M toMap(DoubleFunction<? extends K> keyExtractor,
                                                           DoubleFunction<? extends U> valueMapper,
                                                           BinaryOperator<U> mergeFunction,
                                                           Supplier<M> mapFactory)
```
    Parameters:
    
    keyExtractor -
    
    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> classifier,
                                                 Collector<java.lang.Double,A,D> downstream)
```
    Parameters:
    
    classifier -
    
    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> classifier,
                                                             Collector<java.lang.Double,A,D> downstream,
                                                             Supplier<M> mapFactory)
```
    Parameters:
    
    classifier -
    
    downstream -
    
    mapFactory -
    
    Returns:
    
    See Also:
    
    Collectors.groupingBy(Function, Collector, Supplier)
  - toMatrix
```
public abstract DoubleMatrix toMatrix()
```
  - reduce
```
public abstract double reduce(double identity,
                              DoubleBinaryOperator op)
```
    Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value. This is equivalent to:
```
     double result = identity;
     for (double element : this stream)
         result = accumulator.applyAsDouble(result, element)
     return result;
 
```
    but is not constrained to execute sequentially.
    The identity value must be an identity for the accumulator function. This means that for all x, accumulator.apply(identity, x) is equal to x. The accumulator function must be an associative function.
    This is a terminal operation.
    Parameters:
    
    identity - the identity value for the accumulating function
    
    op - an associative, non-interfering, stateless function for combining two values
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    sum(), min(), max(), average()
  - reduce
```
public abstract OptionalDouble reduce(DoubleBinaryOperator op)
```
    Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalDouble describing the reduced value, if any. This is equivalent to:
```
     boolean foundAny = false;
     double result = null;
     for (double element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.applyAsDouble(result, element);
     }
     return foundAny ? OptionalDouble.of(result) : OptionalDouble.empty();
 
```
    but is not constrained to execute sequentially.
    The accumulator function must be an associative function.
    This is a terminal operation.
    Parameters:
    
    op - an associative, non-interfering, stateless function for combining two values
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    reduce(double, DoubleBinaryOperator)
  - collect
```
public abstract <R> R collect(Supplier<R> supplier,
                              ObjDoubleConsumer<R> accumulator,
                              BiConsumer<R,R> combiner)
```
    Performs a mutable reduction operation on the elements of this stream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:
```
     R result = supplier.get();
     for (double element : this stream)
         accumulator.accept(result, element);
     return result;
 
```
    Like reduce(double, DoubleBinaryOperator), collect operations can be parallelized without requiring additional synchronization.
    This is a terminal operation.
    Type Parameters:
    
    R - type of the result
    
    Parameters:
    
    supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.
    
    accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result
    
    combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    Stream.collect(Supplier, BiConsumer, BiConsumer)
  - collect
```
public abstract <R> R collect(Supplier<R> supplier,
                              ObjDoubleConsumer<R> accumulator)
```
    Parameters:
    
    supplier -
    
    accumulator -
    
    Returns:
  - head
```
public abstract OptionalDouble head()
```
    Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() and tail() are called.
    
    Returns:
  - tail
```
public abstract DoubleStream tail()
```
    Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() and tail() are called.
    
    Returns:
  - head2
```
public abstract DoubleStream head2()
```
    Head2 and tail2 should be used by pair. Don't call any other methods with this stream after head2() and tail2() are called.
    
    Returns:
  - tail2
```
public abstract OptionalDouble tail2()
```
    Head2 and tail2 should be used by pair. Don't call any other methods with this stream after head2() and tail2() are called.
    
    Returns:
  - headAndTail
```
public abstract Pair<OptionalDouble,DoubleStream> headAndTail()
```
  - headAndTail2
```
public abstract Pair<DoubleStream,OptionalDouble> headAndTail2()
```
  - min
```
public abstract OptionalDouble min()
```
    Returns an OptionalDouble describing the minimum element of this stream, or an empty OptionalDouble if this stream is empty. The minimum element will be Double.NaN if any stream element was NaN. Unlike the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. This is a special case of a reduction and is equivalent to:
```
     return reduce(Double::min);
 
```
    This is a terminal operation.
    Returns:
    
    an OptionalDouble containing the minimum element of this stream, or an empty optional if the stream is empty
  - max
```
public abstract OptionalDouble max()
```
    Returns an OptionalDouble describing the maximum element of this stream, or an empty OptionalDouble if this stream is empty. The maximum element will be Double.NaN if any stream element was NaN. Unlike the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. This is a special case of a reduction and is equivalent to:
```
     return reduce(Double::max);
 
```
    This is a terminal operation.
    Returns:
    
    an OptionalDouble containing the maximum element of this stream, or an empty optional if the stream is empty
  - kthLargest
```
public abstract 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()
```
    Returns the sum of elements in this stream. Summation is a special case of a reduction. If floating-point summation were exact, this method would be equivalent to:
```
     return reduce(0, Double::sum);
 
```
    However, since floating-point summation is not exact, the above code is not necessarily equivalent to the summation computation done by this method.
    If any stream element is a NaN or the sum is at any point a NaN then the sum will be NaN. The value of a floating-point sum is a function both of the input values as well as the order of addition operations. The order of addition operations of this method is intentionally not defined to allow for implementation flexibility to improve the speed and accuracy of the computed result. In particular, this method may be implemented using compensated summation or other technique to reduce the error bound in the numerical sum compared to a simple summation of double values.
    This is a terminal operation.
    Returns:
    
    the sum of elements in this stream
  - average
```
public abstract OptionalDouble average()
```
    Returns an OptionalDouble describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty. If any recorded value is a NaN or the sum is at any point a NaN then the average will be NaN.
    The average returned can vary depending upon the order in which values are recorded. This method may be implemented using compensated summation or other technique to reduce the error bound in the numerical sum used to compute the average.
    The average is a special case of a reduction.
    This is a terminal operation.
    
    Returns:
    
    an OptionalDouble containing the average element of this stream, or an empty optional if the stream is empty
  - summarize
```
public abstract DoubleSummaryStatistics summarize()
```
  - summarize2
```
public abstract Pair<DoubleSummaryStatistics,Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Double>>> summarize2()
```
  - 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,
                                     DoubleBiFunction<java.lang.Double> zipFunction)
```
  - zipWith
```
public abstract DoubleStream zipWith(DoubleStream b,
                                     DoubleStream c,
                                     DoubleTriFunction<java.lang.Double> zipFunction)
```
  - zipWith
```
public abstract DoubleStream zipWith(DoubleStream b,
                                     double valueForNoneA,
                                     double valueForNoneB,
                                     DoubleBiFunction<java.lang.Double> zipFunction)
```
  - zipWith
```
public abstract DoubleStream zipWith(DoubleStream b,
                                     DoubleStream c,
                                     double valueForNoneA,
                                     double valueForNoneB,
                                     double valueForNoneC,
                                     DoubleTriFunction<java.lang.Double> zipFunction)
```
  - boxed
```
public abstract Stream<java.lang.Double> boxed()
```
    Returns a Stream consisting of the elements of this stream, boxed to Double.
    This is an intermediate operation.
    
    Returns:
    
    a Stream consistent of the elements of this stream, each boxed to a Double
  - iterator
```
public DoubleIterator iterator()
```
    Description copied from interface: BaseStream
    
    Returns an iterator for the elements of this stream.
    
    Returns:
    
    the element iterator for this stream
  - __
```
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(double[][] a)
```
  - of
```
public static DoubleStream of(double[][][] a)
```
  - 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)
```
  - 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(Supplier<java.lang.Boolean> hasNext,
                                   DoubleSupplier next)
```
  - iterate
```
public static DoubleStream iterate(double seed,
                                   Supplier<java.lang.Boolean> hasNext,
                                   DoubleUnaryOperator f)
```
  - iterate
```
public static DoubleStream iterate(double seed,
                                   DoublePredicate hasNext,
                                   DoubleUnaryOperator f)
```
    Parameters:
    
    seed -
    
    hasNext - test if has next by hasNext.test(seed) for first time and hasNext.test(f.apply(previous)) for remaining.
    
    f -
    
    Returns:
  - iterate
```
public static DoubleStream iterate(double seed,
                                   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,
                               DoubleBiFunction<java.lang.Double> 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,
                               DoubleTriFunction<java.lang.Double> zipFunction)
```
    Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static DoubleStream zip(DoubleIterator a,
                               DoubleIterator b,
                               DoubleBiFunction<java.lang.Double> 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,
                               DoubleTriFunction<java.lang.Double> 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,
                               DoubleBiFunction<java.lang.Double> 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,
                               DoubleTriFunction<java.lang.Double> 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,
                               DoubleBiFunction<java.lang.Double> 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,
                               DoubleTriFunction<java.lang.Double> 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,
                               DoubleBiFunction<java.lang.Double> 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,
                               DoubleTriFunction<java.lang.Double> 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,
                               DoubleBiFunction<java.lang.Double> 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,
                               DoubleTriFunction<java.lang.Double> 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,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.peek(Object)
  - findAny
```
public OT findAny(P predicate)
```
    Description copied from interface: BaseStream
    
    Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty.
    This is a short-circuiting terminal operation.
    The behavior of this operation is explicitly nondeterministic; it is free to select any element in the stream. This is to allow for maximal performance in parallel operations; the cost is that multiple invocations on the same source may not return the same result. (If a stable result is desired, use #findFirst() instead.)
    
    Specified by:
    
    findAny in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    an Optional describing some element of this stream, or an empty Optional if the stream is empty
    
    See Also:
    
    #findFirst()
  - sliding
```
public Stream<S> sliding(int windowSize)
```
    Specified by:
    
    sliding in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,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,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.sliding(int, int)
  - println
```
public void println()
```
    Specified by:
    
    println in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
  - isParallel
```
public boolean isParallel()
```
    Description copied from interface: BaseStream
    
    Returns whether this stream, if a terminal operation were to be executed, would execute in parallel. Calling this method after invoking an terminal stream operation method may yield unpredictable results.
    
    Specified by:
    
    isParallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    true if this stream would execute in parallel if executed
  - sequential
```
public S sequential()
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is sequential. May return itself, either because the stream was already sequential, or because the underlying stream state was modified to be sequential.
    
    Specified by:
    
    sequential in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    a sequential stream
  - parallel
```
public S parallel()
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is parallel. May return itself if the stream was already parallel. Any parallel should be closed by try-catch or call tried before last step.
    
    Specified by:
    
    parallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    a parallel stream
    
    See Also:
    
    BaseStream.parallel(int, Splitor)
  - parallel
```
public S parallel(int maxThreadNum)
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same maxThreadNum as the specified one.
    
    Specified by:
    
    parallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.parallel(int, Splitor)
  - parallel
```
public S parallel(BaseStream.Splitor splitor)
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same splitor as the specified one.
    
    Specified by:
    
    parallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.parallel(int, Splitor)
  - maxThreadNum
```
public int maxThreadNum()
```
    Description copied from interface: BaseStream
    
    Return the underlying maxThreadNum if the stream is parallel, otherwise 1 is returned.
    
    Specified by:
    
    maxThreadNum in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - maxThreadNum
```
public S maxThreadNum(int maxThreadNum)
```
    Description copied from interface: BaseStream
    
    Returns a parallel stream with the specified maxThreadNum . Or return itself, either because the stream was already parallel with same maxThreadNum, or because it's a sequential stream.
    
    Specified by:
    
    maxThreadNum in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - splitor
```
public BaseStream.Splitor splitor()
```
    Description copied from interface: BaseStream
    
    Return the underlying splitor if the stream is parallel, otherwise the default value splitor.ITERATOR is returned.
    
    Specified by:
    
    splitor in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - splitor
```
public S splitor(BaseStream.Splitor splitor)
```
    Description copied from interface: BaseStream
    
    Returns a parallel stream with the specified splitor . Or return itself, either because the stream was already parallel with same splitor, or because it's a sequential stream.
    
    Specified by:
    
    splitor in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - tried
```
public Try<S> tried()
```
    Specified by:
    
    tried in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
  - close
```
public void close()
```
    Description copied from interface: BaseStream
    
    Closes this stream, causing all close handlers for this stream pipeline to be called.
    
    Specified by:
    
    close in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    See Also:
    
    AutoCloseable.close()

Class DoubleStream

Nested Class Summary

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

Method Summary

Methods inherited from class java.lang.Object

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

Method Detail

map

mapToInt

mapToLong

mapToFloat

mapToObj

flatMap

flatArray

flatMapToInt

flatMapToLong

flatMapToFloat

flatMapToObj

collapse

scan

scan

top

top

toDoubleList

toMap

toMap

toMap

toMap

toMap

toMap

toMatrix

reduce

reduce

collect

collect

head

tail

head2

tail2

headAndTail

headAndTail2

min

max

kthLargest

sum

average

summarize

summarize2

merge

zipWith

zipWith

zipWith

zipWith

boxed

iterator

__

empty

of

of

of

of

of

of

of

from

from

repeat

random

iterate

iterate

iterate

iterate

generate

concat

concat

concat

concat

zip

zip

zip