FloatStream (abacus API Documentation)

java.lang.Object
- com.landawn.abacus.util.stream.FloatStream

All Implemented Interfaces:

BaseStream<java.lang.Float,float[],FloatPredicate,FloatConsumer,FloatList,OptionalFloat,com.landawn.abacus.util.IndexedFloat,FloatStream>, java.lang.AutoCloseable
```
public abstract class FloatStream
extends java.lang.Object
```
Note: It's copied from OpenJDK at: http://hg.openjdk.java.net/jdk8u/hs-dev/jdk
A sequence of primitive float-valued elements supporting sequential and parallel aggregate operations. This is the float primitive specialization of Stream.
The following example illustrates an aggregate operation using Stream and FloatStream, computing the sum of the weights of the red widgets:
```
     float sum = widgets.stream()
                         .filter(w -> w.getColor() == RED)
                         .mapToFloat(w -> w.getWeight())
                         .sum();
 
```
See the class documentation for Stream and the package documentation for java.util.stream for additional specification of streams, stream operations, stream pipelines, and parallelism.
Since:

1.8

See Also:

Stream, java.util.stream

Nested Class Summary
- Nested classes/interfaces inherited from interface com.landawn.abacus.util.stream.BaseStream
  BaseStream.Splitor

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`<R> R`	`__(Function<? super FloatStream,R> transfer)`
`abstract DoubleStream`	`asDoubleStream()` Returns a `DoubleStream` consisting of the elements of this stream, converted to `double`.
`abstract OptionalDouble`	`average()` Returns an `OptionalFloat` describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty.
`abstract Stream<java.lang.Float>`	`boxed()` Returns a `Stream` consisting of the elements of this stream, boxed to `Float`.
`S`	`carry(C action)` Same as `peek`
`void`	`close()` Closes this stream, causing all close handlers for this stream pipeline to be called.
`abstract FloatStream`	`collapse(FloatBiPredicate collapsible, FloatBiFunction<java.lang.Float> mergeFunction)` Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
`abstract <R> R`	`collect(Supplier<R> supplier, ObjFloatConsumer<R> accumulator)`
`abstract <R> R`	`collect(Supplier<R> supplier, ObjFloatConsumer<R> accumulator, BiConsumer<R,R> combiner)` Performs a mutable reduction operation on the elements of this stream.
`static FloatStream`	`concat(java.util.Collection<? extends FloatStream> c)`
`static FloatStream`	`concat(float[]... a)`
`static FloatStream`	`concat(FloatIterator... a)`
`static FloatStream`	`concat(FloatStream... a)`
`static FloatStream`	`empty()`
`OT`	`findAny(P predicate)` Returns an `Optional` describing some element of the stream, or an empty `Optional` if the stream is empty.
`abstract FloatStream`	`flatArray(FloatFunction<float[]> mapper)`
`abstract FloatStream`	`flatMap(FloatFunction<? extends FloatStream> 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.
`abstract DoubleStream`	`flatMapToDouble(FloatFunction<? extends DoubleStream> mapper)`
`abstract IntStream`	`flatMapToInt(FloatFunction<? extends IntStream> mapper)`
`abstract LongStream`	`flatMapToLong(FloatFunction<? extends LongStream> mapper)`
`abstract <T> Stream<T>`	`flatMapToObj(FloatFunction<? extends Stream<T>> mapper)`
`static FloatStream`	`generate(FloatSupplier s)`
`abstract OptionalFloat`	`head()` Head and tail should be used by pair.
`abstract FloatStream`	`head2()` Head2 and tail2 should be used by pair.
`abstract Pair<OptionalFloat,FloatStream>`	`headAndTail()`
`abstract Pair<FloatStream,OptionalFloat>`	`headAndTail2()`
`boolean`	`isParallel()` Returns whether this stream, if a terminal operation were to be executed, would execute in parallel.
`static FloatStream`	`iterate(float seed, FloatPredicate hasNext, FloatUnaryOperator f)`
`static FloatStream`	`iterate(float seed, FloatUnaryOperator f)`
`static FloatStream`	`iterate(float seed, Supplier<java.lang.Boolean> hasNext, FloatUnaryOperator f)`
`static FloatStream`	`iterate(Supplier<java.lang.Boolean> hasNext, FloatSupplier next)`
`FloatIterator`	`iterator()` Returns an iterator for the elements of this stream.
`abstract OptionalFloat`	`kthLargest(int k)`
`abstract FloatStream`	`map(FloatUnaryOperator mapper)` Returns a stream consisting of the results of applying the given function to the elements of this stream.
`abstract DoubleStream`	`mapToDouble(FloatToDoubleFunction mapper)` Returns a `DoubleStream` consisting of the results of applying the given function to the elements of this stream.
`abstract IntStream`	`mapToInt(FloatToIntFunction mapper)` Returns an `IntStream` consisting of the results of applying the given function to the elements of this stream.
`abstract LongStream`	`mapToLong(FloatToLongFunction mapper)` Returns a `LongStream` consisting of the results of applying the given function to the elements of this stream.
`abstract <U> Stream<U>`	`mapToObj(FloatFunction<? extends U> mapper)` Returns an object-valued `Stream` consisting of the results of applying the given function to the elements of this stream.
`abstract OptionalFloat`	`max()` Returns an `OptionalFloat` describing the maximum element of this stream, or an empty OptionalFloat if this stream is empty.
`int`	`maxThreadNum()` Return the underlying `maxThreadNum` if the stream is parallel, otherwise `1` is returned.
`S`	`maxThreadNum(int maxThreadNum)` Returns a parallel stream with the specified `maxThreadNum` .
`static FloatStream`	`merge(java.util.Collection<? extends FloatStream> c, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static FloatStream`	`merge(float[] a, float[] b, float[] c, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static FloatStream`	`merge(float[] a, float[] b, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static FloatStream`	`merge(FloatIterator a, FloatIterator b, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static FloatStream`	`merge(FloatIterator a, FloatIterator b, FloatIterator c, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`abstract FloatStream`	`merge(FloatStream b, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static FloatStream`	`merge(FloatStream a, FloatStream b, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static FloatStream`	`merge(FloatStream a, FloatStream b, FloatStream c, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`abstract OptionalFloat`	`min()` Returns an `OptionalFloat` describing the minimum element of this stream, or an empty OptionalFloat if this stream is empty.
`static FloatStream`	`of(float... a)`
`static FloatStream`	`of(float[][] a)`
`static FloatStream`	`of(float[][][] a)`
`static FloatStream`	`of(float[] a, int startIndex, int endIndex)`
`static FloatStream`	`of(FloatIterator iterator)`
`static FloatStream`	`of(Supplier<FloatList> supplier)` Lazy evaluation.
`S`	`parallel()` Returns an equivalent stream that is parallel.
`S`	`parallel(BaseStream.Splitor splitor)` Returns an equivalent stream that is parallel.
`S`	`parallel(int maxThreadNum)` Returns an equivalent stream that is parallel.
`static FloatStream`	`parallelMerge(java.util.Collection<? extends FloatStream> c, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static FloatStream`	`parallelMerge(java.util.Collection<? extends FloatStream> c, FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector, int maxThreadNum)`
`void`	`println()`
`static FloatStream`	`random()`
`abstract OptionalFloat`	`reduce(FloatBinaryOperator op)` Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an `OptionalFloat` describing the reduced value, if any.
`abstract float`	`reduce(float identity, FloatBinaryOperator op)` Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
`static FloatStream`	`repeat(float element, long n)`
`abstract FloatStream`	`scan(FloatBiFunction<java.lang.Float> accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to an initial element `seed` and next element of the current stream.
`abstract FloatStream`	`scan(float seed, FloatBiFunction<java.lang.Float> accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to an initial element `seed` and next element of the current stream.
`S`	`sequential()` Returns an equivalent stream that is sequential.
`Stream<S>`	`sliding(int windowSize)`
`Stream<PL>`	`slidingToList(int windowSize)`
`BaseStream.Splitor`	`splitor()` Return the underlying `splitor` if the stream is parallel, otherwise the default value `splitor.ITERATOR` is returned.
`S`	`splitor(BaseStream.Splitor splitor)` Returns a parallel stream with the specified `splitor` .
`abstract double`	`sum()` Returns the sum of elements in this stream.
`abstract com.landawn.abacus.util.FloatSummaryStatistics`	`summarize()`
`abstract Pair<com.landawn.abacus.util.FloatSummaryStatistics,Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Float>>>`	`summarize2()`
`abstract FloatStream`	`tail()` Head and tail should be used by pair.
`abstract OptionalFloat`	`tail2()` Head2 and tail2 should be used by pair.
`abstract FloatList`	`toFloatList()`
`abstract <K,A,D> java.util.Map<K,D>`	`toMap(FloatFunction<? extends K> classifier, Collector<java.lang.Float,A,D> downstream)`
`abstract <K,A,D,M extends java.util.Map<K,D>> M`	`toMap(FloatFunction<? extends K> classifier, Collector<java.lang.Float,A,D> downstream, Supplier<M> mapFactory)`
`abstract <K,U> java.util.Map<K,U>`	`toMap(FloatFunction<? extends K> keyExtractor, FloatFunction<? extends U> valueMapper)`
`abstract <K,U> java.util.Map<K,U>`	`toMap(FloatFunction<? extends K> keyExtractor, FloatFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction)`
`abstract <K,U,M extends java.util.Map<K,U>> M`	`toMap(FloatFunction<? extends K> keyExtractor, FloatFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)`
`abstract <K,U,M extends java.util.Map<K,U>> M`	`toMap(FloatFunction<? extends K> keyExtractor, FloatFunction<? extends U> valueMapper, Supplier<M> mapFactory)`
`abstract FloatMatrix`	`toMatrix()`
`abstract FloatStream`	`top(int n)` This method only run sequentially, even in parallel stream.
`abstract FloatStream`	`top(int n, java.util.Comparator<? super java.lang.Float> comparator)` This method only run sequentially, even in parallel stream.
`Try<S>`	`tried()`
`static FloatStream`	`zip(java.util.Collection<? extends FloatStream> c, float[] valuesForNone, FloatNFunction<java.lang.Float> zipFunction)` Zip together the iterators until all of them runs out of values.
`static FloatStream`	`zip(java.util.Collection<? extends FloatStream> c, FloatNFunction<java.lang.Float> zipFunction)` Zip together the iterators until one of them runs out of values.
`static FloatStream`	`zip(float[] a, float[] b, float[] c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<java.lang.Float> zipFunction)` Zip together the "a", "b" and "c" iterators until all of them runs out of values.
`static FloatStream`	`zip(float[] a, float[] b, float[] c, FloatTriFunction<java.lang.Float> zipFunction)` Zip together the "a", "b" and "c" arrays until one of them runs out of values.
`static FloatStream`	`zip(float[] a, float[] b, FloatBiFunction<java.lang.Float> zipFunction)` Zip together the "a" and "b" arrays until one of them runs out of values.
`static FloatStream`	`zip(float[] a, float[] b, float valueForNoneA, float valueForNoneB, FloatBiFunction<java.lang.Float> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static FloatStream`	`zip(FloatIterator a, FloatIterator b, FloatBiFunction<java.lang.Float> zipFunction)` Zip together the "a" and "b" iterators until one of them runs out of values.
`static FloatStream`	`zip(FloatIterator a, FloatIterator b, float valueForNoneA, float valueForNoneB, FloatBiFunction<java.lang.Float> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static FloatStream`	`zip(FloatIterator a, FloatIterator b, FloatIterator c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<java.lang.Float> zipFunction)` Zip together the "a", "b" and "c" iterators until all of them runs out of values.
`static FloatStream`	`zip(FloatIterator a, FloatIterator b, FloatIterator c, FloatTriFunction<java.lang.Float> zipFunction)` Zip together the "a", "b" and "c" iterators until one of them runs out of values.
`static FloatStream`	`zip(FloatStream a, FloatStream b, FloatBiFunction<java.lang.Float> zipFunction)` Zip together the "a" and "b" streams until one of them runs out of values.
`static FloatStream`	`zip(FloatStream a, FloatStream b, float valueForNoneA, float valueForNoneB, FloatBiFunction<java.lang.Float> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static FloatStream`	`zip(FloatStream a, FloatStream b, FloatStream c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<java.lang.Float> zipFunction)` Zip together the "a", "b" and "c" iterators until all of them runs out of values.
`static FloatStream`	`zip(FloatStream a, FloatStream b, FloatStream c, FloatTriFunction<java.lang.Float> zipFunction)` Zip together the "a", "b" and "c" streams until one of them runs out of values.
`abstract FloatStream`	`zipWith(FloatStream b, FloatBiFunction<java.lang.Float> zipFunction)`
`abstract FloatStream`	`zipWith(FloatStream b, float valueForNoneA, float valueForNoneB, FloatBiFunction<java.lang.Float> zipFunction)`
`abstract FloatStream`	`zipWith(FloatStream b, FloatStream c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTriFunction<java.lang.Float> zipFunction)`
`abstract FloatStream`	`zipWith(FloatStream b, FloatStream c, FloatTriFunction<java.lang.Float> zipFunction)`

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

Methods inherited from interface com.landawn.abacus.util.stream.BaseStream
allMatch, anyMatch, append, cached, count, difference, distinct, dropWhile, filter, findFirst, findFirstOrLast, findLast, first, forEach, indexed, intersection, join, join, last, limit, noneMatch, onClose, parallel, peek, percentiles, prepend, remove, removeIf, removeIf, removeWhile, reversed, reverseSorted, rotated, shuffled, shuffled, skip, sliding, slidingToList, sorted, split, split, split, splitAt, splitBy, splitToList, splitToList, splitToList, step, symmetricDifference, takeWhile, toArray, toList, toList, toLongMultiset, toLongMultiset, toMultiset, toMultiset, toSet, toSet

- Method Detail
  - map
```
public abstract FloatStream map(FloatUnaryOperator mapper)
```
    Returns a stream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToInt
```
public abstract IntStream mapToInt(FloatToIntFunction mapper)
```
    Returns an IntStream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToLong
```
public abstract LongStream mapToLong(FloatToLongFunction mapper)
```
    Returns a LongStream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToDouble
```
public abstract DoubleStream mapToDouble(FloatToDoubleFunction mapper)
```
    Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToObj
```
public abstract <U> Stream<U> mapToObj(FloatFunction<? extends U> mapper)
```
    Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Type Parameters:
    
    U - the element type of the new stream
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - flatMap
```
public abstract FloatStream flatMap(FloatFunction<? extends FloatStream> 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 - a non-interfering, stateless function to apply to each element which produces a FloatStream of new values
    
    Returns:
    
    the new stream
    
    See Also:
    
    Stream.flatMap(Function)
  - flatArray
```
public abstract FloatStream flatArray(FloatFunction<float[]> mapper)
```
  - flatMapToInt
```
public abstract IntStream flatMapToInt(FloatFunction<? extends IntStream> mapper)
```
  - flatMapToLong
```
public abstract LongStream flatMapToLong(FloatFunction<? extends LongStream> mapper)
```
  - flatMapToDouble
```
public abstract DoubleStream flatMapToDouble(FloatFunction<? extends DoubleStream> mapper)
```
  - flatMapToObj
```
public abstract <T> Stream<T> flatMapToObj(FloatFunction<? extends Stream<T>> mapper)
```
  - collapse
```
public abstract FloatStream collapse(FloatBiPredicate collapsible,
                                     FloatBiFunction<java.lang.Float> mergeFunction)
```
    Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
    This method only run sequentially, even in parallel stream.
    
    Parameters:
    
    collapsible -
    
    mergeFunction -
    
    Returns:
  - scan
```
public abstract FloatStream scan(FloatBiFunction<java.lang.Float> accumulator)
```
    Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream. Produces a Stream consisting of seed, acc(seed, value1), acc(acc(seed, value1), value2), etc.
    This is an intermediate operation.
    Example:
```
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [1, 3, 6, 10, 15]
 
```
    This method only run sequentially, even in parallel stream.
    Parameters:
    
    accumulator - the accumulation function
    
    Returns:
    
    the new stream which has the extract same size as this stream.
  - scan
```
public abstract FloatStream scan(float seed,
                                 FloatBiFunction<java.lang.Float> accumulator)
```
    Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream. Produces a Stream consisting of seed, acc(seed, value1), acc(acc(seed, value1), value2), etc.
    This is an intermediate operation.
    Example:
```
 seed:10
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [11, 13, 16, 20, 25]
 
```
    This method only run sequentially, even in parallel stream.
    Parameters:
    
    seed - the initial value. it's only used once by accumulator to calculate the fist element in the returned stream. It will be ignored if this stream is empty and won't be the first element of the returned stream.
    
    accumulator - the accumulation function
    
    Returns:
    
    the new stream which has the extract same size as this stream.
  - top
```
public abstract FloatStream top(int n)
```
    This method only run sequentially, even in parallel stream.
    
    Parameters:
    
    n -
    
    Returns:
  - top
```
public abstract FloatStream top(int n,
                                java.util.Comparator<? super java.lang.Float> comparator)
```
    This method only run sequentially, even in parallel stream.
    
    Parameters:
    
    n -
    
    Returns:
  - toFloatList
```
public abstract FloatList toFloatList()
```
  - toMap
```
public abstract <K,U> java.util.Map<K,U> toMap(FloatFunction<? extends K> keyExtractor,
                                               FloatFunction<? extends U> valueMapper)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function)
  - toMap
```
public abstract <K,U,M extends java.util.Map<K,U>> M toMap(FloatFunction<? extends K> keyExtractor,
                                                           FloatFunction<? extends U> valueMapper,
                                                           Supplier<M> mapFactory)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    mapFactory -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function, Supplier)
  - toMap
```
public abstract <K,U> java.util.Map<K,U> toMap(FloatFunction<? extends K> keyExtractor,
                                               FloatFunction<? extends U> valueMapper,
                                               BinaryOperator<U> mergeFunction)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    mergeFunction -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function, BinaryOperator)
  - toMap
```
public abstract <K,U,M extends java.util.Map<K,U>> M toMap(FloatFunction<? extends K> keyExtractor,
                                                           FloatFunction<? extends U> valueMapper,
                                                           BinaryOperator<U> mergeFunction,
                                                           Supplier<M> mapFactory)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    mergeFunction -
    
    mapFactory -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function, BinaryOperator, Supplier)
  - toMap
```
public abstract <K,A,D> java.util.Map<K,D> toMap(FloatFunction<? extends K> classifier,
                                                 Collector<java.lang.Float,A,D> downstream)
```
    Parameters:
    
    classifier -
    
    downstream -
    
    Returns:
    
    See Also:
    
    Collectors.groupingBy(Function, Collector)
  - toMap
```
public abstract <K,A,D,M extends java.util.Map<K,D>> M toMap(FloatFunction<? extends K> classifier,
                                                             Collector<java.lang.Float,A,D> downstream,
                                                             Supplier<M> mapFactory)
```
    Parameters:
    
    classifier -
    
    downstream -
    
    mapFactory -
    
    Returns:
    
    See Also:
    
    Collectors.groupingBy(Function, Collector, Supplier)
  - toMatrix
```
public abstract FloatMatrix toMatrix()
```
  - reduce
```
public abstract float reduce(float identity,
                             FloatBinaryOperator op)
```
    Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value. This is equivalent to:
```
     float result = identity;
     for (float element : this stream)
         result = accumulator.applyAsFloat(result, element)
     return result;
 
```
    but is not constrained to execute sequentially.
    The identity value must be an identity for the accumulator function. This means that for all x, accumulator.apply(identity, x) is equal to x. The accumulator function must be an associative function.
    This is a terminal operation.
    Parameters:
    
    identity - the identity value for the accumulating function
    
    op - an associative, non-interfering, stateless function for combining two values
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    sum(), min(), max(), average()
  - reduce
```
public abstract OptionalFloat reduce(FloatBinaryOperator op)
```
    Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalFloat describing the reduced value, if any. This is equivalent to:
```
     boolean foundAny = false;
     float result = null;
     for (float element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.applyAsFloat(result, element);
     }
     return foundAny ? OptionalFloat.of(result) : OptionalFloat.empty();
 
```
    but is not constrained to execute sequentially.
    The accumulator function must be an associative function.
    This is a terminal operation.
    Parameters:
    
    op - an associative, non-interfering, stateless function for combining two values
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    reduce(float, FloatBinaryOperator)
  - collect
```
public abstract <R> R collect(Supplier<R> supplier,
                              ObjFloatConsumer<R> accumulator,
                              BiConsumer<R,R> combiner)
```
    Performs a mutable reduction operation on the elements of this stream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:
```
     R result = supplier.get();
     for (float element : this stream)
         accumulator.accept(result, element);
     return result;
 
```
    Like reduce(float, FloatBinaryOperator), collect operations can be parallelized without requiring additional synchronization.
    This is a terminal operation.
    Type Parameters:
    
    R - type of the result
    
    Parameters:
    
    supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.
    
    accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result
    
    combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    Stream.collect(Supplier, BiConsumer, BiConsumer)
  - collect
```
public abstract <R> R collect(Supplier<R> supplier,
                              ObjFloatConsumer<R> accumulator)
```
    Parameters:
    
    supplier -
    
    accumulator -
    
    Returns:
  - head
```
public abstract OptionalFloat head()
```
    Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() and tail() are called.
    
    Returns:
  - tail
```
public abstract FloatStream tail()
```
    Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() and tail() are called.
    
    Returns:
  - head2
```
public abstract FloatStream head2()
```
    Head2 and tail2 should be used by pair. Don't call any other methods with this stream after head2() and tail2() are called.
    
    Returns:
  - tail2
```
public abstract OptionalFloat tail2()
```
    Head2 and tail2 should be used by pair. Don't call any other methods with this stream after head2() and tail2() are called.
    
    Returns:
  - headAndTail
```
public abstract Pair<OptionalFloat,FloatStream> headAndTail()
```
  - headAndTail2
```
public abstract Pair<FloatStream,OptionalFloat> headAndTail2()
```
  - min
```
public abstract OptionalFloat min()
```
    Returns an OptionalFloat describing the minimum element of this stream, or an empty OptionalFloat if this stream is empty. The minimum element will be Float.NaN if any stream element was NaN. Unlike the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. This is a special case of a reduction and is equivalent to:
```
     return reduce(Float::min);
 
```
    This is a terminal operation.
    Returns:
    
    an OptionalFloat containing the minimum element of this stream, or an empty optional if the stream is empty
  - max
```
public abstract OptionalFloat max()
```
    Returns an OptionalFloat describing the maximum element of this stream, or an empty OptionalFloat if this stream is empty. The maximum element will be Float.NaN if any stream element was NaN. Unlike the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. This is a special case of a reduction and is equivalent to:
```
     return reduce(Float::max);
 
```
    This is a terminal operation.
    Returns:
    
    an OptionalFloat containing the maximum element of this stream, or an empty optional if the stream is empty
  - kthLargest
```
public abstract OptionalFloat kthLargest(int k)
```
    Parameters:
    
    k -
    
    Returns:
    
    OptionalByte.empty() if there is no element or count less than k, otherwise the kth largest element.
  - sum
```
public abstract double sum()
```
    Returns the sum of elements in this stream. Summation is a special case of a reduction. If floating-point summation were exact, this method would be equivalent to:
```
     return reduce(0, Float::sum);
 
```
    However, since floating-point summation is not exact, the above code is not necessarily equivalent to the summation computation done by this method.
    If any stream element is a NaN or the sum is at any point a NaN then the sum will be NaN. The value of a floating-point sum is a function both of the input values as well as the order of addition operations. The order of addition operations of this method is intentionally not defined to allow for implementation flexibility to improve the speed and accuracy of the computed result. In particular, this method may be implemented using compensated summation or other technique to reduce the error bound in the numerical sum compared to a simple summation of float values.
    This is a terminal operation.
    Returns:
    
    the sum of elements in this stream
  - average
```
public abstract OptionalDouble average()
```
    Returns an OptionalFloat describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty. If any recorded value is a NaN or the sum is at any point a NaN then the average will be NaN.
    The average returned can vary depending upon the order in which values are recorded. This method may be implemented using compensated summation or other technique to reduce the error bound in the numerical sum used to compute the average.
    The average is a special case of a reduction.
    This is a terminal operation.
    
    Returns:
    
    an OptionalFloat containing the average element of this stream, or an empty optional if the stream is empty
  - summarize
```
public abstract com.landawn.abacus.util.FloatSummaryStatistics summarize()
```
  - summarize2
```
public abstract Pair<com.landawn.abacus.util.FloatSummaryStatistics,Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Float>>> summarize2()
```
  - merge
```
public abstract FloatStream merge(FloatStream b,
                                  FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    b -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - zipWith
```
public abstract FloatStream zipWith(FloatStream b,
                                    FloatBiFunction<java.lang.Float> zipFunction)
```
  - zipWith
```
public abstract FloatStream zipWith(FloatStream b,
                                    FloatStream c,
                                    FloatTriFunction<java.lang.Float> zipFunction)
```
  - zipWith
```
public abstract FloatStream zipWith(FloatStream b,
                                    float valueForNoneA,
                                    float valueForNoneB,
                                    FloatBiFunction<java.lang.Float> zipFunction)
```
  - zipWith
```
public abstract FloatStream zipWith(FloatStream b,
                                    FloatStream c,
                                    float valueForNoneA,
                                    float valueForNoneB,
                                    float valueForNoneC,
                                    FloatTriFunction<java.lang.Float> zipFunction)
```
  - asDoubleStream
```
public abstract DoubleStream asDoubleStream()
```
    Returns a DoubleStream consisting of the elements of this stream, converted to double.
    This is an intermediate operation.
    
    Returns:
    
    a DoubleStream consisting of the elements of this stream, converted to double
  - boxed
```
public abstract Stream<java.lang.Float> boxed()
```
    Returns a Stream consisting of the elements of this stream, boxed to Float.
    This is an intermediate operation.
    
    Returns:
    
    a Stream consistent of the elements of this stream, each boxed to a Float
  - iterator
```
public FloatIterator iterator()
```
    Description copied from interface: BaseStream
    
    Returns an iterator for the elements of this stream.
    
    Returns:
    
    the element iterator for this stream
  - __
```
public <R> R __(Function<? super FloatStream,R> transfer)
```
  - empty
```
public static FloatStream empty()
```
  - of
```
@SafeVarargs
public static FloatStream of(float... a)
```
  - of
```
public static FloatStream of(float[] a,
                             int startIndex,
                             int endIndex)
```
  - of
```
public static FloatStream of(float[][] a)
```
  - of
```
public static FloatStream of(float[][][] a)
```
  - of
```
public static FloatStream of(FloatIterator iterator)
```
  - of
```
public static FloatStream of(Supplier<FloatList> supplier)
```
    Lazy evaluation.
    
    Parameters:
    
    supplier -
    
    Returns:
  - repeat
```
public static FloatStream repeat(float element,
                                 long n)
```
  - random
```
public static FloatStream random()
```
  - iterate
```
public static FloatStream iterate(Supplier<java.lang.Boolean> hasNext,
                                  FloatSupplier next)
```
  - iterate
```
public static FloatStream iterate(float seed,
                                  Supplier<java.lang.Boolean> hasNext,
                                  FloatUnaryOperator f)
```
  - iterate
```
public static FloatStream iterate(float seed,
                                  FloatPredicate hasNext,
                                  FloatUnaryOperator f)
```
    Parameters:
    
    seed -
    
    hasNext - test if has next by hasNext.test(seed) for first time and hasNext.test(f.apply(previous)) for remaining.
    
    f -
    
    Returns:
  - iterate
```
public static FloatStream iterate(float seed,
                                  FloatUnaryOperator f)
```
  - generate
```
public static FloatStream generate(FloatSupplier s)
```
  - concat
```
@SafeVarargs
public static FloatStream concat(float[]... a)
```
  - concat
```
@SafeVarargs
public static FloatStream concat(FloatIterator... a)
```
  - concat
```
@SafeVarargs
public static FloatStream concat(FloatStream... a)
```
  - concat
```
public static FloatStream concat(java.util.Collection<? extends FloatStream> c)
```
  - zip
```
public static FloatStream zip(float[] a,
                              float[] b,
                              FloatBiFunction<java.lang.Float> zipFunction)
```
    Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static FloatStream zip(float[] a,
                              float[] b,
                              float[] c,
                              FloatTriFunction<java.lang.Float> zipFunction)
```
    Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static FloatStream zip(FloatIterator a,
                              FloatIterator b,
                              FloatBiFunction<java.lang.Float> zipFunction)
```
    Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static FloatStream zip(FloatIterator a,
                              FloatIterator b,
                              FloatIterator c,
                              FloatTriFunction<java.lang.Float> zipFunction)
```
    Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static FloatStream zip(FloatStream a,
                              FloatStream b,
                              FloatBiFunction<java.lang.Float> zipFunction)
```
    Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static FloatStream zip(FloatStream a,
                              FloatStream b,
                              FloatStream c,
                              FloatTriFunction<java.lang.Float> zipFunction)
```
    Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static FloatStream zip(java.util.Collection<? extends FloatStream> c,
                              FloatNFunction<java.lang.Float> zipFunction)
```
    Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    c -
    
    zipFunction -
    
    Returns:
  - zip
```
public static FloatStream zip(float[] a,
                              float[] b,
                              float valueForNoneA,
                              float valueForNoneB,
                              FloatBiFunction<java.lang.Float> zipFunction)
```
    Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    valueForNoneA - value to fill if "a" runs out of values first.
    
    valueForNoneB - value to fill if "b" runs out of values first.
    
    zipFunction -
    
    Returns:
  - zip
```
public static FloatStream zip(float[] a,
                              float[] b,
                              float[] c,
                              float valueForNoneA,
                              float valueForNoneB,
                              float valueForNoneC,
                              FloatTriFunction<java.lang.Float> zipFunction)
```
    Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    c -
    
    valueForNoneA - value to fill if "a" runs out of values.
    
    valueForNoneB - value to fill if "b" runs out of values.
    
    valueForNoneC - value to fill if "c" runs out of values.
    
    zipFunction -
    
    Returns:
  - zip
```
public static FloatStream zip(FloatIterator a,
                              FloatIterator b,
                              float valueForNoneA,
                              float valueForNoneB,
                              FloatBiFunction<java.lang.Float> zipFunction)
```
    Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    valueForNoneA - value to fill if "a" runs out of values first.
    
    valueForNoneB - value to fill if "b" runs out of values first.
    
    zipFunction -
    
    Returns:
  - zip
```
public static FloatStream zip(FloatIterator a,
                              FloatIterator b,
                              FloatIterator c,
                              float valueForNoneA,
                              float valueForNoneB,
                              float valueForNoneC,
                              FloatTriFunction<java.lang.Float> zipFunction)
```
    Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    c -
    
    valueForNoneA - value to fill if "a" runs out of values.
    
    valueForNoneB - value to fill if "b" runs out of values.
    
    valueForNoneC - value to fill if "c" runs out of values.
    
    zipFunction -
    
    Returns:
  - zip
```
public static FloatStream zip(FloatStream a,
                              FloatStream b,
                              float valueForNoneA,
                              float valueForNoneB,
                              FloatBiFunction<java.lang.Float> zipFunction)
```
    Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    valueForNoneA - value to fill if "a" runs out of values first.
    
    valueForNoneB - value to fill if "b" runs out of values first.
    
    zipFunction -
    
    Returns:
  - zip
```
public static FloatStream zip(FloatStream a,
                              FloatStream b,
                              FloatStream c,
                              float valueForNoneA,
                              float valueForNoneB,
                              float valueForNoneC,
                              FloatTriFunction<java.lang.Float> zipFunction)
```
    Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    c -
    
    valueForNoneA - value to fill if "a" runs out of values.
    
    valueForNoneB - value to fill if "b" runs out of values.
    
    valueForNoneC - value to fill if "c" runs out of values.
    
    zipFunction -
    
    Returns:
  - zip
```
public static FloatStream zip(java.util.Collection<? extends FloatStream> c,
                              float[] valuesForNone,
                              FloatNFunction<java.lang.Float> zipFunction)
```
    Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    c -
    
    valuesForNone - value to fill for any iterator runs out of values.
    
    zipFunction -
    
    Returns:
  - merge
```
public static FloatStream merge(float[] a,
                                float[] b,
                                FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static FloatStream merge(float[] a,
                                float[] b,
                                float[] c,
                                FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static FloatStream merge(FloatIterator a,
                                FloatIterator b,
                                FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static FloatStream merge(FloatIterator a,
                                FloatIterator b,
                                FloatIterator c,
                                FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static FloatStream merge(FloatStream a,
                                FloatStream b,
                                FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static FloatStream merge(FloatStream a,
                                FloatStream b,
                                FloatStream c,
                                FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static FloatStream merge(java.util.Collection<? extends FloatStream> c,
                                FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - parallelMerge
```
public static FloatStream parallelMerge(java.util.Collection<? extends FloatStream> c,
                                        FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - parallelMerge
```
public static FloatStream parallelMerge(java.util.Collection<? extends FloatStream> c,
                                        FloatBiFunction<com.landawn.abacus.util.Nth> nextSelector,
                                        int maxThreadNum)
```
    Parameters:
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    maxThreadNum -
    
    Returns:
  - carry
```
public S carry(C action)
```
    Description copied from interface: BaseStream
    
    Same as peek
    
    Specified by:
    
    carry in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.peek(Object)
  - findAny
```
public OT findAny(P predicate)
```
    Description copied from interface: BaseStream
    
    Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty.
    This is a short-circuiting terminal operation.
    The behavior of this operation is explicitly nondeterministic; it is free to select any element in the stream. This is to allow for maximal performance in parallel operations; the cost is that multiple invocations on the same source may not return the same result. (If a stable result is desired, use #findFirst() instead.)
    
    Specified by:
    
    findAny in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    an Optional describing some element of this stream, or an empty Optional if the stream is empty
    
    See Also:
    
    #findFirst()
  - sliding
```
public Stream<S> sliding(int windowSize)
```
    Specified by:
    
    sliding in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.sliding(int, int)
  - slidingToList
```
public Stream<PL> slidingToList(int windowSize)
```
    Specified by:
    
    slidingToList in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.sliding(int, int)
  - println
```
public void println()
```
    Specified by:
    
    println in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
  - isParallel
```
public boolean isParallel()
```
    Description copied from interface: BaseStream
    
    Returns whether this stream, if a terminal operation were to be executed, would execute in parallel. Calling this method after invoking an terminal stream operation method may yield unpredictable results.
    
    Specified by:
    
    isParallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    true if this stream would execute in parallel if executed
  - sequential
```
public S sequential()
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is sequential. May return itself, either because the stream was already sequential, or because the underlying stream state was modified to be sequential.
    
    Specified by:
    
    sequential in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    a sequential stream
  - parallel
```
public S parallel()
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is parallel. May return itself if the stream was already parallel. Any parallel should be closed by try-catch or call tried before last step.
    
    Specified by:
    
    parallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    a parallel stream
    
    See Also:
    
    BaseStream.parallel(int, Splitor)
  - parallel
```
public S parallel(int maxThreadNum)
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same maxThreadNum as the specified one.
    
    Specified by:
    
    parallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.parallel(int, Splitor)
  - parallel
```
public S parallel(BaseStream.Splitor splitor)
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same splitor as the specified one.
    
    Specified by:
    
    parallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.parallel(int, Splitor)
  - maxThreadNum
```
public int maxThreadNum()
```
    Description copied from interface: BaseStream
    
    Return the underlying maxThreadNum if the stream is parallel, otherwise 1 is returned.
    
    Specified by:
    
    maxThreadNum in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - maxThreadNum
```
public S maxThreadNum(int maxThreadNum)
```
    Description copied from interface: BaseStream
    
    Returns a parallel stream with the specified maxThreadNum . Or return itself, either because the stream was already parallel with same maxThreadNum, or because it's a sequential stream.
    
    Specified by:
    
    maxThreadNum in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - splitor
```
public BaseStream.Splitor splitor()
```
    Description copied from interface: BaseStream
    
    Return the underlying splitor if the stream is parallel, otherwise the default value splitor.ITERATOR is returned.
    
    Specified by:
    
    splitor in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - splitor
```
public S splitor(BaseStream.Splitor splitor)
```
    Description copied from interface: BaseStream
    
    Returns a parallel stream with the specified splitor . Or return itself, either because the stream was already parallel with same splitor, or because it's a sequential stream.
    
    Specified by:
    
    splitor in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - tried
```
public Try<S> tried()
```
    Specified by:
    
    tried in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
  - close
```
public void close()
```
    Description copied from interface: BaseStream
    
    Closes this stream, causing all close handlers for this stream pipeline to be called.
    
    Specified by:
    
    close in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    See Also:
    
    AutoCloseable.close()

Class FloatStream

Nested Class Summary

Nested classes/interfaces inherited from interface com.landawn.abacus.util.stream.BaseStream

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.landawn.abacus.util.stream.BaseStream

Method Detail

map

mapToInt

mapToLong

mapToDouble

mapToObj

flatMap

flatArray

flatMapToInt

flatMapToLong

flatMapToDouble

flatMapToObj

collapse

scan

scan

top

top

toFloatList

toMap

toMap

toMap

toMap

toMap

toMap

toMatrix

reduce

reduce

collect

collect

head

tail

head2

tail2

headAndTail

headAndTail2

min

max

kthLargest

sum

average

summarize

summarize2

merge

zipWith

zipWith

zipWith

zipWith

asDoubleStream

boxed

iterator

__

empty

of

of

of

of

of

of

repeat

random

iterate

iterate

iterate

iterate

generate

concat

concat

concat

concat

zip

zip

zip

zip

zip