Gatherers
public
final
class
Gatherers
extends Object
Implementations of Gatherer that provide useful intermediate
operations, such as windowing functions, folding functions,
transforming elements concurrently, etc.
Summary
Public methods |
|---|
static
<T, R>
Gatherer<T, ?, R>
|
fold(Supplier<R> initial, BiFunction<? super R, ? super T, ? extends R> folder)
Returns a Gatherer that performs an ordered, reduction-like,
transformation for scenarios where no combiner-function can be
implemented, or for reductions which are intrinsically
order-dependent.
|
static
<T, R>
Gatherer<T, ?, R>
|
scan(Supplier<R> initial, BiFunction<? super R, ? super T, ? extends R> scanner)
Returns a Gatherer that performs a Prefix Scan -- an incremental
accumulation -- using the provided functions.
|
static
<TR>
Gatherer<TR, ?, List<TR>>
|
windowFixed(int windowSize)
Returns a Gatherer that gathers elements into windows
-- encounter-ordered groups of elements -- of a fixed size.
|
static
<TR>
Gatherer<TR, ?, List<TR>>
|
windowSliding(int windowSize)
Returns a Gatherer that gathers elements into windows --
encounter-ordered groups of elements -- of a given size, where each
subsequent window includes all elements of the previous window except
for the least recent, and adds the next element in the stream.
|
Inherited methods |
|---|
From class
java.lang.Object
Object
|
clone()
Creates and returns a copy of this object.
|
boolean
|
equals(Object obj)
Indicates whether some other object is "equal to" this one.
|
void
|
finalize()
Called by the garbage collector on an object when garbage collection
determines that there are no more references to the object.
|
final
Class<?>
|
getClass()
Returns the runtime class of this Object.
|
int
|
hashCode()
Returns a hash code value for the object.
|
final
void
|
notify()
Wakes up a single thread that is waiting on this object's
monitor.
|
final
void
|
notifyAll()
Wakes up all threads that are waiting on this object's monitor.
|
String
|
toString()
Returns a string representation of the object.
|
final
void
|
wait(long timeoutMillis, int nanos)
Causes the current thread to wait until it is awakened, typically
by being notified or interrupted, or until a
certain amount of real time has elapsed.
|
final
void
|
wait(long timeoutMillis)
Causes the current thread to wait until it is awakened, typically
by being notified or interrupted, or until a
certain amount of real time has elapsed.
|
final
void
|
wait()
Causes the current thread to wait until it is awakened, typically
by being notified or interrupted.
|
|
Public methods
fold
public static Gatherer<T, ?, R> fold (Supplier<R> initial,
BiFunction<? super R, ? super T, ? extends R> folder)
Returns a Gatherer that performs an ordered, reduction-like,
transformation for scenarios where no combiner-function can be
implemented, or for reductions which are intrinsically
order-dependent.
Implementation Requirements:
- If no exceptions are thrown during processing, then this
operation only ever produces a single element.
Example:
lang=java :
// will contain: Optional["123456789"]
Optional<String> numberString =
Stream.of(1,2,3,4,5,6,7,8,9)
.gather(
Gatherers.fold(() -> "", (string, number) -> string + number)
)
.findFirst();
| Parameters |
|---|
initial |
Supplier: the identity value for the fold operation |
folder |
BiFunction: the folding function |
| Returns |
|---|
Gatherer<T, ?, R> |
a new Gatherer |
scan
public static Gatherer<T, ?, R> scan (Supplier<R> initial,
BiFunction<? super R, ? super T, ? extends R> scanner)
Returns a Gatherer that performs a Prefix Scan -- an incremental
accumulation -- using the provided functions. Starting with an
initial value obtained from the Supplier, each subsequent
value is obtained by applying the BiFunction to the current
value and the next input element, after which the resulting value is
produced downstream.
Example:
lang=java :
// will contain: ["1", "12", "123", "1234", "12345", "123456", "1234567", "12345678", "123456789"]
List<String> numberStrings =
Stream.of(1,2,3,4,5,6,7,8,9)
.gather(
Gatherers.scan(() -> "", (string, number) -> string + number)
)
.toList();
| Parameters |
|---|
initial |
Supplier: the supplier of the initial value for the scanner |
scanner |
BiFunction: the function to apply for each element |
| Returns |
|---|
Gatherer<T, ?, R> |
a new Gatherer which performs a prefix scan |
windowFixed
public static Gatherer<TR, ?, List<TR>> windowFixed (int windowSize)
Returns a Gatherer that gathers elements into windows
-- encounter-ordered groups of elements -- of a fixed size.
If the stream is empty then no window will be produced.
The last window may contain fewer elements than the supplied window size.
Example:
lang=java :
// will contain: [[1, 2, 3], [4, 5, 6], [7, 8]]
List<List<Integer>> windows =
Stream.of(1,2,3,4,5,6,7,8).gather(Gatherers.windowFixed(3)).toList();
API Note:
- For efficiency reasons, windows may be allocated contiguously
and eagerly. This means that choosing large window sizes for
small streams may use excessive memory for the duration of
evaluation of this operation.
Implementation Requirements:
- Each window produced is an unmodifiable List; calls to any
mutator method will always cause
UnsupportedOperationException
to be thrown. There are no guarantees on the implementation type or
serializability of the produced Lists.
| Parameters |
|---|
windowSize |
int: the size of the windows |
| Returns |
|---|
Gatherer<TR, ?, List<TR>> |
a new gatherer which groups elements into fixed-size windows |
windowSliding
public static Gatherer<TR, ?, List<TR>> windowSliding (int windowSize)
Returns a Gatherer that gathers elements into windows --
encounter-ordered groups of elements -- of a given size, where each
subsequent window includes all elements of the previous window except
for the least recent, and adds the next element in the stream.
If the stream is empty then no window will be produced. If the size of
the stream is smaller than the window size then only one window will
be produced, containing all elements in the stream.
Example:
lang=java :
// will contain: [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8]]
List<List<Integer>> windows2 =
Stream.of(1,2,3,4,5,6,7,8).gather(Gatherers.windowSliding(2)).toList();
// will contain: [[1, 2, 3, 4, 5, 6], [2, 3, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8]]
List<List<Integer>> windows6 =
Stream.of(1,2,3,4,5,6,7,8).gather(Gatherers.windowSliding(6)).toList();
API Note:
- For efficiency reasons, windows may be allocated contiguously
and eagerly. This means that choosing large window sizes for
small streams may use excessive memory for the duration of
evaluation of this operation.
Implementation Requirements:
- Each window produced is an unmodifiable List; calls to any
mutator method will always cause
UnsupportedOperationException
to be thrown. There are no guarantees on the implementation type or
serializability of the produced Lists.
| Parameters |
|---|
windowSize |
int: the size of the windows |
| Returns |
|---|
Gatherer<TR, ?, List<TR>> |
a new gatherer which groups elements into sliding windows |
