com.annimon.stream

Class Stream<T>

java.lang.Object

com.annimon.stream.Stream<T>

Type Parameters:

T - the type of the stream elements

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable

public class Stream<T>
extends java.lang.Object
implements java.io.Closeable

A sequence of elements supporting aggregate operations.

Method Summary

Methods

Modifier and Type	Method and Description
boolean	allMatch(Predicate<? super T> predicate) Tests whether all elements match the given predicate.
boolean	anyMatch(Predicate<? super T> predicate) Tests whether any elements match the given predicate.
<R> R	chain(Function<Stream<T>,R> function) Applies custom operator on stream.
<K> Stream<java.util.List<T>>	chunkBy(Function<? super T,? extends K> classifier) Partitions Stream into Lists according to the given classifier function.
void	close() Causes close handler to be invoked if it exists.
<R,A> R	collect(Collector<? super T,A,R> collector) Collects elements with collector that encapsulates supplier, accumulator and combiner functions.
<R> R	collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator) Collects elements to supplier provided container by applying the given accumulation function.
static <T> Stream<T>	concat(java.util.Collection<? extends T> c1, java.util.Collection<? extends T> c2)
static <T> Stream<T>	concat(java.util.Iterator<? extends T> iterator1, java.util.Iterator<? extends T> iterator2) Concatenates two iterators to a stream.
static <T> Stream<T>	concat(Stream<? extends T> stream1, Stream<? extends T> stream2) Concatenates two streams.
static <T> Stream<T>	concat(T[] a, T[] b)
int	count() Returns the count of elements in this stream.
Stream<T>	distinct() Returns Stream with distinct elements (as determined by hashCode and equals methods).
<K> Stream<T>	distinctBy(Function<? super T,? extends K> keyExtractor) Returns Stream with distinct elements (as determined by hashCode and equals methods) according to the given classifier function.
Stream<T>	dropWhile(Predicate<? super T> predicate) Drops elements while the predicate is true, then returns the rest.
static <T> Stream<T>	empty() Returns an empty stream.
Stream<T>	filter(Predicate<? super T> predicate) Returns Stream with elements that satisfy the given predicate.
Optional<T>	findFirst() Returns the first element wrapped by Optional class.
Optional<T>	findLast() Returns the last element wrapped by Optional class.
<R> Stream<R>	flatMap(Function<? super T,? extends Stream<? extends R>> 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.
<R> Stream<R>	flatMap2(Function<? super T,? extends java.util.Collection<? extends R>> mapper)
<R> Stream<R>	flatMap3(Function<? super T,? extends R[]> mapper)
DoubleStream	flatMapToDouble(Function<? super T,? 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.
<K,V> EntryStream<K,V>	flatMapToEntry(Function<? super T,? extends Stream<? extends java.util.Map.Entry<K,V>>> mapper)
<K,V> EntryStream<K,V>	flatMapToEntry2(Function<? super T,? extends java.util.Map<K,V>> mapper)
IntStream	flatMapToInt(Function<? super T,? extends IntStream> 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.
LongStream	flatMapToLong(Function<? super T,? extends LongStream> 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.
void	forEach(Consumer<? super T> action) Performs the given action on each element.
static <T> Stream<T>	generate(Supplier<T> supplier) Creates a Stream by elements that generated by Supplier.
<K> Stream<java.util.Map.Entry<K,java.util.List<T>>>	groupBy(Function<? super T,? extends K> classifier) Partitions Stream into Map entries according to the given classifier function.
<K,A,D> Stream<java.util.Map.Entry<K,D>>	groupBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
<K,A,D> Stream<java.util.Map.Entry<K,D>>	groupBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream, Supplier<java.util.Map<K,D>> mapFactory)
<K> EntryStream<K,java.util.List<T>>	groupByToEntry(Function<? super T,? extends K> classifier)
<K,A,D> EntryStream<K,D>	groupByToEntry(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
<K,A,D> EntryStream<K,D>	groupByToEntry(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream, Supplier<java.util.Map<K,D>> mapFactory)
<K> java.util.Map<K,java.util.List<T>>	groupTo(Function<? super T,? extends K> classifier)
<K,A,D> java.util.Map<K,D>	groupTo(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)
<K,D,A,M extends java.util.Map<K,D>> M	groupTo(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream, Supplier<M> mapFactory)
Stream<Indexed<T>>	indexed() Returns Stream with indexed elements.
static <T> Stream<T>	iterate(T seed, Predicate<? super T> predicate, UnaryOperator<T> op) Creates a Stream by iterative application UnaryOperator function to an initial element seed, conditioned on satisfying the supplied predicate.
static <T> Stream<T>	iterate(T seed, UnaryOperator<T> op) Creates a Stream by iterative application UnaryOperator function to an initial element seed.
java.util.Iterator<T>	iterator() Returns internal stream iterator.
static <T> Stream<T>	just(T value)
Stream<T>	limit(long maxSize) Returns Stream with first maxSize elements.
<R> Stream<R>	map(Function<? super T,? extends R> mapper) Returns Stream with elements that obtained by applying the given function.
DoubleStream	mapToDouble(ToDoubleFunction<? super T> mapper) Returns DoubleStream with elements that obtained by applying the given function.
<K,V> EntryStream<K,V>	mapToEntry(Function<? super T,K> keyMapper, Function<? super T,V> valueMapper)
<K,V> EntryStream<K,V>	mapToEntry(Function<? super T,java.util.Map.Entry<K,V>> mapper)
IntStream	mapToInt(ToIntFunction<? super T> mapper) Returns IntStream with elements that obtained by applying the given function.
LongStream	mapToLong(ToLongFunction<? super T> mapper) Returns LongStream with elements that obtained by applying the given function.
Optional<T>	max(java.util.Comparator<? super T> comparator) Finds the maximum element according to the given comparator.
<U extends java.lang.Comparable<? super U>> Optional<T>	maxBy(Function<? super T,U> keyExtractor)
static <T> Stream<T>	merge(java.util.Collection<? extends T> c1, java.util.Collection<? extends T> c2, BiFunction<? super T,? super T,com.annimon.stream.operator.ObjMerge.MergeResult> selector)
static <T> Stream<T>	merge(java.util.Iterator<? extends T> iterator1, java.util.Iterator<? extends T> iterator2, BiFunction<? super T,? super T,com.annimon.stream.operator.ObjMerge.MergeResult> selector) Merges elements of two iterators according to the supplied selector function.
static <T> Stream<T>	merge(Stream<? extends T> stream1, Stream<? extends T> stream2, BiFunction<? super T,? super T,com.annimon.stream.operator.ObjMerge.MergeResult> selector) Merges elements of two streams according to the supplied selector function.
static <T> Stream<T>	merge(T[] a, T[] b, BiFunction<? super T,? super T,com.annimon.stream.operator.ObjMerge.MergeResult> selector)
Optional<T>	min(java.util.Comparator<? super T> comparator) Finds the minimum element according to the given comparator.
<U extends java.lang.Comparable<? super U>> Optional<T>	minBy(Function<? super T,U> keyExtractor)
boolean	noneMatch(Predicate<? super T> predicate) Tests whether no elements match the given predicate.
static <T> Stream<T>	of(java.util.Collection<? extends T> c) Creates a Stream from Map entries.
static <T> Stream<T>	of(java.util.Iterator<? extends T> iterator) Creates a Stream from any class that implements Iterator interface.
static <K,V> Stream<java.util.Map.Entry<K,V>>	of(java.util.Map<K,V> map) Creates a Stream from Map entries.
static <T> Stream<T>	of(T... elements) Creates a Stream from the specified values.
static <T> Stream<T>	ofNullable(T element) If specified element is null, returns an empty Stream, otherwise returns a Stream containing a single element.
Stream<T>	onClose(java.lang.Runnable closeHandler) Adds close handler to the current stream.
Stream<T>	peek(Consumer<? super T> action) Performs provided action on each element.
void	println()
Optional<T>	reduce(BiFunction<T,T,T> accumulator) Reduces the elements using provided associative accumulation function.
<R> R	reduce(R identity, BiFunction<? super R,? super T,? extends R> accumulator) Reduces the elements using provided identity value and the associative accumulation function.
Stream<T>	scan(BiFunction<T,T,T> accumulator) Returns a Stream produced by iterative application of a accumulation function to reduction value and next element of the current stream.
<R> Stream<R>	scan(R identity, BiFunction<? super R,? super T,? extends R> accumulator) Returns a Stream produced by iterative application of a accumulation function to an initial element identity and next element of the current stream.
<TT> Stream<TT>	select(java.lang.Class<TT> clazz) Returns a stream consisting of the elements of this stream which are instances of given class.
Stream<T>	skip(long n) Skips first n elements and returns Stream with remaining elements.
Stream<T>	skipNull() Returns Stream without null elements.
Stream<java.util.List<T>>	sliding(int windowSize) Partitions Stream into Lists of fixed size by sliding over the elements of the stream.
Stream<java.util.List<T>>	sliding(int windowSize, int stepWidth) Partitions Stream into Lists of fixed size by sliding over the elements of the stream.
Stream<T>	sorted() Returns Stream with sorted elements (as determinated by Comparable interface).
Stream<T>	sorted(java.util.Comparator<? super T> comparator) Returns Stream with sorted elements (as determinated by provided Comparator).
<U extends java.lang.Comparable<? super U>> Stream<T>	sortedBy(Function<? super T,U> keyExtractor) Returns Stream with sorted elements (as determinated by Comparable interface).
Stream<java.util.List<T>>	split(int size)
Stream<T>	takeUntil(Predicate<? super T> stopPredicate) Takes elements while the predicate returns false.
Stream<T>	takeWhile(Predicate<? super T> predicate) Takes elements while the predicate returns true.
java.lang.Object[]	toArray() Collects elements to an array.
<R> R[]	toArray(IntFunction<R[]> generator) Collects elements to an array, the generator constructor of provided.
<C extends java.util.Collection<T>> C	toCollection(Supplier<C> supplier)
java.util.List<T>	toList() Collects elements to a new List.
<K> java.util.Map<K,T>	toMap(Function<? super T,? extends K> keyMapper)
<K,V> java.util.Map<K,V>	toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
<K,V> java.util.Map<K,V>	toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
<K,V,M extends java.util.Map<K,V>> M	toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<M> mapFactory)
<K,V,M extends java.util.Map<K,V>> M	toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Supplier<M> mapFactory)
java.util.Set<T>	toSet()
static <F,S,R> Stream<R>	zip(java.util.Collection<? extends F> c1, java.util.Collection<? extends S> c2, BiFunction<? super F,? super S,? extends R> combiner)
static <F,S,R> Stream<R>	zip(F[] a, S[] b, BiFunction<? super F,? super S,? extends R> combiner)
static <F,S,R> Stream<R>	zip(java.util.Iterator<? extends F> iterator1, java.util.Iterator<? extends S> iterator2, BiFunction<? super F,? super S,? extends R> combiner) Combines two iterators to a stream by applying specified combiner function to each element at same position.
static <F,S,R> Stream<R>	zip(Stream<? extends F> stream1, Stream<? extends S> stream2, BiFunction<? super F,? super S,? extends R> combiner) Combines two streams by applying specified combiner function to each element at same position.

Methods inherited from class java.lang.Object

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

Method Detail

empty

public static <T> Stream<T> empty()

Returns an empty stream.

Type Parameters:

T - the type of the stream elements

Returns:

the new empty stream

just

public static <T> Stream<T> just(T value)

ofNullable

public static <T> Stream<T> ofNullable(T element)

If specified element is null, returns an empty Stream, otherwise returns a Stream containing a single element.

Type Parameters:

T - the type of the stream element

Parameters:

element - the element to be passed to stream if it is non-null

Returns:

the new stream

Since:

1.1.5

of

@SafeVarargs
public static <T> Stream<T> of(T... elements)

Creates a Stream from the specified values.

Type Parameters:

T - the type of the stream elements

Parameters:

elements - the elements to be passed to stream

Returns:

the new stream

Throws:

java.lang.NullPointerException - if elements is null

of

public static <T> Stream<T> of(java.util.Collection<? extends T> c)

Creates a Stream from Map entries.

Type Parameters:

K - the type of map keys

V - the type of map values

Parameters:

map - the map with elements to be passed to stream

Returns:

the new stream

Throws:

java.lang.NullPointerException - if map is null

of

public static <K,V> Stream<java.util.Map.Entry<K,V>> of(java.util.Map<K,V> map)

Creates a Stream from Map entries.

Type Parameters:

K - the type of map keys

V - the type of map values

Parameters:

map - the map with elements to be passed to stream

Returns:

the new stream

Throws:

java.lang.NullPointerException - if map is null

of

public static <T> Stream<T> of(java.util.Iterator<? extends T> iterator)

Creates a Stream from any class that implements Iterator interface.

Type Parameters:

T - the type of the stream elements

Parameters:

iterator - the iterator with elements to be passed to stream

Returns:

the new stream

Throws:

java.lang.NullPointerException - if iterator is null

generate

public static <T> Stream<T> generate(Supplier<T> supplier)

Creates a Stream by elements that generated by Supplier.

Type Parameters:

T - the type of the stream elements

Parameters:

supplier - the Supplier of generated elements

Returns:

the new stream

Throws:

java.lang.NullPointerException - if supplier is null

iterate

public static <T> Stream<T> iterate(T seed,
                    UnaryOperator<T> op)

Creates a Stream by iterative application UnaryOperator function to an initial element seed. Produces Stream consisting of seed, op(seed), op(op(seed)), etc.

Example:

 seed: 1
 op: (a) -> a + 5
 result: [1, 6, 11, 16, ...]
 

Type Parameters:

T - the type of the stream elements

Parameters:

seed - the initial value

op - operator to produce new element by previous one

Returns:

the new stream

Throws:

java.lang.NullPointerException - if op is null

iterate

public static <T> Stream<T> iterate(T seed,
                    Predicate<? super T> predicate,
                    UnaryOperator<T> op)

Creates a Stream by iterative application UnaryOperator function to an initial element seed, conditioned on satisfying the supplied predicate.

Example:

 seed: 0
 predicate: (a) -> a < 20
 op: (a) -> a + 5
 result: [0, 5, 10, 15]
 

Type Parameters:

T - the type of the stream elements

Parameters:

seed - the initial value

predicate - a predicate to determine when the stream must terminate

op - operator to produce new element by previous one

Returns:

the new stream

Throws:

java.lang.NullPointerException - if op is null

Since:

1.1.5

concat

public static <T> Stream<T> concat(Stream<? extends T> stream1,
                   Stream<? extends T> stream2)

Concatenates two streams.

Example:

 stream 1: [1, 2, 3, 4]
 stream 2: [5, 6]
 result:   [1, 2, 3, 4, 5, 6]
 

Type Parameters:

T - The type of stream elements

Parameters:

stream1 - the first stream

stream2 - the second stream

Returns:

the new concatenated stream

Throws:

java.lang.NullPointerException - if stream1 or stream2 is null

concat

public static <T> Stream<T> concat(java.util.Iterator<? extends T> iterator1,
                   java.util.Iterator<? extends T> iterator2)

Concatenates two iterators to a stream.

Example:

 iterator 1: [1, 2, 3, 4]
 iterator 2: [5, 6]
 result:     [1, 2, 3, 4, 5, 6]
 

Type Parameters:

T - The type of iterator elements

Parameters:

iterator1 - the first iterator

iterator2 - the second iterator

Returns:

the new stream

Throws:

java.lang.NullPointerException - if iterator1 or iterator2 is null

Since:

1.1.9

concat

public static <T> Stream<T> concat(java.util.Collection<? extends T> c1,
                   java.util.Collection<? extends T> c2)

concat

public static <T> Stream<T> concat(T[] a,
                   T[] b)

zip

public static <F,S,R> Stream<R> zip(Stream<? extends F> stream1,
                    Stream<? extends S> stream2,
                    BiFunction<? super F,? super S,? extends R> combiner)

Combines two streams by applying specified combiner function to each element at same position.

Example:

 combiner: (a, b) -> a + b
 stream 1: [1, 2, 3, 4]
 stream 2: [5, 6, 7, 8]
 result:   [6, 8, 10, 12]
 

Type Parameters:

F - the type of first stream elements

S - the type of second stream elements

R - the type of elements in resulting stream

Parameters:

stream1 - the first stream

stream2 - the second stream

combiner - the combiner function used to apply to each element

Returns:

the new stream

Throws:

java.lang.NullPointerException - if stream1 or stream2 is null

zip

public static <F,S,R> Stream<R> zip(java.util.Iterator<? extends F> iterator1,
                    java.util.Iterator<? extends S> iterator2,
                    BiFunction<? super F,? super S,? extends R> combiner)

Combines two iterators to a stream by applying specified combiner function to each element at same position.

Example:

 combiner: (a, b) -> a + b
 stream 1: [1, 2, 3, 4]
 stream 2: [5, 6, 7, 8]
 result:   [6, 8, 10, 12]
 

Type Parameters:

F - the type of first iterator elements

S - the type of second iterator elements

R - the type of elements in resulting stream

Parameters:

iterator1 - the first iterator

iterator2 - the second iterator

combiner - the combiner function used to apply to each element

Returns:

the new stream

Throws:

java.lang.NullPointerException - if iterator1 or iterator2 is null

Since:

1.1.2

zip

public static <F,S,R> Stream<R> zip(java.util.Collection<? extends F> c1,
                    java.util.Collection<? extends S> c2,
                    BiFunction<? super F,? super S,? extends R> combiner)

zip

public static <F,S,R> Stream<R> zip(F[] a,
                    S[] b,
                    BiFunction<? super F,? super S,? extends R> combiner)

merge

public static <T> Stream<T> merge(Stream<? extends T> stream1,
                  Stream<? extends T> stream2,
                  BiFunction<? super T,? super T,com.annimon.stream.operator.ObjMerge.MergeResult> selector)

Merges elements of two streams according to the supplied selector function.

Example 1 — Merge two sorted streams:

 stream1: [1, 3, 8, 10]
 stream2: [2, 5, 6, 12]
 selector: (a, b) -> a < b ? TAKE_FIRST : TAKE_SECOND
 result: [1, 2, 3, 5, 6, 8, 10, 12]
 

Example 2 — Concat two streams:

 stream1: [0, 3, 1]
 stream2: [2, 5, 6, 1]
 selector: (a, b) -> TAKE_SECOND
 result: [2, 5, 6, 1, 0, 3, 1]
 

Type Parameters:

T - the type of the elements

Parameters:

stream1 - the first stream

stream2 - the second stream

selector - the selector function used to choose elements

Returns:

the new stream

Throws:

java.lang.NullPointerException - if stream1 or stream2 is null

Since:

1.1.9

merge

public static <T> Stream<T> merge(java.util.Iterator<? extends T> iterator1,
                  java.util.Iterator<? extends T> iterator2,
                  BiFunction<? super T,? super T,com.annimon.stream.operator.ObjMerge.MergeResult> selector)

Merges elements of two iterators according to the supplied selector function.

Example 1 — Merge two sorted iterators:

 iterator1: [1, 3, 8, 10]
 iterator2: [2, 5, 6, 12]
 selector: (a, b) -> a < b ? TAKE_FIRST : TAKE_SECOND
 result: [1, 2, 3, 5, 6, 8, 10, 12]
 

Example 2 — Concat two iterators:

 iterator1: [0, 3, 1]
 iterator2: [2, 5, 6, 1]
 selector: (a, b) -> TAKE_SECOND
 result: [2, 5, 6, 1, 0, 3, 1]
 

Type Parameters:

T - the type of the elements

Parameters:

iterator1 - the first iterator

iterator2 - the second iterator

selector - the selector function used to choose elements

Returns:

the new stream

Throws:

java.lang.NullPointerException - if iterator1 or iterator2 is null

Since:

1.1.9

merge

public static <T> Stream<T> merge(java.util.Collection<? extends T> c1,
                  java.util.Collection<? extends T> c2,
                  BiFunction<? super T,? super T,com.annimon.stream.operator.ObjMerge.MergeResult> selector)

merge

public static <T> Stream<T> merge(T[] a,
                  T[] b,
                  BiFunction<? super T,? super T,com.annimon.stream.operator.ObjMerge.MergeResult> selector)

iterator

public java.util.Iterator<T> iterator()

Returns internal stream iterator.

Returns:

internal stream iterator

filter

public Stream<T> filter(Predicate<? super T> predicate)

Returns Stream with elements that satisfy the given predicate.

This is an intermediate operation.

Example:

 predicate: (a) -> a > 2
 stream: [1, 2, 3, 4, -8, 0, 11]
 result: [3, 4, 11]
 

Parameters:

predicate - the predicate used to filter elements

Returns:

the new stream

skipNull

public Stream<T> skipNull()

Returns Stream without null elements.

This is an intermediate operation.

Returns:

the new stream

Since:

1.1.6

map

public <R> Stream<R> map(Function<? super T,? extends R> mapper)

Returns Stream with elements that obtained by applying the given function.

This is an intermediate operation.

Example:

 mapper: (a) -> a + 5
 stream: [1, 2, 3, 4]
 result: [6, 7, 8, 9]
 

Type Parameters:

R - the type of elements in resulting stream

Parameters:

mapper - the mapper function used to apply to each element

Returns:

the new stream

mapToInt

public IntStream mapToInt(ToIntFunction<? super T> mapper)

Returns IntStream with elements that obtained by applying the given function.

This is an intermediate operation.

Parameters:

mapper - the mapper function used to apply to each element

Returns:

the new IntStream

See Also:

map(com.annimon.stream.function.Function)

mapToLong

public LongStream mapToLong(ToLongFunction<? super T> mapper)

Returns LongStream with elements that obtained by applying the given function.

This is an intermediate operation.

Parameters:

mapper - the mapper function used to apply to each element

Returns:

the new LongStream

Since:

1.1.4

See Also:

map(com.annimon.stream.function.Function)

mapToDouble

public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)

Returns DoubleStream with elements that obtained by applying the given function.

This is an intermediate operation.

Parameters:

mapper - the mapper function used to apply to each element

Returns:

the new DoubleStream

Since:

1.1.4

See Also:

map(com.annimon.stream.function.Function)

mapToEntry

public <K,V> EntryStream<K,V> mapToEntry(Function<? super T,java.util.Map.Entry<K,V>> mapper)

mapToEntry

public <K,V> EntryStream<K,V> mapToEntry(Function<? super T,K> keyMapper,
                                Function<? super T,V> valueMapper)

flatMap

public <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> 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.

Example:

 mapper: (a) -> [a, a + 5]
 stream: [1, 2, 3, 4]
 result: [1, 6, 2, 7, 3, 8, 4, 9]
 

Type Parameters:

R - the type of elements in resulting stream

Parameters:

mapper - the mapper function used to apply to each element

Returns:

the new stream

flatMap2

public <R> Stream<R> flatMap2(Function<? super T,? extends java.util.Collection<? extends R>> mapper)

flatMap3

public <R> Stream<R> flatMap3(Function<? super T,? extends R[]> mapper)

flatMapToInt

public IntStream flatMapToInt(Function<? super T,? extends IntStream> 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 - the mapper function used to apply to each element

Returns:

the new IntStream

See Also:

flatMap(com.annimon.stream.function.Function)

flatMapToLong

public LongStream flatMapToLong(Function<? super T,? extends LongStream> 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 - the mapper function used to apply to each element

Returns:

the new LongStream

See Also:

flatMap(com.annimon.stream.function.Function)

flatMapToDouble

public DoubleStream flatMapToDouble(Function<? super T,? 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 - the mapper function used to apply to each element

Returns:

the new DoubleStream

See Also:

flatMap(com.annimon.stream.function.Function)

flatMapToEntry

public <K,V> EntryStream<K,V> flatMapToEntry(Function<? super T,? extends Stream<? extends java.util.Map.Entry<K,V>>> mapper)

flatMapToEntry2

public <K,V> EntryStream<K,V> flatMapToEntry2(Function<? super T,? extends java.util.Map<K,V>> mapper)

indexed

public Stream<Indexed<T>> indexed()

Returns Stream with indexed elements. Indexing starts from 0 with step 1.

This is an intermediate operation.

Example:

 stream: ["a", "b", "c"]
 result: [(0, "a"), (1, "b"), (2, "c")]
 

Returns:

the new IntPair stream

Since:

1.1.2

distinct

public Stream<T> distinct()

Returns Stream with distinct elements (as determined by hashCode and equals methods).

This is a stateful intermediate operation.

Example:

 stream: [1, 4, 2, 3, 3, 4, 1]
 result: [1, 4, 2, 3]
 

Returns:

the new stream

distinctBy

public <K> Stream<T> distinctBy(Function<? super T,? extends K> keyExtractor)

Returns Stream with distinct elements (as determined by hashCode and equals methods) according to the given classifier function.

This is a stateful intermediate operation.

Example:

 classifier: (str) -> str.length()
 stream: ["a", "bc", "d", "ef", "ghij"]
 result: ["a", "bc", "ghij"]
 

Parameters:

keyExtractor - the classifier function

Returns:

the new stream

Since:

1.1.8

sorted

public Stream<T> sorted()

Returns Stream with sorted elements (as determinated by Comparable interface).

This is a stateful intermediate operation.

If the elements of this stream are not Comparable, a java.lang.ClassCastException may be thrown when the terminal operation is executed.

Example:

 stream: [3, 4, 1, 2]
 result: [1, 2, 3, 4]
 

Returns:

the new stream

sorted

public Stream<T> sorted(java.util.Comparator<? super T> comparator)

Returns Stream with sorted elements (as determinated by provided Comparator).

This is a stateful intermediate operation.

Example:

 comparator: (a, b) -> -a.compareTo(b)
 stream: [1, 2, 3, 4]
 result: [4, 3, 2, 1]
 

Parameters:

comparator - the Comparator to compare elements

Returns:

the new stream

sortedBy

public <U extends java.lang.Comparable<? super U>> Stream<T> sortedBy(Function<? super T,U> keyExtractor)

Returns Stream with sorted elements (as determinated by Comparable interface). Each element transformed by given function f before comparing.

This is a stateful intermediate operation.

Example:

 f: (a) -> -a
 stream: [1, 2, 3, 4]
 result: [4, 3, 2, 1]
 

Type Parameters:

R - the type of the result of transforming function

Parameters:

keyExtractor - the transformation function

Returns:

the new stream

groupBy

public <K> Stream<java.util.Map.Entry<K,java.util.List<T>>> groupBy(Function<? super T,? extends K> classifier)

Partitions Stream into Map entries according to the given classifier function.

This is a stateful intermediate operation.

Example:

 classifier: (str) -> str.length()
 stream: ["a", "bc", "d", "ef", "ghij"]
 result: [{1: ["a", "d"]}, {2: ["bc", "ef"]}, {4: ["ghij"]}]
 

Type Parameters:

K - the type of the keys, which are result of the classifier function

Parameters:

classifier - the classifier function

Returns:

the new stream

groupBy

public <K,A,D> Stream<java.util.Map.Entry<K,D>> groupBy(Function<? super T,? extends K> classifier,
                                               Collector<? super T,A,D> downstream)

groupBy

public <K,A,D> Stream<java.util.Map.Entry<K,D>> groupBy(Function<? super T,? extends K> classifier,
                                               Collector<? super T,A,D> downstream,
                                               Supplier<java.util.Map<K,D>> mapFactory)

groupByToEntry

public <K> EntryStream<K,java.util.List<T>> groupByToEntry(Function<? super T,? extends K> classifier)

groupByToEntry

public <K,A,D> EntryStream<K,D> groupByToEntry(Function<? super T,? extends K> classifier,
                                      Collector<? super T,A,D> downstream)

groupByToEntry

public <K,A,D> EntryStream<K,D> groupByToEntry(Function<? super T,? extends K> classifier,
                                      Collector<? super T,A,D> downstream,
                                      Supplier<java.util.Map<K,D>> mapFactory)

groupTo

public <K> java.util.Map<K,java.util.List<T>> groupTo(Function<? super T,? extends K> classifier)

groupTo

public <K,A,D> java.util.Map<K,D> groupTo(Function<? super T,? extends K> classifier,
                                 Collector<? super T,A,D> downstream)

groupTo

public <K,D,A,M extends java.util.Map<K,D>> M groupTo(Function<? super T,? extends K> classifier,
                                             Collector<? super T,A,D> downstream,
                                             Supplier<M> mapFactory)

chunkBy

public <K> Stream<java.util.List<T>> chunkBy(Function<? super T,? extends K> classifier)

Partitions Stream into Lists according to the given classifier function. In contrast to groupBy(Function), this method assumes that the elements of the stream are sorted. Because of this assumption, it does not need to first collect all elements and then partition them. Instead, it can emit a List of elements when it reaches the first element that does not belong to the same chunk as the previous elements.

This is an intermediate operation.

Example:

 classifier: (a) -> a % 5 == 0
 stream: [1, 2, 5, 6, 7, 9, 10, 12, 14]
 result: [[1, 2], [5], [6, 7, 9], [10], [12, 14]]
 

Type Parameters:

K - the type of the keys, which are the result of the classifier function

Parameters:

classifier - the classifier function

Returns:

the new stream

split

public Stream<java.util.List<T>> split(int size)

sliding

public Stream<java.util.List<T>> sliding(int windowSize)

Partitions Stream into Lists of fixed size by sliding over the elements of the stream. It starts with the first element and in each iteration moves by 1. This method yields the same results as calling sliding(int, int) with a stepWidth of 1.

This is an intermediate operation.

Example:

 windowSize: 3
 stream: [1, 2, 3, 4, 5]
 result: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
 

Parameters:

windowSize - number of elements that will be emitted together in a list

Returns:

the new stream

See Also:

sliding(int, int)

sliding

public Stream<java.util.List<T>> sliding(int windowSize,
                                int stepWidth)

Partitions Stream into Lists of fixed size by sliding over the elements of the stream. It starts with the first element and in each iteration moves by the given step width. This method allows, for example, to partition the elements into batches of windowSize elements (by using a step width equal to the specified window size) or to sample every n-th element (by using a window size of 1 and a step width of n).

This is an intermediate operation.

Example:

 windowSize: 3, stepWidth: 3
 stream: [1, 1, 1, 2, 2, 2, 3, 3, 3]
 result: [[1, 1, 1], [2, 2, 2] [3, 3, 3]]

 windowSize: 2, stepWidth: 3
 stream: [1, 2, 3, 1, 2, 3, 1, 2, 3]
 result: [[1, 2], [1, 2], [1, 2]]

 windowSize: 3, stepWidth: 1
 stream: [1, 2, 3, 4, 5, 6]
 result: [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]]
 

Parameters:

windowSize - number of elements that will be emitted together in a list

stepWidth - step width

Returns:

the new stream

Throws:

java.lang.IllegalArgumentException - if windowSize is zero or negative

java.lang.IllegalArgumentException - if stepWidth is zero or negative

peek

public Stream<T> peek(Consumer<? super T> action)

Performs provided action on each element.

This is an intermediate operation.

Parameters:

action - the action to be performed on each element

Returns:

the new stream

scan

public Stream<T> scan(BiFunction<T,T,T> accumulator)

Returns a Stream produced by iterative application of a accumulation function to reduction value and next element of the current stream. Produces a Stream consisting of value1, acc(value1, value2), acc(acc(value1, value2), value3), etc.

This is an intermediate operation.

Example:

 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [1, 3, 6, 10, 15]
 

Parameters:

accumulator - the accumulation function

Returns:

the new stream

Throws:

java.lang.NullPointerException - if accumulator is null

Since:

1.1.6

scan

public <R> Stream<R> scan(R identity,
                 BiFunction<? super R,? super T,? extends R> accumulator)

Returns a Stream produced by iterative application of a accumulation function to an initial element identity and next element of the current stream. Produces a Stream consisting of identity, acc(identity, value1), acc(acc(identity, value1), value2), etc.

This is an intermediate operation.

Example:

 identity: 0
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [0, 1, 3, 6, 10, 15]
 

Type Parameters:

R - the type of the result

Parameters:

identity - the initial value

accumulator - the accumulation function

Returns:

the new stream

Throws:

java.lang.NullPointerException - if accumulator is null

Since:

1.1.6

takeWhile

public Stream<T> takeWhile(Predicate<? super T> predicate)

Takes elements while the predicate returns true.

This is an intermediate operation.

Example:

 predicate: (a) -> a < 3
 stream: [1, 2, 3, 4, 1, 2, 3, 4]
 result: [1, 2]
 

Parameters:

predicate - the predicate used to take elements

Returns:

the new stream

takeUntil

public Stream<T> takeUntil(Predicate<? super T> stopPredicate)

Takes elements while the predicate returns false. Once predicate condition is satisfied by an element, the stream finishes with this element.

This is an intermediate operation.

Example:

 stopPredicate: (a) -> a > 2
 stream: [1, 2, 3, 4, 1, 2, 3, 4]
 result: [1, 2, 3]
 

Parameters:

stopPredicate - the predicate used to take elements

Returns:

the new stream

Since:

1.1.6

dropWhile

public Stream<T> dropWhile(Predicate<? super T> predicate)

Drops elements while the predicate is true, then returns the rest.

This is an intermediate operation.

Example:

 predicate: (a) -> a < 3
 stream: [1, 2, 3, 4, 1, 2, 3, 4]
 result: [3, 4, 1, 2, 3, 4]
 

Parameters:

predicate - the predicate used to drop elements

Returns:

the new stream

limit

public Stream<T> limit(long maxSize)

Returns Stream with first maxSize elements.

This is a short-circuiting stateful intermediate operation.

Example:

 maxSize: 3
 stream: [1, 2, 3, 4, 5]
 result: [1, 2, 3]

 maxSize: 10
 stream: [1, 2]
 result: [1, 2]
 

Parameters:

maxSize - the number of elements to limit

Returns:

the new stream

Throws:

java.lang.IllegalArgumentException - if maxSize is negative

skip

public Stream<T> skip(long n)

Skips first n elements and returns Stream with remaining elements. If stream contains fewer than n elements, then an empty stream will be returned.

This is a stateful intermediate operation.

Example:

 n: 3
 stream: [1, 2, 3, 4, 5]
 result: [4, 5]

 n: 10
 stream: [1, 2]
 result: []
 

Parameters:

n - the number of elements to skip

Returns:

the new stream

Throws:

java.lang.IllegalArgumentException - if n is negative

anyMatch

public boolean anyMatch(Predicate<? super T> predicate)

Tests whether any elements match the given predicate.

This is a short-circuiting terminal operation.

Example:

 predicate: (a) -> a == 5
 stream: [1, 2, 3, 4, 5]
 result: true

 predicate: (a) -> a == 5
 stream: [5, 5, 5]
 result: true
 

Parameters:

predicate - the predicate used to match elements

Returns:

true if any elements match the given predicate, otherwise false

allMatch

public boolean allMatch(Predicate<? super T> predicate)

Tests whether all elements match the given predicate.

This is a short-circuiting terminal operation.

Example:

 predicate: (a) -> a == 5
 stream: [1, 2, 3, 4, 5]
 result: false

 predicate: (a) -> a == 5
 stream: [5, 5, 5]
 result: true
 

Parameters:

predicate - the predicate used to match elements

Returns:

true if all elements match the given predicate, otherwise false

noneMatch

public boolean noneMatch(Predicate<? super T> predicate)

Tests whether no elements match the given predicate.

This is a short-circuiting terminal operation.

Example:

 predicate: (a) -> a == 5
 stream: [1, 2, 3, 4, 5]
 result: false

 predicate: (a) -> a == 5
 stream: [1, 2, 3]
 result: true
 

Parameters:

predicate - the predicate used to match elements

Returns:

true if no elements match the given predicate, otherwise false

findFirst

public Optional<T> findFirst()

Returns the first element wrapped by Optional class. If stream is empty, returns Optional.empty().

This is a short-circuiting terminal operation.

Returns:

an Optional with the first element or Optional.empty() if stream is empty

findLast

public Optional<T> findLast()

Returns the last element wrapped by Optional class. If stream is empty, returns Optional.empty().

This is a short-circuiting terminal operation.

Returns:

an Optional with the last element or Optional.empty() if the stream is empty

Since:

1.1.8

min

public Optional<T> min(java.util.Comparator<? super T> comparator)

Finds the minimum element according to the given comparator.

This is a terminal operation.

Example:

 comparator: (a, b) -> a.compareTo(b)
 stream: [1, 2, 3, 4, 5]
 result: 1
 

Parameters:

comparator - the Comparator to compare elements

Returns:

the minimum element

minBy

public <U extends java.lang.Comparable<? super U>> Optional<T> minBy(Function<? super T,U> keyExtractor)

max

public Optional<T> max(java.util.Comparator<? super T> comparator)

Finds the maximum element according to the given comparator.

This is a terminal operation.

Example:

 comparator: (a, b) -> a.compareTo(b)
 stream: [1, 2, 3, 4, 5]
 result: 5
 

Parameters:

comparator - the Comparator to compare elements

Returns:

the maximum element

maxBy

public <U extends java.lang.Comparable<? super U>> Optional<T> maxBy(Function<? super T,U> keyExtractor)

forEach

public void forEach(Consumer<? super T> action)

Performs the given action on each element.

This is a terminal operation.

Parameters:

action - the action to be performed on each element

reduce

public <R> R reduce(R identity,
           BiFunction<? super R,? super T,? extends R> accumulator)

Reduces the elements using provided identity value and the associative accumulation function.

This is a terminal operation.

Example:

 identity: 0
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: 15
 

Type Parameters:

R - the type of the result

Parameters:

identity - the initial value

accumulator - the accumulation function

Returns:

the result of the reduction

reduce

public Optional<T> reduce(BiFunction<T,T,T> accumulator)

Reduces the elements using provided associative accumulation function.

This is a terminal operation.

Parameters:

accumulator - the accumulation function

Returns:

the result of the reduction

See Also:

reduce(java.lang.Object, com.annimon.stream.function.BiFunction)

collect

public <R> R collect(Supplier<R> supplier,
            BiConsumer<R,? super T> accumulator)

Collects elements to supplier provided container by applying the given accumulation function.

This is a terminal operation.

Type Parameters:

R - the type of the result

Parameters:

supplier - the supplier function that provides container

accumulator - the accumulation function

Returns:

the result of collect elements

See Also:

collect(com.annimon.stream.Collector)

collect

public <R,A> R collect(Collector<? super T,A,R> collector)

Collects elements with collector that encapsulates supplier, accumulator and combiner functions.

This is a terminal operation.

Type Parameters:

R - the type of result

A - the intermediate used by Collector

Parameters:

collector - the Collector

Returns:

the result of collect elements

See Also:

collect(com.annimon.stream.function.Supplier, com.annimon.stream.function.BiConsumer)

count

public int count()

Returns the count of elements in this stream.

This is a terminal operation.

Returns:

the count of elements

toArray

public java.lang.Object[] toArray()

Collects elements to an array.

This is a terminal operation.

Returns:

the result of collect elements

See Also:

toArray(com.annimon.stream.function.IntFunction)

toArray

public <R> R[] toArray(IntFunction<R[]> generator)

Collects elements to an array, the generator constructor of provided.

This is a terminal operation.

Type Parameters:

R - the type of the result

Parameters:

generator - the array constructor reference that accommodates future array of assigned size

Returns:

the result of collect elements

toList

public java.util.List<T> toList()

Collects elements to a new List.

This implementation does not call collect(Collectors.toList()), so it can be faster by reducing method calls.

This is a terminal operation.

Returns:

a new List

Since:

1.1.5

See Also:

Collectors.toList()

toSet

public java.util.Set<T> toSet()

toCollection

public <C extends java.util.Collection<T>> C toCollection(Supplier<C> supplier)

toMap

public <K> java.util.Map<K,T> toMap(Function<? super T,? extends K> keyMapper)

Parameters:

keyMapper -

Returns:

See Also:

Collectors.toMap(Function)

toMap

public <K,V> java.util.Map<K,V> toMap(Function<? super T,? extends K> keyMapper,
                             Function<? super T,? extends V> valueMapper)

Parameters:

keyMapper -

valueMapper -

Returns:

See Also:

Collectors.toMap(Function, Function)

toMap

public <K,V> java.util.Map<K,V> toMap(Function<? super T,? extends K> keyMapper,
                             Function<? super T,? extends V> valueMapper,
                             BinaryOperator<V> mergeFunction)

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

See Also:

Collectors.toMap(Function, Function, BinaryOperator)

toMap

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

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

See Also:

Collectors.toMap(Function, Function, Supplier)

toMap

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

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

See Also:

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

chain

public <R> R chain(Function<Stream<T>,R> function)

Applies custom operator on stream. Transforming function can return Stream for intermediate operations, or any value for terminal operation.

Operator examples:

     // Intermediate operator
     public class Reverse<T> implements Function<Stream<T>, Stream<T>> {
         @Override
         public Stream<T> apply(Stream<T> stream) {
             final Iterator<? extends T> iterator = stream.iterator();
             final ArrayDeque<T> deque = new ArrayDeque<T>();
             while (iterator.hasNext()) {
                 deque.addFirst(iterator.next());
             }
             return Stream.of(deque.iterator());
         }
     }

     // Intermediate operator based on existing stream operators
     public class SkipAndLimit<T> implements UnaryOperator<Stream<T>> {

         private final int skip, limit;

         public SkipAndLimit(int skip, int limit) {
             this.skip = skip;
             this.limit = limit;
         }

         @Override
         public Stream<T> apply(Stream<T> stream) {
             return stream.skip(skip).limit(limit);
         }
     }

     // Terminal operator
     public class Sum implements Function<Stream<Integer>, Integer> {
         @Override
         public Integer apply(Stream<Integer> stream) {
             return stream.reduce(0, new BinaryOperator<Integer>() {
                 @Override
                 public Integer apply(Integer value1, Integer value2) {
                     return value1 + value2;
                 }
             });
         }
     }
 

Type Parameters:

R - the type of the result

Parameters:

function - a transforming function

Returns:

a result of the transforming function

Throws:

java.lang.NullPointerException - if function is null

select

public <TT> Stream<TT> select(java.lang.Class<TT> clazz)

Returns a stream consisting of the elements of this stream which are instances of given class.

This is an intermediate operation.

Type Parameters:

TT - a type of instances to select.

Parameters:

clazz - a class which instances should be selected

Returns:

the new stream of type passed as parameter

println

public void println()

onClose

public Stream<T> onClose(java.lang.Runnable closeHandler)

Adds close handler to the current stream.

This is an intermediate operation.

Parameters:

closeHandler - an action to execute when the stream is closed

Returns:

the new stream with the close handler

Since:

1.1.8

close

public void close()

Causes close handler to be invoked if it exists. Since most of the stream providers are lists or arrays, it is not necessary to close the stream.

Specified by:

close in interface java.io.Closeable

Specified by:

close in interface java.lang.AutoCloseable

Since:

1.1.8