FlowImpl (rapidoid-fluent 5.1.1 API)

java.lang.Object
- org.rapidoid.fluent.flow.FlowImpl<T>

All Implemented Interfaces:

AutoCloseable, BaseStream<T,Stream<T>>, Stream<T>, Flow<T>
```
public class FlowImpl<T>
extends Object
implements Flow<T>
```
Since:

5.0.0

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.stream.Stream
  Stream.Builder<T>

Constructor Summary

Constructors
Constructor and Description

FlowImpl(Stream<T> stream)

Constructors
Constructor and Description
`FlowImpl(Stream<T> stream)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(Predicate<? super T> predicate)`
`boolean`	`anyMatch(Predicate<? super T> predicate)`
`void`	`close()`
`<R,A> R`	`collect(Collector<? super T,A,R> collector)`
`<R> R`	`collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)`
`long`	`count()`
`FlowImpl<T>`	`distinct()`
`FlowImpl<T>`	`filter(Predicate<? super T> predicate)`
`Optional<T>`	`findAny()`
`Optional<T>`	`findFirst()`
`Optional<T>`	`findLast()` Returns an `Optional` describing the last element of this stream, or an empty `Optional` if the stream is empty.
`<R> FlowImpl<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)`
`<K,V> Map<K,List<T>>`	`groupBy(Function<T,K> transformation)` Equivalent to `collect(Collectors.groupingBy(transformation))`.
`boolean`	`isParallel()`
`Iterator<T>`	`iterator()`
`FlowImpl<T>`	`limit(long maxSize)`
`<R> FlowImpl<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)`
`FlowImpl<T>`	`onClose(Runnable closeHandler)`
`FlowImpl<T>`	`parallel()`
`FlowImpl<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)`
`Flow<T>`	`reverse()` Reverses the order of the elements in the flow.
`FlowImpl<T>`	`sequential()`
`FlowImpl<T>`	`skip(long n)`
`FlowImpl<T>`	`sorted()`
`FlowImpl<T>`	`sorted(Comparator<? super T> comparator)`
`Spliterator<T>`	`spliterator()`
`Stream<T>`	`stream()` Returns the wrapped stream.
`Object[]`	`toArray()`
`<A> A[]`	`toArray(IntFunction<A[]> generator)`
`List<T>`	`toList()` Equivalent to `collect(Collectors.toList())`.
`<K,V> Map<K,V>`	`toMap(Function<T,K> keyTransformation, Function<T,V> valueTransformation)` Equivalent to `collect(Collectors.toMap(keyTransformation, valueTransformation))`.
`Set<T>`	`toSet()` Equivalent to `collect(Collectors.toSet())`.
`FlowImpl<T>`	`unordered()`
`<R> Flow<T>`	`withNonNull(Function<? super T,R> transformation)` Equivalent to `stream.filter(x -> transformation.apply(x) != null))`.
`<R> Flow<T>`	`withNull(Function<? super T,R> transformation)` Equivalent to `filter(x -> transformation.apply(x) == null)`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.rapidoid.fluent.Flow
chars, count, of, of, of, range

Methods inherited from interface java.util.stream.Stream
builder, concat, empty, generate, iterate

- Constructor Detail
  - FlowImpl
```
public FlowImpl(Stream<T> stream)
```
- Method Detail
  - 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 FlowImpl<T> sequential()
```
    Specified by:
    
    sequential in interface BaseStream<T,Stream<T>>
  - parallel
```
public FlowImpl<T> parallel()
```
    Specified by:
    
    parallel in interface BaseStream<T,Stream<T>>
  - unordered
```
public FlowImpl<T> unordered()
```
    Specified by:
    
    unordered in interface BaseStream<T,Stream<T>>
  - onClose
```
public FlowImpl<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 FlowImpl<T> filter(Predicate<? super T> predicate)
```
    Specified by:
    
    filter in interface Stream<T>
  - map
```
public <R> FlowImpl<R> map(Function<? super T,? extends R> mapper)
```
    Specified by:
    
    map 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> FlowImpl<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 FlowImpl<T> distinct()
```
    Specified by:
    
    distinct in interface Stream<T>
  - sorted
```
public FlowImpl<T> sorted()
```
    Specified by:
    
    sorted in interface Stream<T>
  - sorted
```
public FlowImpl<T> sorted(Comparator<? super T> comparator)
```
    Specified by:
    
    sorted in interface Stream<T>
  - peek
```
public FlowImpl<T> peek(Consumer<? super T> action)
```
    Specified by:
    
    peek in interface Stream<T>
  - limit
```
public FlowImpl<T> limit(long maxSize)
```
    Specified by:
    
    limit in interface Stream<T>
  - skip
```
public FlowImpl<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>
  - 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>
  - 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>
  - 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>
  - findFirst
```
public Optional<T> findFirst()
```
    Specified by:
    
    findFirst in interface Stream<T>
  - findAny
```
public Optional<T> findAny()
```
    Specified by:
    
    findAny in interface Stream<T>
  - toList
```
public List<T> toList()
```
    Equivalent to collect(Collectors.toList()).
    
    Specified by:
    
    toList in interface Flow<T>
  - toSet
```
public Set<T> toSet()
```
    Equivalent to collect(Collectors.toSet()).
    
    Specified by:
    
    toSet in interface Flow<T>
  - toMap
```
public <K,V> Map<K,V> toMap(Function<T,K> keyTransformation,
                            Function<T,V> valueTransformation)
```
    Equivalent to collect(Collectors.toMap(keyTransformation, valueTransformation)).
    
    Specified by:
    
    toMap in interface Flow<T>
  - stream
```
public Stream<T> stream()
```
    Returns the wrapped stream.
    
    Specified by:
    
    stream in interface Flow<T>
  - withNonNull
```
public <R> Flow<T> withNonNull(Function<? super T,R> transformation)
```
    Equivalent to stream.filter(x -> transformation.apply(x) != null)).
    
    Specified by:
    
    withNonNull in interface Flow<T>
  - withNull
```
public <R> Flow<T> withNull(Function<? super T,R> transformation)
```
    Equivalent to filter(x -> transformation.apply(x) == null).
    
    Specified by:
    
    withNull in interface Flow<T>
  - groupBy
```
public <K,V> Map<K,List<T>> groupBy(Function<T,K> transformation)
```
    Equivalent to collect(Collectors.groupingBy(transformation)).
    
    Specified by:
    
    groupBy in interface Flow<T>
  - reverse
```
public Flow<T> reverse()
```
    Reverses the order of the elements in the flow.
    
    Specified by:
    
    reverse in interface Flow<T>
  - findLast
```
public Optional<T> findLast()
```
    Returns an Optional describing the last element of this stream, or an empty Optional if the stream is empty. If the stream has no encounter order, then any element may be returned.
    
    Specified by:
    
    findLast in interface Flow<T>

Class FlowImpl<T>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.rapidoid.fluent.Flow

Methods inherited from interface java.util.stream.Stream

Constructor Detail

FlowImpl

Method Detail

iterator

spliterator

isParallel

sequential

parallel

unordered

onClose

close

filter

map

mapToInt

mapToLong

mapToDouble

flatMap

flatMapToInt

flatMapToLong

flatMapToDouble

distinct

sorted

sorted

peek

limit

skip

forEach

forEachOrdered

toArray

toArray

reduce

reduce

reduce

collect

collect

min

max

count

anyMatch

allMatch

noneMatch

findFirst

findAny

toList

toSet

toMap

stream

withNonNull

withNull

groupBy

reverse

findLast