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:
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

All Methods Static Methods Instance Methods Concrete Methods
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`.
`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)`
`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)`
`boolean`	`isParallel()`
`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)`
`static <T> NonEmptyStream<T>`	`of(T singleElement)`
`static <T> NonEmptyStream<T>`	`of(T firstElement, Stream<T> remainingElements)`
`static <T> NonEmptyStream<T>`	`of(T firstElement, T... remainingElements)`
`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, takeWhile

- Method Detail
  - of
```
public static <T> NonEmptyStream<T> of(T singleElement)
```
  - of
```
@SafeVarargs
public static <T> NonEmptyStream<T> of(T firstElement,
                                       T... remainingElements)
```
  - of
```
public static <T> NonEmptyStream<T> of(T firstElement,
                                       Stream<T> remainingElements)
```
  - of
```
public static <T> NonEmptyStream<T> of(Supplier<? extends T> firstElement,
                                       Stream<T> remainingElements)
```
  - 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>
  - 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()

Class NonEmptyStream<T>

Nested Class Summary

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

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.stream.Stream

Method Detail

of

of

of

of

collect

collect

collect

map

iterator

spliterator

isParallel

sequential

parallel

unordered

onClose

close

filter

mapToInt

mapToLong

mapToDouble

flatMap

flatMapToInt

flatMapToLong

flatMapToDouble

distinct

sorted

sorted

peek

limitToNonEmpty

limit

skip

forEach

forEachOrdered

toArray

toArray

reduce

reduceFromFirst

reduce

reduce

min

max

count

anyMatch

allMatch

noneMatch

first

findFirst

any

findAny