com.pivovarit.collectors

Class ParallelCollectors

java.lang.Object

com.pivovarit.collectors.ParallelCollectors

public final class ParallelCollectors
extends java.lang.Object

An umbrella class exposing static factory methods for instantiating parallel Collectors

Author:

Grzegorz Piwowarek

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ParallelCollectors.Batching A subset of collectors which perform operations in batches and not separately (one object in a thread pool's worker queue represents a batch of operations to be performed by a single thread)

Method Summary

Modifier and Type	Method and Description
static <T,R,RR> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<RR>>	parallel(java.util.function.Function<T,R> mapper, java.util.stream.Collector<R,?,RR> collector, java.util.concurrent.Executor executor) Deprecated. use parallel(Function, Collector, Executor, int)
static <T,R,RR> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<RR>>	parallel(java.util.function.Function<T,R> mapper, java.util.stream.Collector<R,?,RR> collector, java.util.concurrent.Executor executor, int parallelism) A convenience Collector used for executing parallel computations on a custom Executor and returning them as a CompletableFuture containing a result of the application of the user-provided Collector.
static <T,R> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>>	parallel(java.util.function.Function<T,R> mapper, java.util.concurrent.Executor executor) Deprecated. use parallel(Function, Executor, int)
static <T,R> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>>	parallel(java.util.function.Function<T,R> mapper, java.util.concurrent.Executor executor, int parallelism) A convenience Collector used for executing parallel computations on a custom Executor and returning them as CompletableFuture containing a Stream of these elements.
static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>>	parallelToOrderedStream(java.util.function.Function<T,R> mapper, java.util.concurrent.Executor executor) Deprecated. use parallelToOrderedStream(Function, Executor, int)
static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>>	parallelToOrderedStream(java.util.function.Function<T,R> mapper, java.util.concurrent.Executor executor, int parallelism) A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results as they arrive while maintaining the initial order.
static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>>	parallelToStream(java.util.function.Function<T,R> mapper, java.util.concurrent.Executor executor) Deprecated. use parallelToStream(Function, Executor, int)
static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>>	parallelToStream(java.util.function.Function<T,R> mapper, java.util.concurrent.Executor executor, int parallelism) A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results as they arrive.
static <T> java.util.stream.Collector<java.util.concurrent.CompletableFuture<T>,?,java.util.concurrent.CompletableFuture<java.util.List<T>>>	toFuture() A convenience Collector for collecting a Stream<CompletableFuture<T>> into a CompletableFuture<List<T>>
static <T,R> java.util.stream.Collector<java.util.concurrent.CompletableFuture<T>,?,java.util.concurrent.CompletableFuture<R>>	toFuture(java.util.stream.Collector<T,?,R> collector) A convenience Collector for collecting a Stream<CompletableFuture<T>> into a CompletableFuture<R> using a provided Collector<T, ?, R>

Methods inherited from class java.lang.Object

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

Method Detail

parallel

@Deprecated
public static <T,R,RR> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<RR>> parallel(java.util.function.Function<T,R> mapper,
                                                                                                                       java.util.stream.Collector<R,?,RR> collector,
                                                                                                                       java.util.concurrent.Executor executor)

Deprecated. use parallel(Function, Collector, Executor, int)

A convenience Collector used for executing parallel computations on a custom Executor and returning them as a CompletableFuture containing a result of the application of the user-provided Collector.

The maximum parallelism level defaults to Runtime.availableProcessors() - 1
Example:

 CompletableFuture<List<String>> result = Stream.of(1, 2, 3)
   .collect(parallel(i -> foo(i), toList(), executor));
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

RR - the reduction result collector

Parameters:

mapper - a transformation to be performed in parallel

collector - the Collector describing the reduction

executor - the Executor to use for asynchronous execution

Returns:

a Collector which collects all processed elements into a user-provided mutable Collection in parallel

Since:

2.0.0

parallel

public static <T,R,RR> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<RR>> parallel(java.util.function.Function<T,R> mapper,
                                                                                                           java.util.stream.Collector<R,?,RR> collector,
                                                                                                           java.util.concurrent.Executor executor,
                                                                                                           int parallelism)

A convenience Collector used for executing parallel computations on a custom Executor and returning them as a CompletableFuture containing a result of the application of the user-provided Collector.
Example:

 CompletableFuture<List<String>> result = Stream.of(1, 2, 3)
   .collect(parallel(i -> foo(i), toList(), executor, 2));
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

RR - the reduction result collector

Parameters:

mapper - a transformation to be performed in parallel

collector - the Collector describing the reduction

executor - the Executor to use for asynchronous execution

parallelism - the max parallelism level

Returns:

a Collector which collects all processed elements into a user-provided mutable Collection in parallel

Since:

2.0.0

parallel

@Deprecated
public static <T,R> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>> parallel(java.util.function.Function<T,R> mapper,
                                                                                                                                            java.util.concurrent.Executor executor)

Deprecated. use parallel(Function, Executor, int)

A convenience Collector used for executing parallel computations on a custom Executor and returning them as CompletableFuture containing a Stream of these elements

The max parallelism level defaults to Runtime.availableProcessors() - 1

The collector maintains the order of processed Stream. Instances should not be reused.
Example:

 CompletableFuture<Stream<String>> result = Stream.of(1, 2, 3)
   .collect(parallel(i -> foo(), executor));
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

Parameters:

mapper - a transformation to be performed in parallel

executor - the Executor to use for asynchronous execution

Returns:

a Collector which collects all processed elements into a Stream in parallel

Since:

2.0.0

parallel

public static <T,R> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>> parallel(java.util.function.Function<T,R> mapper,
                                                                                                                                java.util.concurrent.Executor executor,
                                                                                                                                int parallelism)

A convenience Collector used for executing parallel computations on a custom Executor and returning them as CompletableFuture containing a Stream of these elements.

The max parallelism level defaults to Runtime.availableProcessors() - 1

The collector maintains the order of processed Stream. Instances should not be reused.
Example:

 CompletableFuture<Stream<String>> result = Stream.of(1, 2, 3)
   .collect(parallel(i -> foo(), executor, 2));
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

Parameters:

mapper - a transformation to be performed in parallel

executor - the Executor to use for asynchronous execution

parallelism - the max parallelism level

Returns:

a Collector which collects all processed elements into a Stream in parallel

Since:

2.0.0

parallelToStream

@Deprecated
public static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>> parallelToStream(java.util.function.Function<T,R> mapper,
                                                                                                            java.util.concurrent.Executor executor)

Deprecated. use parallelToStream(Function, Executor, int)

A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results in completion order

For the parallelism of 1, the stream is executed by the calling thread.

The max parallelism level defaults to Runtime.availableProcessors() - 1

Instances should not be reused.
Example:

 List<String> result = Stream.of(1, 2, 3)
   .collect(parallelToStream(i -> foo(), executor))
   .collect(toList());
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

Parameters:

mapper - a transformation to be performed in parallel

executor - the Executor to use for asynchronous execution

Returns:

a Collector which collects all processed elements into a Stream in parallel

Since:

2.0.0

parallelToStream

public static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>> parallelToStream(java.util.function.Function<T,R> mapper,
                                                                                                java.util.concurrent.Executor executor,
                                                                                                int parallelism)

A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results as they arrive.

For the parallelism of 1, the stream is executed by the calling thread.
Example:

 Stream.of(1, 2, 3)
   .collect(parallelToStream(i -> foo(), executor, 2))
   .forEach(System.out::println);
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

Parameters:

mapper - a transformation to be performed in parallel

executor - the Executor to use for asynchronous execution

parallelism - the max parallelism level

Returns:

a Collector which collects all processed elements into a Stream in parallel

Since:

2.0.0

parallelToOrderedStream

@Deprecated
public static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>> parallelToOrderedStream(java.util.function.Function<T,R> mapper,
                                                                                                                   java.util.concurrent.Executor executor)

Deprecated. use parallelToOrderedStream(Function, Executor, int)

A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results as they arrive while maintaining the initial order.

For the parallelism of 1, the stream is executed by the calling thread.

The max parallelism level defaults to Runtime.availableProcessors() - 1

Instances should not be reused.

Example:

 Stream.of(1, 2, 3)
   .collect(parallelToOrderedStream(i -> foo(), executor))
   .forEach(System.out::println);
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

Parameters:

mapper - a transformation to be performed in parallel

executor - the Executor to use for asynchronous execution

Returns:

a Collector which collects all processed elements into a Stream in parallel

Since:

2.0.0

parallelToOrderedStream

public static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>> parallelToOrderedStream(java.util.function.Function<T,R> mapper,
                                                                                                       java.util.concurrent.Executor executor,
                                                                                                       int parallelism)

A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results as they arrive while maintaining the initial order.

For the parallelism of 1, the stream is executed by the calling thread.
Example:

 Stream.of(1, 2, 3)
   .collect(parallelToOrderedStream(i -> foo(), executor, 2))
   .forEach(System.out::println);
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

Parameters:

mapper - a transformation to be performed in parallel

executor - the Executor to use for asynchronous execution

parallelism - the max parallelism level

Returns:

a Collector which collects all processed elements into a Stream in parallel

Since:

2.0.0

toFuture

public static <T,R> java.util.stream.Collector<java.util.concurrent.CompletableFuture<T>,?,java.util.concurrent.CompletableFuture<R>> toFuture(java.util.stream.Collector<T,?,R> collector)

A convenience Collector for collecting a Stream<CompletableFuture<T>> into a CompletableFuture<R> using a provided Collector<T, ?, R>

Type Parameters:

T - the type of the collected elements

R - the result of the transformation

Parameters:

collector - the Collector describing the reduction

Returns:

a Collector which collects all futures and combines them into a single future using the provided downstream Collector

Since:

2.3.0

toFuture

public static <T> java.util.stream.Collector<java.util.concurrent.CompletableFuture<T>,?,java.util.concurrent.CompletableFuture<java.util.List<T>>> toFuture()

A convenience Collector for collecting a Stream<CompletableFuture<T>> into a CompletableFuture<List<T>>

Type Parameters:

T - the type of the collected elements

Returns:

a Collector which collects all futures and combines them into a single future returning a list of results

Since:

2.3.0