LongStream (abacus API Documentation)

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

All Implemented Interfaces:

BaseStream<java.lang.Long,long[],LongPredicate,LongConsumer,LongList,OptionalLong,com.landawn.abacus.util.IndexedLong,LongIterator,LongStream>, java.lang.AutoCloseable

Direct Known Subclasses:

LongStream.LongStreamEx
```
public abstract class LongStream
extends java.lang.Object
```
Note: It's copied from OpenJDK at: http://hg.openjdk.java.net/jdk8u/hs-dev/jdk
A sequence of primitive long-valued elements supporting sequential and parallel aggregate operations. This is the long primitive specialization of Stream.
The following example illustrates an aggregate operation using Stream and LongStream, computing the sum of the weights of the red widgets:
```
     long sum = widgets.stream()
                       .filter(w -> w.getColor() == RED)
                       .mapToLong(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
Modifier and Type Class and Description

static class LongStream.LongStreamEx
- Nested classes/interfaces inherited from interface com.landawn.abacus.util.stream.BaseStream
  BaseStream.Splitor

Nested Classes
Modifier and Type	Class and Description
`static class`	`LongStream.LongStreamEx`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`<R> R`	`__(Function<? super LongStream,R> transfer)`
`abstract <E extends java.lang.Exception> boolean`	`allMatch(Try.LongPredicate<E> predicate)`
`abstract <E extends java.lang.Exception> boolean`	`anyMatch(Try.LongPredicate<E> predicate)`
`abstract DoubleStream`	`asDoubleStream()` Returns a `DoubleStream` consisting of the elements of this stream, converted to `double`.
`abstract FloatStream`	`asFloatStream()` Returns a `FloatStream` consisting of the elements of this stream, converted to `double`.
`abstract OptionalDouble`	`average()` Returns an `OptionalDouble` describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty.
`abstract Stream<java.lang.Long>`	`boxed()` Returns a `Stream` consisting of the elements of this stream, each boxed to a `Long`.
`S`	`carry(C action)` Same as `peek`
`void`	`close()` Closes this stream, causing all close handlers for this stream pipeline to be called.
`abstract LongStream`	`collapse(LongBiPredicate collapsible, LongBiFunction<java.lang.Long> mergeFunction)`
`abstract <R> R`	`collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator)`
`abstract <R> R`	`collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R,R> combiner)` Performs a mutable reduction operation on the elements of this stream.
`static LongStream`	`concat(java.util.Collection<? extends LongStream> c)`
`static LongStream`	`concat(long[]... a)`
`static LongStream`	`concat(LongIterator... a)`
`static LongStream`	`concat(LongStream... a)`
`static LongStream`	`empty()`
`abstract <E extends java.lang.Exception> OptionalLong`	`findAny(Try.LongPredicate<E> predicate)`
`abstract <E extends java.lang.Exception> OptionalLong`	`findFirst(Try.LongPredicate<E> predicate)`
`abstract <E extends java.lang.Exception,E2 extends java.lang.Exception> OptionalLong`	`findFirstOrLast(Try.LongPredicate<E> predicateForFirst, Try.LongPredicate<E> predicateForLast)`
`abstract <E extends java.lang.Exception> OptionalLong`	`findLast(Try.LongPredicate<E> predicate)`
`abstract LongStream`	`flatMap(LongFunction<? extends LongStream> mapper)` Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
`abstract DoubleStream`	`flatMapToDouble(LongFunction<? extends DoubleStream> mapper)`
`abstract FloatStream`	`flatMapToFloat(LongFunction<? extends FloatStream> mapper)`
`abstract IntStream`	`flatMapToInt(LongFunction<? extends IntStream> mapper)`
`abstract <T> Stream<T>`	`flatMapToObj(LongFunction<? extends Stream<T>> mapper)`
`abstract LongStream`	`flattMap(LongFunction<long[]> mapper)`
`abstract <T> Stream<T>`	`flattMapToObj(LongFunction<? extends java.util.Collection<T>> mapper)`
`abstract <E extends java.lang.Exception> void`	`forEach(Try.LongConsumer<E> action)`
`static LongStream`	`generate(LongSupplier s)`
`abstract OptionalLong`	`head()` Head and tail should be used by pair.
`abstract Pair<OptionalLong,LongStream>`	`headAndTail()`
`abstract Pair<LongStream,OptionalLong>`	`headAndTaill()`
`abstract LongStream`	`headd()` Head2 and tail2 should be used by pair.
`static LongStream`	`interval(long intervalInMillis)`
`static LongStream`	`interval(long delayInMillis, long intervalInMillis)` Generates the long value by the specified period: [0, 1, 2, 3...]
`static LongStream`	`interval(long delay, long interval, java.util.concurrent.TimeUnit unit)` Generates the long value by the specified period: [0, 1, 2, 3...]
`boolean`	`isParallel()` Returns whether this stream, if a terminal operation were to be executed, would execute in parallel.
`static LongStream`	`iterate(BooleanSupplier hasNext, LongSupplier next)`
`static LongStream`	`iterate(long seed, BooleanSupplier hasNext, LongUnaryOperator f)`
`static LongStream`	`iterate(long seed, LongPredicate hasNext, LongUnaryOperator f)`
`static LongStream`	`iterate(long seed, LongUnaryOperator f)`
`LongIterator`	`iterator()` Returns an iterator for the elements of this stream.
`abstract OptionalLong`	`kthLargest(int k)`
`abstract LongStream`	`map(LongUnaryOperator mapper)` Returns a stream consisting of the results of applying the given function to the elements of this stream.
`abstract DoubleStream`	`mapToDouble(LongToDoubleFunction mapper)` Returns a `DoubleStream` consisting of the results of applying the given function to the elements of this stream.
`abstract FloatStream`	`mapToFloat(LongToFloatFunction mapper)` Returns a `FloatStream` consisting of the results of applying the given function to the elements of this stream.
`abstract IntStream`	`mapToInt(LongToIntFunction mapper)` Returns an `IntStream` consisting of the results of applying the given function to the elements of this stream.
`abstract <U> Stream<U>`	`mapToObj(LongFunction<? extends U> mapper)` Returns an object-valued `Stream` consisting of the results of applying the given function to the elements of this stream.
`abstract OptionalLong`	`max()` Returns an `OptionalLong` describing the maximum element of this stream, or an empty optional 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 LongStream`	`merge(java.util.Collection<? extends LongStream> c, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static LongStream`	`merge(long[] a, long[] b, long[] c, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static LongStream`	`merge(long[] a, long[] b, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static LongStream`	`merge(LongIterator a, LongIterator b, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static LongStream`	`merge(LongIterator a, LongIterator b, LongIterator c, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`abstract LongStream`	`merge(LongStream b, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static LongStream`	`merge(LongStream a, LongStream b, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static LongStream`	`merge(LongStream a, LongStream b, LongStream c, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`abstract OptionalLong`	`min()` Returns an `OptionalLong` describing the minimum element of this stream, or an empty optional if this stream is empty.
`abstract <E extends java.lang.Exception> boolean`	`noneMatch(Try.LongPredicate<E> predicate)`
`static LongStream`	`of(java.util.Collection<java.lang.Long> c)`
`static LongStream`	`of(long... a)`
`static LongStream`	`of(java.lang.Long[] a)`
`static LongStream`	`of(long[][] a)`
`static LongStream`	`of(long[][][] a)`
`static LongStream`	`of(long[] a, int startIndex, int endIndex)`
`static LongStream`	`of(java.lang.Long[] a, int startIndex, int endIndex)`
`static LongStream`	`of(LongIterator iterator)`
`static LongStream`	`of(java.util.stream.LongStream stream)`
`static LongStream`	`of(Supplier<LongList> 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 LongStream`	`parallelMerge(java.util.Collection<? extends LongStream> c, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static LongStream`	`parallelMerge(java.util.Collection<? extends LongStream> c, LongBiFunction<com.landawn.abacus.util.Nth> nextSelector, int maxThreadNum)`
`void`	`println()`
`static LongStream`	`random()`
`static LongStream`	`range(long startInclusive, long endExclusive)`
`static LongStream`	`range(long startInclusive, long endExclusive, long by)`
`static LongStream`	`rangeClosed(long startInclusive, long endInclusive)`
`static LongStream`	`rangeClosed(long startInclusive, long endInclusive, long by)`
`abstract OptionalLong`	`reduce(LongBinaryOperator op)` Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an `OptionalLong` describing the reduced value, if any.
`abstract long`	`reduce(long identity, LongBinaryOperator 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 LongStream`	`repeat(long element, long n)`
`abstract LongStream`	`scan(LongBiFunction<java.lang.Long> 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 LongStream`	`scan(long seed, LongBiFunction<java.lang.Long> 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.
`S`	`shuffled()` This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
`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 long`	`sum()` Returns the sum of elements in this stream.
`abstract LongSummaryStatistics`	`summarize()`
`abstract Pair<LongSummaryStatistics,Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Long>>>`	`summarizze()`
`abstract LongStream`	`tail()` Head and tail should be used by pair.
`abstract OptionalLong`	`taill()` Head2 and tail2 should be used by pair.
`ImmutableList<T>`	`toImmutableList()`
`ImmutableSet<T>`	`toImmutableSet()`
`abstract java.util.stream.LongStream`	`toJdkStream()`
`abstract LongList`	`toLongList()`
`abstract <K,A,D> java.util.Map<K,D>`	`toMap(LongFunction<? extends K> classifier, Collector<java.lang.Long,A,D> downstream)`
`abstract <K,A,D,M extends java.util.Map<K,D>> M`	`toMap(LongFunction<? extends K> classifier, Collector<java.lang.Long,A,D> downstream, Supplier<M> mapFactory)`
`abstract <K,U> java.util.Map<K,U>`	`toMap(LongFunction<? extends K> keyExtractor, LongFunction<? extends U> valueMapper)`
`abstract <K,U> java.util.Map<K,U>`	`toMap(LongFunction<? extends K> keyExtractor, LongFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction)`
`abstract <K,U,M extends java.util.Map<K,U>> M`	`toMap(LongFunction<? extends K> keyExtractor, LongFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)`
`abstract <K,U,M extends java.util.Map<K,U>> M`	`toMap(LongFunction<? extends K> keyExtractor, LongFunction<? extends U> valueMapper, Supplier<M> mapFactory)`
`abstract LongMatrix`	`toMatrix()`
`abstract LongStream`	`top(int n)` This method only run sequentially, even in parallel stream.
`abstract LongStream`	`top(int n, java.util.Comparator<? super java.lang.Long> comparator)` This method only run sequentially, even in parallel stream.
`Try<S>`	`tried()`
`static LongStream`	`zip(java.util.Collection<? extends LongStream> c, long[] valuesForNone, LongNFunction<java.lang.Long> zipFunction)` Zip together the iterators until all of them runs out of values.
`static LongStream`	`zip(java.util.Collection<? extends LongStream> c, LongNFunction<java.lang.Long> zipFunction)` Zip together the iterators until one of them runs out of values.
`static LongStream`	`zip(long[] a, long[] b, long[] c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<java.lang.Long> zipFunction)` Zip together the "a", "b" and "c" iterators until all of them runs out of values.
`static LongStream`	`zip(long[] a, long[] b, long[] c, LongTriFunction<java.lang.Long> zipFunction)` Zip together the "a", "b" and "c" arrays until one of them runs out of values.
`static LongStream`	`zip(long[] a, long[] b, LongBiFunction<java.lang.Long> zipFunction)` Zip together the "a" and "b" arrays until one of them runs out of values.
`static LongStream`	`zip(long[] a, long[] b, long valueForNoneA, long valueForNoneB, LongBiFunction<java.lang.Long> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static LongStream`	`zip(LongIterator a, LongIterator b, LongBiFunction<java.lang.Long> zipFunction)` Zip together the "a" and "b" iterators until one of them runs out of values.
`static LongStream`	`zip(LongIterator a, LongIterator b, LongIterator c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<java.lang.Long> zipFunction)` Zip together the "a", "b" and "c" iterators until all of them runs out of values.
`static LongStream`	`zip(LongIterator a, LongIterator b, LongIterator c, LongTriFunction<java.lang.Long> zipFunction)` Zip together the "a", "b" and "c" iterators until one of them runs out of values.
`static LongStream`	`zip(LongIterator a, LongIterator b, long valueForNoneA, long valueForNoneB, LongBiFunction<java.lang.Long> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static LongStream`	`zip(LongStream a, LongStream b, LongBiFunction<java.lang.Long> zipFunction)` Zip together the "a" and "b" streams until one of them runs out of values.
`static LongStream`	`zip(LongStream a, LongStream b, long valueForNoneA, long valueForNoneB, LongBiFunction<java.lang.Long> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static LongStream`	`zip(LongStream a, LongStream b, LongStream c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<java.lang.Long> zipFunction)` Zip together the "a", "b" and "c" iterators until all of them runs out of values.
`static LongStream`	`zip(LongStream a, LongStream b, LongStream c, LongTriFunction<java.lang.Long> zipFunction)` Zip together the "a", "b" and "c" streams until one of them runs out of values.
`abstract LongStream`	`zipWith(LongStream b, LongBiFunction<java.lang.Long> zipFunction)`
`abstract LongStream`	`zipWith(LongStream b, long valueForNoneA, long valueForNoneB, LongBiFunction<java.lang.Long> zipFunction)`
`abstract LongStream`	`zipWith(LongStream b, LongStream c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTriFunction<java.lang.Long> zipFunction)`
`abstract LongStream`	`zipWith(LongStream b, LongStream c, LongTriFunction<java.lang.Long> 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
append, cached, count, difference, distinct, dropWhile, dropWhile, filter, first, indexed, intersection, join, join, last, limit, onClose, parallel, peek, percentiles, prepend, removeIf, removeIf, reversed, reverseSorted, rotated, shuffled, skip, skip, sliding, slidingToList, sorted, split, split, split, splitAt, splitBy, splitToList, splitToList, splitToList, step, symmetricDifference, takeWhile, toArray, toCollection, toList, toLongMultiset, toLongMultiset, toMultiset, toMultiset, toSet

- Method Detail
  - map
```
public abstract LongStream map(LongUnaryOperator 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(LongToIntFunction 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
  - mapToFloat
```
public abstract FloatStream mapToFloat(LongToFloatFunction mapper)
```
    Returns a FloatStream 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(LongToDoubleFunction 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(LongFunction<? 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 LongStream flatMap(LongFunction<? extends LongStream> mapper)
```
    Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element which produces a LongStream of new values
    
    Returns:
    
    the new stream
    
    See Also:
    
    Stream.flatMap(Function)
  - flattMap
```
public abstract LongStream flattMap(LongFunction<long[]> mapper)
```
  - flatMapToInt
```
public abstract IntStream flatMapToInt(LongFunction<? extends IntStream> mapper)
```
  - flatMapToFloat
```
public abstract FloatStream flatMapToFloat(LongFunction<? extends FloatStream> mapper)
```
  - flatMapToDouble
```
public abstract DoubleStream flatMapToDouble(LongFunction<? extends DoubleStream> mapper)
```
  - flatMapToObj
```
public abstract <T> Stream<T> flatMapToObj(LongFunction<? extends Stream<T>> mapper)
```
  - flattMapToObj
```
public abstract <T> Stream<T> flattMapToObj(LongFunction<? extends java.util.Collection<T>> mapper)
```
  - collapse
```
public abstract LongStream collapse(LongBiPredicate collapsible,
                                    LongBiFunction<java.lang.Long> mergeFunction)
```
  - scan
```
public abstract LongStream scan(LongBiFunction<java.lang.Long> 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 LongStream scan(long seed,
                                LongBiFunction<java.lang.Long> 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 LongStream top(int n)
```
    This method only run sequentially, even in parallel stream.
    
    Parameters:
    
    n -
    
    Returns:
  - top
```
public abstract LongStream top(int n,
                               java.util.Comparator<? super java.lang.Long> comparator)
```
    This method only run sequentially, even in parallel stream.
    
    Parameters:
    
    n -
    
    Returns:
  - toLongList
```
public abstract LongList toLongList()
```
  - toMap
```
public abstract <K,U> java.util.Map<K,U> toMap(LongFunction<? extends K> keyExtractor,
                                               LongFunction<? 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(LongFunction<? extends K> keyExtractor,
                                                           LongFunction<? 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(LongFunction<? extends K> keyExtractor,
                                               LongFunction<? 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(LongFunction<? extends K> keyExtractor,
                                                           LongFunction<? 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(LongFunction<? extends K> classifier,
                                                 Collector<java.lang.Long,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(LongFunction<? extends K> classifier,
                                                             Collector<java.lang.Long,A,D> downstream,
                                                             Supplier<M> mapFactory)
```
    Parameters:
    
    classifier -
    
    downstream -
    
    mapFactory -
    
    Returns:
    
    See Also:
    
    Collectors.groupingBy(Function, Collector, Supplier)
  - toMatrix
```
public abstract LongMatrix toMatrix()
```
  - reduce
```
public abstract long reduce(long identity,
                            LongBinaryOperator 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:
```
     long result = identity;
     for (long element : this stream)
         result = accumulator.applyAsLong(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 OptionalLong reduce(LongBinaryOperator op)
```
    Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalLong describing the reduced value, if any. This is equivalent to:
```
     boolean foundAny = false;
     long result = null;
     for (long element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.applyAsLong(result, element);
     }
     return foundAny ? OptionalLong.of(result) : OptionalLong.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(long, LongBinaryOperator)
  - collect
```
public abstract <R> R collect(Supplier<R> supplier,
                              ObjLongConsumer<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 (long element : this stream)
         accumulator.accept(result, element);
     return result;
 
```
    Like reduce(long, LongBinaryOperator), 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,
                              ObjLongConsumer<R> accumulator)
```
    Parameters:
    
    supplier -
    
    accumulator -
    
    Returns:
  - forEach
```
public abstract <E extends java.lang.Exception> void forEach(Try.LongConsumer<E> action)
                                                      throws E extends java.lang.Exception
```
    Throws:
    
    E extends java.lang.Exception
  - anyMatch
```
public abstract <E extends java.lang.Exception> boolean anyMatch(Try.LongPredicate<E> predicate)
                                                          throws E extends java.lang.Exception
```
    Throws:
    
    E extends java.lang.Exception
  - allMatch
```
public abstract <E extends java.lang.Exception> boolean allMatch(Try.LongPredicate<E> predicate)
                                                          throws E extends java.lang.Exception
```
    Throws:
    
    E extends java.lang.Exception
  - noneMatch
```
public abstract <E extends java.lang.Exception> boolean noneMatch(Try.LongPredicate<E> predicate)
                                                           throws E extends java.lang.Exception
```
    Throws:
    
    E extends java.lang.Exception
  - findFirst
```
public abstract <E extends java.lang.Exception> OptionalLong findFirst(Try.LongPredicate<E> predicate)
                                                                throws E extends java.lang.Exception
```
    Throws:
    
    E extends java.lang.Exception
  - findLast
```
public abstract <E extends java.lang.Exception> OptionalLong findLast(Try.LongPredicate<E> predicate)
                                                               throws E extends java.lang.Exception
```
    Throws:
    
    E extends java.lang.Exception
  - findFirstOrLast
```
public abstract <E extends java.lang.Exception,E2 extends java.lang.Exception> OptionalLong findFirstOrLast(Try.LongPredicate<E> predicateForFirst,
                                                                                                            Try.LongPredicate<E> predicateForLast)
                                                                                                     throws E extends java.lang.Exception,
                                                                                                            E2 extends java.lang.Exception
```
    Throws:
    
    E extends java.lang.Exception
  - findAny
```
public abstract <E extends java.lang.Exception> OptionalLong findAny(Try.LongPredicate<E> predicate)
                                                              throws E extends java.lang.Exception
```
    Throws:
    
    E extends java.lang.Exception
  - head
```
public abstract OptionalLong 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 LongStream 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:
  - headd
```
public abstract LongStream headd()
```
    Head2 and tail2 should be used by pair. Don't call any other methods with this stream after headd() and taill() are called.
    
    Returns:
  - taill
```
public abstract OptionalLong taill()
```
    Head2 and tail2 should be used by pair. Don't call any other methods with this stream after headd() and taill() are called.
    
    Returns:
  - headAndTail
```
public abstract Pair<OptionalLong,LongStream> headAndTail()
```
  - headAndTaill
```
public abstract Pair<LongStream,OptionalLong> headAndTaill()
```
  - min
```
public abstract OptionalLong min()
```
    Returns an OptionalLong describing the minimum element of this stream, or an empty optional if this stream is empty. This is a special case of a reduction and is equivalent to:
```
     return reduce(Long::min);
 
```
    This is a terminal operation.
    Returns:
    
    an OptionalLong containing the minimum element of this stream, or an empty OptionalLong if the stream is empty
  - max
```
public abstract OptionalLong max()
```
    Returns an OptionalLong describing the maximum element of this stream, or an empty optional if this stream is empty. This is a special case of a reduction and is equivalent to:
```
     return reduce(Long::max);
 
```
    This is a terminal operation.
    Returns:
    
    an OptionalLong containing the maximum element of this stream, or an empty OptionalLong if the stream is empty
  - kthLargest
```
public abstract OptionalLong 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 long sum()
```
    Returns the sum of elements in this stream. This is a special case of a reduction and is equivalent to:
```
     return reduce(0, Long::sum);
 
```
    This is a terminal operation.
    Returns:
    
    the sum of elements in this stream
  - average
```
public abstract OptionalDouble average()
```
    Returns an OptionalDouble describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty. This is a special case of a reduction.
    This is a terminal operation.
    
    Returns:
    
    an OptionalDouble containing the average element of this stream, or an empty optional if the stream is empty
  - summarize
```
public abstract LongSummaryStatistics summarize()
```
  - summarizze
```
public abstract Pair<LongSummaryStatistics,Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Long>>> summarizze()
```
  - merge
```
public abstract LongStream merge(LongStream b,
                                 LongBiFunction<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 LongStream zipWith(LongStream b,
                                   LongBiFunction<java.lang.Long> zipFunction)
```
  - zipWith
```
public abstract LongStream zipWith(LongStream b,
                                   LongStream c,
                                   LongTriFunction<java.lang.Long> zipFunction)
```
  - zipWith
```
public abstract LongStream zipWith(LongStream b,
                                   long valueForNoneA,
                                   long valueForNoneB,
                                   LongBiFunction<java.lang.Long> zipFunction)
```
  - zipWith
```
public abstract LongStream zipWith(LongStream b,
                                   LongStream c,
                                   long valueForNoneA,
                                   long valueForNoneB,
                                   long valueForNoneC,
                                   LongTriFunction<java.lang.Long> zipFunction)
```
  - asFloatStream
```
public abstract FloatStream asFloatStream()
```
    Returns a FloatStream consisting of the elements of this stream, converted to double.
    This is an intermediate operation.
    
    Returns:
    
    a FloatStream consisting of the elements of this stream, converted to double
  - 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
  - toJdkStream
```
public abstract java.util.stream.LongStream toJdkStream()
```
  - boxed
```
public abstract Stream<java.lang.Long> boxed()
```
    Returns a Stream consisting of the elements of this stream, each boxed to a Long.
    This is an intermediate operation.
    
    Returns:
    
    a Stream consistent of the elements of this stream, each boxed to Long
  - iterator
```
public LongIterator 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 LongStream,R> transfer)
```
  - empty
```
public static LongStream empty()
```
  - of
```
@SafeVarargs
public static LongStream of(long... a)
```
  - of
```
public static LongStream of(long[] a,
                            int startIndex,
                            int endIndex)
```
  - of
```
public static LongStream of(long[][] a)
```
  - of
```
public static LongStream of(long[][][] a)
```
  - of
```
public static LongStream of(java.lang.Long[] a)
```
  - of
```
public static LongStream of(java.lang.Long[] a,
                            int startIndex,
                            int endIndex)
```
  - of
```
public static LongStream of(java.util.Collection<java.lang.Long> c)
```
  - of
```
public static LongStream of(LongIterator iterator)
```
  - of
```
public static LongStream of(Supplier<LongList> supplier)
```
    Lazy evaluation.
    
    Parameters:
    
    supplier -
    
    Returns:
  - of
```
public static LongStream of(java.util.stream.LongStream stream)
```
  - range
```
public static LongStream range(long startInclusive,
                               long endExclusive)
```
  - range
```
public static LongStream range(long startInclusive,
                               long endExclusive,
                               long by)
```
  - rangeClosed
```
public static LongStream rangeClosed(long startInclusive,
                                     long endInclusive)
```
  - rangeClosed
```
public static LongStream rangeClosed(long startInclusive,
                                     long endInclusive,
                                     long by)
```
  - repeat
```
public static LongStream repeat(long element,
                                long n)
```
  - random
```
public static LongStream random()
```
  - iterate
```
public static LongStream iterate(BooleanSupplier hasNext,
                                 LongSupplier next)
```
  - iterate
```
public static LongStream iterate(long seed,
                                 BooleanSupplier hasNext,
                                 LongUnaryOperator f)
```
  - iterate
```
public static LongStream iterate(long seed,
                                 LongPredicate hasNext,
                                 LongUnaryOperator 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 LongStream iterate(long seed,
                                 LongUnaryOperator f)
```
  - generate
```
public static LongStream generate(LongSupplier s)
```
  - interval
```
public static LongStream interval(long intervalInMillis)
```
    Parameters:
    
    intervalInMillis -
    
    Returns:
  - interval
```
public static LongStream interval(long delayInMillis,
                                  long intervalInMillis)
```
    Generates the long value by the specified period: [0, 1, 2, 3...]
    
    Parameters:
    
    delayInMillis -
    
    intervalInMillis -
    
    Returns:
  - interval
```
public static LongStream interval(long delay,
                                  long interval,
                                  java.util.concurrent.TimeUnit unit)
```
    Generates the long value by the specified period: [0, 1, 2, 3...]
    
    Parameters:
    
    delay -
    
    interval -
    
    unit -
    
    Returns:
  - concat
```
@SafeVarargs
public static LongStream concat(long[]... a)
```
  - concat
```
@SafeVarargs
public static LongStream concat(LongIterator... a)
```
  - concat
```
@SafeVarargs
public static LongStream concat(LongStream... a)
```
  - concat
```
public static LongStream concat(java.util.Collection<? extends LongStream> c)
```
  - zip
```
public static LongStream zip(long[] a,
                             long[] b,
                             LongBiFunction<java.lang.Long> 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 LongStream zip(long[] a,
                             long[] b,
                             long[] c,
                             LongTriFunction<java.lang.Long> 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 LongStream zip(LongIterator a,
                             LongIterator b,
                             LongBiFunction<java.lang.Long> 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 LongStream zip(LongIterator a,
                             LongIterator b,
                             LongIterator c,
                             LongTriFunction<java.lang.Long> 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 LongStream zip(LongStream a,
                             LongStream b,
                             LongBiFunction<java.lang.Long> 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 LongStream zip(LongStream a,
                             LongStream b,
                             LongStream c,
                             LongTriFunction<java.lang.Long> 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 LongStream zip(java.util.Collection<? extends LongStream> c,
                             LongNFunction<java.lang.Long> 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 LongStream zip(long[] a,
                             long[] b,
                             long valueForNoneA,
                             long valueForNoneB,
                             LongBiFunction<java.lang.Long> 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 LongStream zip(long[] a,
                             long[] b,
                             long[] c,
                             long valueForNoneA,
                             long valueForNoneB,
                             long valueForNoneC,
                             LongTriFunction<java.lang.Long> 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 LongStream zip(LongIterator a,
                             LongIterator b,
                             long valueForNoneA,
                             long valueForNoneB,
                             LongBiFunction<java.lang.Long> 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 LongStream zip(LongIterator a,
                             LongIterator b,
                             LongIterator c,
                             long valueForNoneA,
                             long valueForNoneB,
                             long valueForNoneC,
                             LongTriFunction<java.lang.Long> 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 LongStream zip(LongStream a,
                             LongStream b,
                             long valueForNoneA,
                             long valueForNoneB,
                             LongBiFunction<java.lang.Long> 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 LongStream zip(LongStream a,
                             LongStream b,
                             LongStream c,
                             long valueForNoneA,
                             long valueForNoneB,
                             long valueForNoneC,
                             LongTriFunction<java.lang.Long> 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 LongStream zip(java.util.Collection<? extends LongStream> c,
                             long[] valuesForNone,
                             LongNFunction<java.lang.Long> 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 LongStream merge(long[] a,
                               long[] b,
                               LongBiFunction<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 LongStream merge(long[] a,
                               long[] b,
                               long[] c,
                               LongBiFunction<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 LongStream merge(LongIterator a,
                               LongIterator b,
                               LongBiFunction<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 LongStream merge(LongIterator a,
                               LongIterator b,
                               LongIterator c,
                               LongBiFunction<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 LongStream merge(LongStream a,
                               LongStream b,
                               LongBiFunction<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 LongStream merge(LongStream a,
                               LongStream b,
                               LongStream c,
                               LongBiFunction<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 LongStream merge(java.util.Collection<? extends LongStream> c,
                               LongBiFunction<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 LongStream parallelMerge(java.util.Collection<? extends LongStream> c,
                                       LongBiFunction<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 LongStream parallelMerge(java.util.Collection<? extends LongStream> c,
                                       LongBiFunction<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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.peek(Object)
  - sliding
```
public Stream<S> sliding(int windowSize)
```
    Specified by:
    
    sliding in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.sliding(int, int)
  - shuffled
```
public S shuffled()
```
    Description copied from interface: BaseStream
    
    This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
    
    Specified by:
    
    shuffled in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>
    
    Returns:
  - toImmutableList
```
public ImmutableList<T> toImmutableList()
```
    Specified by:
    
    toImmutableList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>
  - toImmutableSet
```
public ImmutableSet<T> toImmutableSet()
```
    Specified by:
    
    toImmutableSet in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>
  - println
```
public void println()
```
    Specified by:
    
    println in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>
    
    Returns:
  - tried
```
public Try<S> tried()
```
    Specified by:
    
    tried in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    See Also:
    
    AutoCloseable.close()

Class LongStream

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

mapToFloat

mapToDouble

mapToObj

flatMap

flattMap

flatMapToInt

flatMapToFloat

flatMapToDouble

flatMapToObj

flattMapToObj

collapse

scan

scan

top

top

toLongList

toMap

toMap

toMap

toMap

toMap

toMap

toMatrix

reduce

reduce

collect

collect

forEach

anyMatch

allMatch

noneMatch

findFirst

findLast

findFirstOrLast

findAny

head

tail

headd

taill

headAndTail

headAndTaill

min

max

kthLargest

sum

average

summarize

summarizze

merge

zipWith

zipWith

zipWith

zipWith

asFloatStream

asDoubleStream

toJdkStream

boxed

iterator

__

empty

of

of

of

of

of

of

of

of

of

of

range