java.lang.Object
- com.github.ferstl.streams.ParallelDoubleStreamSupport

All Implemented Interfaces:

AutoCloseable, BaseStream<Double,DoubleStream>, DoubleStream
```
public class ParallelDoubleStreamSupport
extends Object
implements DoubleStream
```
An implementation of DoubleStream which uses a custom ForkJoinPool for parallel aggregate operations. This is the double primitive specialization of ParallelStreamSupport.
The following example illustrates an aggregate operation using ParallelStreamSupport and ParallelDoubleStreamSupport with a custom ForkJoinPool, computing the sum of the weights of the red widgets:
```
 ForkJoinPool pool = new ForkJoinPool();
 double sum = ParallelStreamSupport.parallelStream(widgets, pool)
     .filter(w -> w.getColor() == RED)
     .mapToDouble(w -> w.getWeight())
     .sum();
 
```
In case this stream is configured for parallel execution, i.e. BaseStream.isParallel() returns true, a terminal operation will be executed as ForkJoinTask in the custom ForkJoinPool. Otherwise it will be executed in the calling thread.
This implementation offers various factory methods which are based on:
- The static factory methods of DoubleStream, which are meaningful for parallel streams
- Arrays.stream(double[])
- StreamSupport.doubleStream(Spliterator.OfDouble, boolean)
- StreamSupport.doubleStream(Supplier, int, boolean)
API Note:

Internally, this stream wraps a double stream which is initially created in one of the static factory methods. Whenever a non-terminal operation is called the underlying stream will be replaced with the result of calling the same method on that stream. The return value of these operations is always this stream or, in case of operations that return a different type of stream, one of ParallelStreamSupport, ParallelIntStreamSupport or ParallelLongStreamSupport.

Although each factory method returns a parallel stream, calling BaseStream.sequential() is still possible and leads to sequential execution of a terminal operation within the calling thread.

Implementation Note:

See the class documentation for Stream and the package documentation for java.util.stream for additional specification.

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.stream.DoubleStream
  DoubleStream.Builder

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`allMatch(DoublePredicate predicate)`
`boolean`	`anyMatch(DoublePredicate predicate)`
`OptionalDouble`	`average()`
`Stream<Double>`	`boxed()`
`void`	`close()`
`<R> R`	`collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R,R> combiner)`
`static DoubleStream`	`concat(DoubleStream a, DoubleStream b, ForkJoinPool workerPool)`	Creates a lazily concatenated parallel `double` stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
`long`	`count()`
`DoubleStream`	`distinct()`
`DoubleStream`	`dropWhile(DoublePredicate predicate)`
`protected void`	`execute(Runnable terminalOperation)`
`protected <R> R`	`execute(Callable<R> terminalOperation)`
`DoubleStream`	`filter(DoublePredicate predicate)`
`OptionalDouble`	`findAny()`
`OptionalDouble`	`findFirst()`
`DoubleStream`	`flatMap(DoubleFunction<? extends DoubleStream> mapper)`
`void`	`forEach(DoubleConsumer action)`
`void`	`forEachOrdered(DoubleConsumer action)`
`static DoubleStream`	`generate(DoubleSupplier supplier, ForkJoinPool workerPool)`	Creates a parallel infinite sequential unordered `double` stream where each element is generated by the provided `DoubleSupplier`.
`boolean`	`isParallel()`
`static DoubleStream`	`iterate(double seed, DoubleUnaryOperator operator, ForkJoinPool workerPool)`	Creates a parallel infinite ordered `double` stream produced by iterative application of a function `f` to an initial element `seed`.
`PrimitiveIterator.OfDouble`	`iterator()`
`DoubleStream`	`limit(long maxSize)`
`DoubleStream`	`map(DoubleUnaryOperator mapper)`
`IntStream`	`mapToInt(DoubleToIntFunction mapper)`
`LongStream`	`mapToLong(DoubleToLongFunction mapper)`
`<U> Stream<U>`	`mapToObj(DoubleFunction<? extends U> mapper)`
`OptionalDouble`	`max()`
`OptionalDouble`	`min()`
`boolean`	`noneMatch(DoublePredicate predicate)`
`S`	`onClose(Runnable closeHandler)`
`S`	`parallel()`
`static DoubleStream`	`parallelStream(double[] array, ForkJoinPool workerPool)`	Creates a parallel `double` stream from the given Array.
`static DoubleStream`	`parallelStream(Supplier<? extends Spliterator.OfDouble> supplier, int characteristics, ForkJoinPool workerPool)`	Creates a parallel `double` stream from the given Spliterator supplier.
`static DoubleStream`	`parallelStream(Spliterator.OfDouble spliterator, ForkJoinPool workerPool)`	Creates a parallel `double` stream from the given Spliterator.
`static DoubleStream`	`parallelStream(DoubleStream.Builder builder, ForkJoinPool workerPool)`	Creates a parallel `double` stream from the given `DoubleStream.Builder`.
`DoubleStream`	`peek(DoubleConsumer action)`
`double`	`reduce(double identity, DoubleBinaryOperator op)`
`OptionalDouble`	`reduce(DoubleBinaryOperator op)`
`S`	`sequential()`
`DoubleStream`	`skip(long n)`
`DoubleStream`	`sorted()`
`Spliterator.OfDouble`	`spliterator()`
`double`	`sum()`
`DoubleSummaryStatistics`	`summaryStatistics()`
`DoubleStream`	`takeWhile(DoublePredicate predicate)`
`double[]`	`toArray()`
`S`	`unordered()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.stream.BaseStream
close, isParallel, onClose, unordered

Methods inherited from interface java.util.stream.DoubleStream
parallel, sequential

- Method Detail
  - parallelStream
```
public static DoubleStream parallelStream(double[] array,
                                          ForkJoinPool workerPool)
```
    Creates a parallel double stream from the given Array. This operation is similar to calling Arrays.stream(array).parallel() with the difference that a parallel terminal operation will be executed in the given ForkJoinPool.
    
    Parameters:
    
    array - Array to create the parallel stream from. Must not be null.
    
    workerPool - Thread pool for parallel execution of a terminal operation. Must not be null.
    
    Returns:
    
    A parallel double stream that executes a terminal operation in the given ForkJoinPool.
    
    See Also:
    
    Arrays.stream(int[])
  - parallelStream
```
public static DoubleStream parallelStream(Spliterator.OfDouble spliterator,
                                          ForkJoinPool workerPool)
```
    Creates a parallel double stream from the given Spliterator. This operation is similar to calling StreamSupport.doubleStream(spliterator, true) with the difference that a parallel terminal operation will be executed in the given ForkJoinPool.
    
    Parameters:
    
    spliterator - A Spliterator.OfDouble describing the stream elements. Must not be null.
    
    workerPool - Thread pool for parallel execution of a terminal operation. Must not be null.
    
    Returns:
    
    A parallel double stream that executes a terminal operation in the given ForkJoinPool.
    
    See Also:
    
    StreamSupport.doubleStream(Spliterator.OfDouble, boolean)
  - parallelStream
```
public static DoubleStream parallelStream(Supplier<? extends Spliterator.OfDouble> supplier,
                                          int characteristics,
                                          ForkJoinPool workerPool)
```
    Creates a parallel double stream from the given Spliterator supplier. This operation is similar to calling StreamSupport.doubleStream(supplier, characteristics, true) with the difference that a parallel terminal operation will be executed in the given ForkJoinPool.
    
    Parameters:
    
    supplier - A Supplier of a Spliterator.OfDouble. Must not be null.
    
    characteristics - Spliterator characteristics of the supplied Spliterator. The characteristics must be equal to supplier.get().characteristics(), otherwise undefined behavior may occur when terminal operation commences.
    
    workerPool - Thread pool for parallel execution of a terminal operation. Must not be null.
    
    Returns:
    
    A parallel double stream that executes a terminal operation in the given ForkJoinPool.
    
    See Also:
    
    StreamSupport.doubleStream(Supplier, int, boolean)
  - parallelStream
```
public static DoubleStream parallelStream(DoubleStream.Builder builder,
                                          ForkJoinPool workerPool)
```
    Creates a parallel double stream from the given DoubleStream.Builder. This operation is similar to calling builder.build().parallel() with the difference that a parallel terminal operation will be executed in the given ForkJoinPool.
    
    Parameters:
    
    builder - The builder to create the stream from. Must not be null.
    
    workerPool - Thread pool for parallel execution of a terminal operation. Must not be null.
    
    Returns:
    
    A parallel double stream that executes a terminal operation in the given ForkJoinPool.
    
    See Also:
    
    DoubleStream.builder()
  - iterate
```
public static DoubleStream iterate(double seed,
                                   DoubleUnaryOperator operator,
                                   ForkJoinPool workerPool)
```
    Creates a parallel infinite ordered double stream produced by iterative application of a function f to an initial element seed. This operation is similar to calling DoubleStream.iterate(seed, operator).parallel() with the difference that a parallel terminal operation will be executed in the given ForkJoinPool.
    
    Parameters:
    
    seed - The initial element.
    
    operator - A function to be applied to to the previous element to produce a new element. Must not be null.
    
    workerPool - Thread pool for parallel execution of a terminal operation. Must not be null.
    
    Returns:
    
    A parallel double stream that executes a terminal operation in the given ForkJoinPool.
    
    See Also:
    
    DoubleStream.iterate(double, DoubleUnaryOperator)
  - generate
```
public static DoubleStream generate(DoubleSupplier supplier,
                                    ForkJoinPool workerPool)
```
    Creates a parallel infinite sequential unordered double stream where each element is generated by the provided DoubleSupplier. This operation is similar to calling DoubleStream.generate(supplier).parallel() with the difference that a parallel terminal operation will be executed in the given ForkJoinPool.
    
    Parameters:
    
    supplier - The DoubleSupplier of generated elements. Must not be null.
    
    workerPool - Thread pool for parallel execution of a terminal operation. Must not be null.
    
    Returns:
    
    A parallel double stream that executes a terminal operation in the given ForkJoinPool.
    
    See Also:
    
    DoubleStream.generate(DoubleSupplier)
  - concat
```
public static DoubleStream concat(DoubleStream a,
                                  DoubleStream b,
                                  ForkJoinPool workerPool)
```
    Creates a lazily concatenated parallel double stream whose elements are all the elements of the first stream followed by all the elements of the second stream. This operation is similar to calling DoubleStream.concat(a, b).parallel() with the difference that a parallel terminal operation will be executed in the given ForkJoinPool.
    
    Parameters:
    
    a - The first stream. Must not be null.
    
    b - The second stream. Must not be null.
    
    workerPool - Thread pool for parallel execution of a terminal operation. Must not be null.
    
    Returns:
    
    A parallel stream that executes a terminal operation in the given ForkJoinPool.
    
    See Also:
    
    DoubleStream.concat(DoubleStream, DoubleStream)
  - filter
```
public DoubleStream filter(DoublePredicate predicate)
```
    Specified by:
    
    filter in interface DoubleStream
  - map
```
public DoubleStream map(DoubleUnaryOperator mapper)
```
    Specified by:
    
    map in interface DoubleStream
  - mapToObj
```
public <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper)
```
    Specified by:
    
    mapToObj in interface DoubleStream
  - mapToInt
```
public IntStream mapToInt(DoubleToIntFunction mapper)
```
    Specified by:
    
    mapToInt in interface DoubleStream
  - mapToLong
```
public LongStream mapToLong(DoubleToLongFunction mapper)
```
    Specified by:
    
    mapToLong in interface DoubleStream
  - flatMap
```
public DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper)
```
    Specified by:
    
    flatMap in interface DoubleStream
  - distinct
```
public DoubleStream distinct()
```
    Specified by:
    
    distinct in interface DoubleStream
  - sorted
```
public DoubleStream sorted()
```
    Specified by:
    
    sorted in interface DoubleStream
  - peek
```
public DoubleStream peek(DoubleConsumer action)
```
    Specified by:
    
    peek in interface DoubleStream
  - limit
```
public DoubleStream limit(long maxSize)
```
    Specified by:
    
    limit in interface DoubleStream
  - skip
```
public DoubleStream skip(long n)
```
    Specified by:
    
    skip in interface DoubleStream
  - takeWhile
```
public DoubleStream takeWhile(DoublePredicate predicate)
```
    Specified by:
    
    takeWhile in interface DoubleStream
  - dropWhile
```
public DoubleStream dropWhile(DoublePredicate predicate)
```
    Specified by:
    
    dropWhile in interface DoubleStream
  - forEach
```
public void forEach(DoubleConsumer action)
```
    Specified by:
    
    forEach in interface DoubleStream
  - forEachOrdered
```
public void forEachOrdered(DoubleConsumer action)
```
    Specified by:
    
    forEachOrdered in interface DoubleStream
  - toArray
```
public double[] toArray()
```
    Specified by:
    
    toArray in interface DoubleStream
  - reduce
```
public double reduce(double identity,
                     DoubleBinaryOperator op)
```
    Specified by:
    
    reduce in interface DoubleStream
  - reduce
```
public OptionalDouble reduce(DoubleBinaryOperator op)
```
    Specified by:
    
    reduce in interface DoubleStream
  - collect
```
public <R> R collect(Supplier<R> supplier,
                     ObjDoubleConsumer<R> accumulator,
                     BiConsumer<R,R> combiner)
```
    Specified by:
    
    collect in interface DoubleStream
  - sum
```
public double sum()
```
    Specified by:
    
    sum in interface DoubleStream
  - min
```
public OptionalDouble min()
```
    Specified by:
    
    min in interface DoubleStream
  - max
```
public OptionalDouble max()
```
    Specified by:
    
    max in interface DoubleStream
  - count
```
public long count()
```
    Specified by:
    
    count in interface DoubleStream
  - average
```
public OptionalDouble average()
```
    Specified by:
    
    average in interface DoubleStream
  - summaryStatistics
```
public DoubleSummaryStatistics summaryStatistics()
```
    Specified by:
    
    summaryStatistics in interface DoubleStream
  - anyMatch
```
public boolean anyMatch(DoublePredicate predicate)
```
    Specified by:
    
    anyMatch in interface DoubleStream
  - allMatch
```
public boolean allMatch(DoublePredicate predicate)
```
    Specified by:
    
    allMatch in interface DoubleStream
  - noneMatch
```
public boolean noneMatch(DoublePredicate predicate)
```
    Specified by:
    
    noneMatch in interface DoubleStream
  - findFirst
```
public OptionalDouble findFirst()
```
    Specified by:
    
    findFirst in interface DoubleStream
  - findAny
```
public OptionalDouble findAny()
```
    Specified by:
    
    findAny in interface DoubleStream
  - boxed
```
public Stream<Double> boxed()
```
    Specified by:
    
    boxed in interface DoubleStream
  - iterator
```
public PrimitiveIterator.OfDouble iterator()
```
    Specified by:
    
    iterator in interface BaseStream<Double,DoubleStream>
    
    Specified by:
    
    iterator in interface DoubleStream
  - spliterator
```
public Spliterator.OfDouble spliterator()
```
    Specified by:
    
    spliterator in interface BaseStream<Double,DoubleStream>
    
    Specified by:
    
    spliterator in interface DoubleStream
  - isParallel
```
public boolean isParallel()
```
    Specified by:
    
    isParallel in interface BaseStream<T,S extends BaseStream<T,S>>
  - sequential
```
public S sequential()
```
    Specified by:
    
    sequential in interface BaseStream<T,S extends BaseStream<T,S>>
  - parallel
```
public S parallel()
```
    Specified by:
    
    parallel in interface BaseStream<T,S extends BaseStream<T,S>>
  - unordered
```
public S unordered()
```
    Specified by:
    
    unordered in interface BaseStream<T,S extends BaseStream<T,S>>
  - onClose
```
public S onClose(Runnable closeHandler)
```
    Specified by:
    
    onClose in interface BaseStream<T,S extends BaseStream<T,S>>
  - close
```
public void close()
```
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface BaseStream<T,S extends BaseStream<T,S>>
  - execute
```
protected void execute(Runnable terminalOperation)
```
  - execute
```
protected <R> R execute(Callable<R> terminalOperation)
```

Class ParallelDoubleStreamSupport

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.stream.DoubleStream

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.stream.BaseStream

Methods inherited from interface java.util.stream.DoubleStream

Method Detail

parallelStream

parallelStream

parallelStream

parallelStream

iterate

generate

concat

filter

map

mapToObj

mapToInt

mapToLong

flatMap

distinct

sorted

peek

limit

skip

takeWhile

dropWhile

forEach

forEachOrdered

toArray

reduce

reduce

collect

sum

min

max

count

average

summaryStatistics

anyMatch

allMatch

noneMatch

findFirst

findAny

boxed

iterator

spliterator

isParallel

sequential

parallel

unordered

onClose

close

execute

execute