Package no.digipost.stream

Class NonEmptyStream<T>

java.lang.Object

no.digipost.stream.NonEmptyStream<T>

Type Parameters:

T - the type of the stream elements

All Implemented Interfaces:

AutoCloseable, BaseStream<T,Stream<T>>, Stream<T>

public class NonEmptyStream<T>
extends Object
implements Stream<T>

A stream which is guarantied to produce at least one element. It provides some extensions to the general Stream API for processing the stream knowing it is non-empty, including, but not limited to:

• first() and any()
• limitToNonEmpty(long)
• collect(EmptyResultIfEmptySourceCollector)
• reduceFromFirst(BinaryOperator)

A selection of operations which maintains the cardinality of the stream returns NonEmptyStream, such as:

• map(Function)

This selection may be extended in the future. For operations which can not guarantie the result will still be a non-empty stream, such as filter and limit, will yield a regular Stream.

Nested Class Summary

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

Stream.Builder<T extends Object>

Method Summary

Modifier and Type	Method	Description
boolean	allMatch(Predicate<? super T> predicate)
T	any()	Return any element from the stream.
boolean	anyMatch(Predicate<? super T> predicate)
void	close()
<R> R	collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)
<R, A> R	collect(Collector<? super T,A,R> collector)
<A, R> R	collect(EmptyResultIfEmptySourceCollector<? super T,A,R> collector)	Collect the stream elements by using a EmptyResultIfEmptySourceCollector.
static <T> NonEmptyStream<T>	concat(Stream<? extends T> a, NonEmptyStream<? extends T> b)	Create a stream by concatenating a regular Stream followed by a NonEmptyStream, in the same manner as Stream.concat(Stream, Stream).
static <T> NonEmptyStream<T>	concat(NonEmptyStream<? extends T> a, Stream<? extends T> b)	Create a stream by concatenating a NonEmptyStream followed by a regular Stream, in the same manner as Stream.concat(Stream, Stream).
static <T> NonEmptyStream<T>	concat(NonEmptyStream<? extends T> a, NonEmptyStream<? extends T> b)	Create a stream by concatenating two non-empty streams, in the same manner as Stream.concat(Stream, Stream).
long	count()
NonEmptyStream<T>	distinct()
Stream<T>	filter(Predicate<? super T> predicate)
Optional<T>	findAny()
Optional<T>	findFirst()
T	first()	Return the first element of the stream.
<R> Stream<R>	flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
<R> NonEmptyStream<R>	flatMap(ToNonEmptyStreamFunction<? super T,? 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.
DoubleStream	flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
IntStream	flatMapToInt(Function<? super T,? extends IntStream> mapper)
LongStream	flatMapToLong(Function<? super T,? extends LongStream> mapper)
void	forEach(Consumer<? super T> action)
void	forEachOrdered(Consumer<? super T> action)
static <T> NonEmptyStream<T>	generate(Supplier<T> s)	Create the same stream as produced by Stream.generate(Supplier), but typed as NonEmptyStream.
boolean	isParallel()
static <T> NonEmptyStream<T>	iterate(T seed, UnaryOperator<T> f)	Create the same stream as produced by Stream.iterate(Object, UnaryOperator), but typed as NonEmptyStream.
Iterator<T>	iterator()
Stream<T>	limit(long maxSize)
NonEmptyStream<T>	limitToNonEmpty(long maxSizeMoreThanZero)	Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSizeMoreThanZero in length.
<R> NonEmptyStream<R>	map(Function<? super T,? extends R> mapper)
DoubleStream	mapToDouble(ToDoubleFunction<? super T> mapper)
IntStream	mapToInt(ToIntFunction<? super T> mapper)
LongStream	mapToLong(ToLongFunction<? super T> mapper)
Optional<T>	max(Comparator<? super T> comparator)
Optional<T>	min(Comparator<? super T> comparator)
boolean	noneMatch(Predicate<? super T> predicate)
static <T> NonEmptyStream<T>	of(Supplier<? extends T> firstElement, Stream<T> remainingElements)	Create a non-empty stream where the first element is resolved from a Supplier, and remaining elements are provided from another stream.
static <T> NonEmptyStream<T>	of(T singleElement)	Create a non-empty stream containing a single element.
static <T> NonEmptyStream<T>	of(T firstElement, Stream<T> remainingElements)	Create a non-empty stream whose elements are a given first value, and remaining elements are provided from another stream.
static <T> NonEmptyStream<T>	of(T firstElement, T... remainingElements)	Create a non-empty stream whose elements are the specified values.
NonEmptyStream<T>	onClose(Runnable closeHandler)
NonEmptyStream<T>	parallel()
NonEmptyStream<T>	peek(Consumer<? super T> action)
Optional<T>	reduce(BinaryOperator<T> accumulator)
T	reduce(T identity, BinaryOperator<T> accumulator)
<U> U	reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)
T	reduceFromFirst(BinaryOperator<T> accumulator)	Performs a reduction on the elements of this stream, using the first element of the stream (guarantied to be available) and an associative accumulation function, and returns the reduced value.
NonEmptyStream<T>	sequential()
Stream<T>	skip(long n)
NonEmptyStream<T>	sorted()
NonEmptyStream<T>	sorted(Comparator<? super T> comparator)
Spliterator<T>	spliterator()
Object[]	toArray()
<A> A[]	toArray(IntFunction<A[]> generator)
NonEmptyStream<T>	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.Stream

dropWhile, mapMulti, mapMultiToDouble, mapMultiToInt, mapMultiToLong, takeWhile, toList

Method Details

of

public static <T> NonEmptyStream<T> of(T singleElement)

Create a non-empty stream containing a single element.

Type Parameters:

T - the type of the single element in the stream

Parameters:

singleElement - the element

Returns:

the new singleton non-empty stream

of

@SafeVarargs
public static <T> NonEmptyStream<T> of(T firstElement,
 T... remainingElements)

Create a non-empty stream whose elements are the specified values.

Type Parameters:

T - the type of stream elements

Parameters:

firstElement - the first element

remainingElements - the remaining elements after the first

Returns:

the new non-empty stream

of

public static <T> NonEmptyStream<T> of(T firstElement,
 Stream<T> remainingElements)

Create a non-empty stream whose elements are a given first value, and remaining elements are provided from another stream.

Type Parameters:

T - the type of stream elements

Parameters:

firstElement - the first element

remainingElements - the remaining elements after the first

Returns:

the new non-empty stream

of

public static <T> NonEmptyStream<T> of(Supplier<? extends T> firstElement,
 Stream<T> remainingElements)

Create a non-empty stream where the first element is resolved from a Supplier, and remaining elements are provided from another stream.

Type Parameters:

T - the type of stream elements

Parameters:

firstElement - the supplier of the first element

remainingElements - the remaining elements after the first

Returns:

the new non-empty stream

concat

public static <T> NonEmptyStream<T> concat(NonEmptyStream<? extends T> a,
 Stream<? extends T> b)

Create a stream by concatenating a NonEmptyStream followed by a regular Stream, in the same manner as Stream.concat(Stream, Stream). The resulting stream is also non-empty.

Type Parameters:

T - The type of stream elements

Parameters:

a - the first stream, non-empty

b - the second stream

Returns:

the concatenation of the two input streams

See Also:

• Stream.concat(Stream, Stream)

concat

public static <T> NonEmptyStream<T> concat(Stream<? extends T> a,
 NonEmptyStream<? extends T> b)

Create a stream by concatenating a regular Stream followed by a NonEmptyStream, in the same manner as Stream.concat(Stream, Stream). The resulting stream is also non-empty.

Type Parameters:

T - The type of stream elements

Parameters:

a - the first stream

b - the second stream, non-empty

Returns:

the concatenation of the two input streams

See Also:

• Stream.concat(Stream, Stream)

concat

public static <T> NonEmptyStream<T> concat(NonEmptyStream<? extends T> a,
 NonEmptyStream<? extends T> b)

Create a stream by concatenating two non-empty streams, in the same manner as Stream.concat(Stream, Stream). The resulting stream is also non-empty.

This method overload is needed to avoid ambiguity with concat(NonEmptyStream, Stream) and concat(Stream, NonEmptyStream) when concatenating two non-empty streams.

Type Parameters:

T - The type of stream elements

Parameters:

a - the first non-empty stream

b - the second non-empty stream

Returns:

the concatenation of the two input streams

See Also:

• Stream.concat(Stream, Stream)

iterate

public static <T> NonEmptyStream<T> iterate(T seed,
 UnaryOperator<T> f)

Create the same stream as produced by Stream.iterate(Object, UnaryOperator), but typed as NonEmptyStream.

Type Parameters:

T - the type of stream elements

Parameters:

seed - the initial element

f - a function to be applied to to the previous element to produce a new element

Returns:

the new infinite non-empty stream

See Also:

• Stream.iterate(Object, UnaryOperator)

generate

public static <T> NonEmptyStream<T> generate(Supplier<T> s)

Create the same stream as produced by Stream.generate(Supplier), but typed as NonEmptyStream.

Type Parameters:

T - the type of stream elements

Parameters:

s - the Supplier of generated elements

Returns:

a new infinite non-empty stream

See Also:

• Stream.generate(Supplier)

collect

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

Specified by:

collect in interface Stream<T>

collect

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

Specified by:

collect in interface Stream<T>

collect

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

Collect the stream elements by using a EmptyResultIfEmptySourceCollector.

This is an extension to the general Stream API, as a non-empty stream can always produce a value without needing a provided initial "identity" value.

Parameters:

collector - the Collector describing the reduction

Returns:

the result from collecting the elements

See Also:

• EmptyResultIfEmptySourceCollector

map

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

Specified by:

map in interface Stream<T>

iterator

public Iterator<T> iterator()

Specified by:

iterator in interface BaseStream<T,Stream<T>>

spliterator

public Spliterator<T> spliterator()

Specified by:

spliterator in interface BaseStream<T,Stream<T>>

isParallel

public boolean isParallel()

Specified by:

isParallel in interface BaseStream<T,Stream<T>>

sequential

public NonEmptyStream<T> sequential()

Specified by:

sequential in interface BaseStream<T,Stream<T>>

parallel

public NonEmptyStream<T> parallel()

Specified by:

parallel in interface BaseStream<T,Stream<T>>

unordered

public NonEmptyStream<T> unordered()

Specified by:

unordered in interface BaseStream<T,Stream<T>>

onClose

public NonEmptyStream<T> onClose(Runnable closeHandler)

Specified by:

onClose in interface BaseStream<T,Stream<T>>

close

public void close()

Specified by:

close in interface AutoCloseable

Specified by:

close in interface BaseStream<T,Stream<T>>

filter

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

Specified by:

filter in interface Stream<T>

mapToInt

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

Specified by:

mapToInt in interface Stream<T>

mapToLong

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

Specified by:

mapToLong in interface Stream<T>

mapToDouble

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

Specified by:

mapToDouble in interface Stream<T>

flatMap

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

Specified by:

flatMap in interface Stream<T>

flatMap

public <R> NonEmptyStream<R> flatMap(ToNonEmptyStreamFunction<? super T,? 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 extension to the general Stream API, as flat-mapping to non-empty streams will preserve the non-empty guarantee of the stream.

Type Parameters:

R - The element type of the new stream

Parameters:

mapper - a non-interfering, stateless function to apply to each element which produces a stream of new values

Returns:

the new non-empty stream

flatMapToInt

public IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper)

Specified by:

flatMapToInt in interface Stream<T>

flatMapToLong

public LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper)

Specified by:

flatMapToLong in interface Stream<T>

flatMapToDouble

public DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)

Specified by:

flatMapToDouble in interface Stream<T>

distinct

public NonEmptyStream<T> distinct()

Specified by:

distinct in interface Stream<T>

sorted

public NonEmptyStream<T> sorted()

Specified by:

sorted in interface Stream<T>

sorted

public NonEmptyStream<T> sorted(Comparator<? super T> comparator)

Specified by:

sorted in interface Stream<T>

peek

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

Specified by:

peek in interface Stream<T>

limitToNonEmpty

public NonEmptyStream<T> limitToNonEmpty(long maxSizeMoreThanZero)

Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSizeMoreThanZero in length.

Parameters:

maxSizeMoreThanZero - the number of elements the stream should be limited to, must be 1 or greater (>= 1)

Returns:

the new non-empty stream

Throws:

IllegalArgumentException - if the given maxSizeMoreThanZero is 0 or less

See Also:

• limit(long)

limit

public Stream<T> limit(long maxSize)

Specified by:

limit in interface Stream<T>

skip

public Stream<T> skip(long n)

Specified by:

skip in interface Stream<T>

forEach

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

Specified by:

forEach in interface Stream<T>

forEachOrdered

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

Specified by:

forEachOrdered in interface Stream<T>

toArray

public Object[] toArray()

Specified by:

toArray in interface Stream<T>

toArray

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

Specified by:

toArray in interface Stream<T>

reduce

public T reduce(T identity,
 BinaryOperator<T> accumulator)

Specified by:

reduce in interface Stream<T>

reduceFromFirst

public T reduceFromFirst(BinaryOperator<T> accumulator)

Performs a reduction on the elements of this stream, using the first element of the stream (guarantied to be available) and an associative accumulation function, and returns the reduced value.

This is an extension to the general Stream API, as a non-empty stream can always produce a value without needing a provided initial "identity" value.

Parameters:

accumulator - an associative, non-interfering, stateless function for combining two values

Returns:

the result of the reduction

See Also:

• reduce(Object, BinaryOperator)

reduce

public Optional<T> reduce(BinaryOperator<T> accumulator)

Specified by:

reduce in interface Stream<T>

reduce

public <U> U reduce(U identity,
 BiFunction<U,? super T,U> accumulator,
 BinaryOperator<U> combiner)

Specified by:

reduce in interface Stream<T>

min

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

Specified by:

min in interface Stream<T>

max

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

Specified by:

max in interface Stream<T>

count

public long count()

Specified by:

count in interface Stream<T>

anyMatch

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

Specified by:

anyMatch in interface Stream<T>

allMatch

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

Specified by:

allMatch in interface Stream<T>

noneMatch

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

Specified by:

noneMatch in interface Stream<T>

first

public T first()

Return the first element of the stream.

This is an extension to the general Stream API, as a non-empty stream is guarantied to always have at least one value.

Returns:

the first value of the stream

See Also:

• findFirst()

findFirst

public Optional<T> findFirst()

As this is a non-empty stream, this method always returns a non-empty Optional with the first value of the stream.

Specified by:

findFirst in interface Stream<T>

Returns:

an Optional containing the first element of the stream

See Also:

• first()

any

public T any()

Return any element from the stream.

This is an extension to the general Stream API, as a non-empty stream is guarantied to always have at least one value.

Returns:

any value from the stream

See Also:

• findAny()

findAny

public Optional<T> findAny()

As this is a non-empty stream, this method always returns a non-empty Optional with the any value from the stream.

Specified by:

findAny in interface Stream<T>

Returns:

an Optional containing any element from the stream

See Also:

• any()