AutoCloseable
, BaseStream<Long,LongStream>
public interface LongStream extends BaseStream<Long,LongStream>
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.Stream
,
java.util.streamModifier and Type  Interface  Description 

static interface 
LongStream.Builder 
A mutable builder for a
LongStream . 
Modifier and Type  Method  Description 

boolean 
allMatch(LongPredicate predicate) 
Returns whether all elements of this stream match the provided predicate.

boolean 
anyMatch(LongPredicate predicate) 
Returns whether any elements of this stream match the provided
predicate.

DoubleStream 
asDoubleStream() 
Returns a
DoubleStream consisting of the elements of this stream,
converted to double . 
OptionalDouble 
average() 
Returns an
OptionalDouble describing the arithmetic mean of elements of
this stream, or an empty optional if this stream is empty. 
Stream<Long> 
boxed() 
Returns a
Stream consisting of the elements of this stream,
each boxed to a Long . 
static LongStream.Builder 
builder() 
Returns a builder for a
LongStream . 
<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(LongStream a,
LongStream b) 
Creates a lazily concatenated stream whose elements are all the
elements of the first stream followed by all the elements of the
second stream.

long 
count() 
Returns the count of elements in this stream.

LongStream 
distinct() 
Returns a stream consisting of the distinct elements of this stream.

default LongStream 
dropWhile(LongPredicate predicate) 
Returns, if this stream is ordered, a stream consisting of the remaining
elements of this stream after dropping the longest prefix of elements
that match the given predicate.

static LongStream 
empty() 
Returns an empty sequential
LongStream . 
LongStream 
filter(LongPredicate predicate) 
Returns a stream consisting of the elements of this stream that match
the given predicate.

OptionalLong 
findAny() 
Returns an
OptionalLong describing some element of the stream, or
an empty OptionalLong if the stream is empty. 
OptionalLong 
findFirst() 
Returns an
OptionalLong describing the first element of this
stream, or an empty OptionalLong if the stream is empty. 
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.

void 
forEach(LongConsumer action) 
Performs an action for each element of this stream.

void 
forEachOrdered(LongConsumer action) 
Performs an action for each element of this stream, guaranteeing that
each element is processed in encounter order for streams that have a
defined encounter order.

static LongStream 
generate(LongSupplier s) 
Returns an infinite sequential unordered stream where each element is
generated by the provided
LongSupplier . 
static LongStream 
iterate(long seed,
LongPredicate hasNext,
LongUnaryOperator next) 
Returns a sequential ordered
LongStream produced by iterative
application of the given next function to an initial element,
conditioned on satisfying the given hasNext predicate. 
static LongStream 
iterate(long seed,
LongUnaryOperator f) 
Returns an infinite sequential ordered
LongStream produced by iterative
application of a function f to an initial element seed ,
producing a Stream consisting of seed , f(seed) ,
f(f(seed)) , etc. 
PrimitiveIterator.OfLong 
iterator() 
Returns an iterator for the elements of this stream.

LongStream 
limit(long maxSize) 
Returns a stream consisting of the elements of this stream, truncated
to be no longer than
maxSize in length. 
LongStream 
map(LongUnaryOperator mapper) 
Returns a stream consisting of the results of applying the given
function to the elements of this stream.

DoubleStream 
mapToDouble(LongToDoubleFunction mapper) 
Returns a
DoubleStream consisting of the results of applying the
given function to the elements of this stream. 
IntStream 
mapToInt(LongToIntFunction mapper) 
Returns an
IntStream consisting of the results of applying the
given function to the elements of this stream. 
<U> Stream<U> 
mapToObj(LongFunction<? extends U> mapper) 
Returns an objectvalued
Stream consisting of the results of
applying the given function to the elements of this stream. 
OptionalLong 
max() 
Returns an
OptionalLong describing the maximum element of this
stream, or an empty optional if this stream is empty. 
OptionalLong 
min() 
Returns an
OptionalLong describing the minimum element of this
stream, or an empty optional if this stream is empty. 
boolean 
noneMatch(LongPredicate predicate) 
Returns whether no elements of this stream match the provided predicate.

static LongStream 
of(long t) 
Returns a sequential
LongStream containing a single element. 
static LongStream 
of(long... values) 
Returns a sequential ordered stream whose elements are the specified values.

LongStream 
parallel() 
Returns an equivalent stream that is parallel.

LongStream 
peek(LongConsumer action) 
Returns a stream consisting of the elements of this stream, additionally
performing the provided action on each element as elements are consumed
from the resulting stream.

static LongStream 
range(long startInclusive,
long endExclusive) 
Returns a sequential ordered
LongStream from startInclusive
(inclusive) to endExclusive (exclusive) by an incremental step of
1 . 
static LongStream 
rangeClosed(long startInclusive,
long endInclusive) 
Returns a sequential ordered
LongStream from startInclusive
(inclusive) to endInclusive (inclusive) by an incremental step of
1 . 
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.

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. 
LongStream 
sequential() 
Returns an equivalent stream that is sequential.

LongStream 
skip(long n) 
Returns a stream consisting of the remaining elements of this stream
after discarding the first
n elements of the stream. 
LongStream 
sorted() 
Returns a stream consisting of the elements of this stream in sorted
order.

Spliterator.OfLong 
spliterator() 
Returns a spliterator for the elements of this stream.

long 
sum() 
Returns the sum of elements in this stream.

LongSummaryStatistics 
summaryStatistics() 
Returns a
LongSummaryStatistics describing various summary data
about the elements of this stream. 
default LongStream 
takeWhile(LongPredicate predicate) 
Returns, if this stream is ordered, a stream consisting of the longest
prefix of elements taken from this stream that match the given predicate.

long[] 
toArray() 
Returns an array containing the elements of this stream.

close, isParallel, onClose, unordered
LongStream filter(LongPredicate predicate)
This is an intermediate operation.
predicate
 a noninterfering,
stateless
predicate to apply to each element to determine if it
should be includedLongStream map(LongUnaryOperator mapper)
This is an intermediate operation.
mapper
 a noninterfering,
stateless
function to apply to each element<U> Stream<U> mapToObj(LongFunction<? extends U> mapper)
Stream
consisting of the results of
applying the given function to the elements of this stream.
This is an intermediate operation.
U
 the element type of the new streammapper
 a noninterfering,
stateless
function to apply to each elementIntStream mapToInt(LongToIntFunction mapper)
IntStream
consisting of the results of applying the
given function to the elements of this stream.
This is an intermediate operation.
mapper
 a noninterfering,
stateless
function to apply to each elementDoubleStream mapToDouble(LongToDoubleFunction mapper)
DoubleStream
consisting of the results of applying the
given function to the elements of this stream.
This is an intermediate operation.
mapper
 a noninterfering,
stateless
function to apply to each elementLongStream flatMap(LongFunction<? extends LongStream> mapper)
closed
after its contents
have been placed into this stream. (If a mapped stream is null
an empty stream is used, instead.)
This is an intermediate operation.
mapper
 a noninterfering,
stateless
function to apply to each element which produces a
LongStream
of new valuesStream.flatMap(Function)
LongStream distinct()
This is a stateful intermediate operation.
LongStream sorted()
This is a stateful intermediate operation.
LongStream peek(LongConsumer action)
This is an intermediate operation.
For parallel stream pipelines, the action may be called at whatever time and in whatever thread the element is made available by the upstream operation. If the action modifies shared state, it is responsible for providing the required synchronization.
LongStream.of(1, 2, 3, 4)
.filter(e > e > 2)
.peek(e > System.out.println("Filtered value: " + e))
.map(e > e * e)
.peek(e > System.out.println("Mapped value: " + e))
.sum();
In cases where the stream implementation is able to optimize away the
production of some or all the elements (such as with shortcircuiting
operations like findFirst
, or in the example described in
count()
), the action will not be invoked for those elements.
action
 a
noninterfering action to perform on the elements as
they are consumed from the streamLongStream limit(long maxSize)
maxSize
in length.
limit()
is generally a cheap operation on sequential
stream pipelines, it can be quite expensive on ordered parallel pipelines,
especially for large values of maxSize
, since limit(n)
is constrained to return not just any n elements, but the
first n elements in the encounter order. Using an unordered
stream source (such as generate(LongSupplier)
) or removing the
ordering constraint with BaseStream.unordered()
may result in significant
speedups of limit()
in parallel pipelines, if the semantics of
your situation permit. If consistency with encounter order is required,
and you are experiencing poor performance or memory utilization with
limit()
in parallel pipelines, switching to sequential execution
with sequential()
may improve performance.maxSize
 the number of elements the stream should be limited toIllegalArgumentException
 if maxSize
is negativeLongStream skip(long n)
n
elements of the stream.
If this stream contains fewer than n
elements then an
empty stream will be returned.
This is a stateful intermediate operation.
skip()
is generally a cheap operation on sequential
stream pipelines, it can be quite expensive on ordered parallel pipelines,
especially for large values of n
, since skip(n)
is constrained to skip not just any n elements, but the
first n elements in the encounter order. Using an unordered
stream source (such as generate(LongSupplier)
) or removing the
ordering constraint with BaseStream.unordered()
may result in significant
speedups of skip()
in parallel pipelines, if the semantics of
your situation permit. If consistency with encounter order is required,
and you are experiencing poor performance or memory utilization with
skip()
in parallel pipelines, switching to sequential execution
with sequential()
may improve performance.n
 the number of leading elements to skipIllegalArgumentException
 if n
is negativedefault LongStream takeWhile(LongPredicate predicate)
If this stream is ordered then the longest prefix is a contiguous sequence of elements of this stream that match the given predicate. The first element of the sequence is the first element of this stream, and the element immediately following the last element of the sequence does not match the given predicate.
If this stream is unordered, and some (but not all) elements of this stream match the given predicate, then the behavior of this operation is nondeterministic; it is free to take any subset of matching elements (which includes the empty set).
Independent of whether this stream is ordered or unordered if all elements of this stream match the given predicate then this operation takes all elements (the result is the same as the input), or if no elements of the stream match the given predicate then no elements are taken (the result is an empty stream).
takeWhile()
is generally a cheap operation on sequential
stream pipelines, it can be quite expensive on ordered parallel
pipelines, since the operation is constrained to return not just any
valid prefix, but the longest prefix of elements in the encounter order.
Using an unordered stream source (such as
generate(LongSupplier)
) or removing the ordering constraint with
BaseStream.unordered()
may result in significant speedups of
takeWhile()
in parallel pipelines, if the semantics of your
situation permit. If consistency with encounter order is required, and
you are experiencing poor performance or memory utilization with
takeWhile()
in parallel pipelines, switching to sequential
execution with sequential()
may improve performance.spliterator
of this stream, wraps that spliterator so as to support the semantics
of this operation on traversal, and returns a new stream associated with
the wrapped spliterator. The returned stream preserves the execution
characteristics of this stream (namely parallel or sequential execution
as per BaseStream.isParallel()
) but the wrapped spliterator may choose to
not support splitting. When the returned stream is closed, the close
handlers for both the returned and this stream are invoked.predicate
 a noninterfering,
stateless
predicate to apply to elements to determine the longest
prefix of elements.default LongStream dropWhile(LongPredicate predicate)
If this stream is ordered then the longest prefix is a contiguous sequence of elements of this stream that match the given predicate. The first element of the sequence is the first element of this stream, and the element immediately following the last element of the sequence does not match the given predicate.
If this stream is unordered, and some (but not all) elements of this stream match the given predicate, then the behavior of this operation is nondeterministic; it is free to drop any subset of matching elements (which includes the empty set).
Independent of whether this stream is ordered or unordered if all elements of this stream match the given predicate then this operation drops all elements (the result is an empty stream), or if no elements of the stream match the given predicate then no elements are dropped (the result is the same as the input).
This is a stateful intermediate operation.
dropWhile()
is generally a cheap operation on sequential
stream pipelines, it can be quite expensive on ordered parallel
pipelines, since the operation is constrained to return not just any
valid prefix, but the longest prefix of elements in the encounter order.
Using an unordered stream source (such as
generate(LongSupplier)
) or removing the ordering constraint with
BaseStream.unordered()
may result in significant speedups of
dropWhile()
in parallel pipelines, if the semantics of your
situation permit. If consistency with encounter order is required, and
you are experiencing poor performance or memory utilization with
dropWhile()
in parallel pipelines, switching to sequential
execution with sequential()
may improve performance.spliterator
of this stream, wraps that spliterator so as to support the semantics
of this operation on traversal, and returns a new stream associated with
the wrapped spliterator. The returned stream preserves the execution
characteristics of this stream (namely parallel or sequential execution
as per BaseStream.isParallel()
) but the wrapped spliterator may choose to
not support splitting. When the returned stream is closed, the close
handlers for both the returned and this stream are invoked.predicate
 a noninterfering,
stateless
predicate to apply to elements to determine the longest
prefix of elements.void forEach(LongConsumer action)
This is a terminal operation.
For parallel stream pipelines, this operation does not guarantee to respect the encounter order of the stream, as doing so would sacrifice the benefit of parallelism. For any given element, the action may be performed at whatever time and in whatever thread the library chooses. If the action accesses shared state, it is responsible for providing the required synchronization.
action
 a
noninterfering action to perform on the elementsvoid forEachOrdered(LongConsumer action)
This is a terminal operation.
action
 a
noninterfering action to perform on the elementsforEach(LongConsumer)
long[] toArray()
This is a terminal operation.
long reduce(long identity, LongBinaryOperator op)
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.
long sum = integers.reduce(0, (a, b) > a+b);
or more compactly:
long sum = integers.reduce(0, Long::sum);
While this may seem a more roundabout way to perform an aggregation compared to simply mutating a running total in a loop, reduction operations parallelize more gracefully, without needing additional synchronization and with greatly reduced risk of data races.
identity
 the identity value for the accumulating functionop
 an associative,
noninterfering,
stateless
function for combining two valuessum()
,
min()
,
max()
,
average()
OptionalLong reduce(LongBinaryOperator op)
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.
op
 an associative,
noninterfering,
stateless
function for combining two valuesreduce(long, LongBinaryOperator)
<R> R collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R,R> combiner)
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.
R
 the type of the mutable result containersupplier
 a function that creates a new mutable result container.
For a parallel execution, this function may be called
multiple times and must return a fresh value each time.accumulator
 an associative,
noninterfering,
stateless
function that must fold an element into a result
container.combiner
 an associative,
noninterfering,
stateless
function that accepts two partial result containers
and merges them, which must be compatible with the
accumulator function. The combiner function must fold
the elements from the second result container into the
first result container.Stream.collect(Supplier, BiConsumer, BiConsumer)
long sum()
return reduce(0, Long::sum);
This is a terminal operation.
OptionalLong min()
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.
OptionalLong
containing the minimum element of this
stream, or an empty OptionalLong
if the stream is emptyOptionalLong max()
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.
OptionalLong
containing the maximum element of this
stream, or an empty OptionalLong
if the stream is emptylong count()
return map(e > 1L).sum();
This is a terminal operation.
LongStream s = LongStream.of(1, 2, 3, 4);
long count = s.peek(System.out::println).count();
The number of elements covered by the stream source is known and the
intermediate operation, peek
, does not inject into or remove
elements from the stream (as may be the case for flatMap
or
filter
operations). Thus the count is 4 and there is no need to
execute the pipeline and, as a sideeffect, print out the elements.OptionalDouble average()
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.
OptionalDouble
containing the average element of this
stream, or an empty optional if the stream is emptyLongSummaryStatistics summaryStatistics()
LongSummaryStatistics
describing various summary data
about the elements of this stream. This is a special case of a
reduction.
This is a terminal operation.
LongSummaryStatistics
describing various summary data
about the elements of this streamboolean anyMatch(LongPredicate predicate)
false
is returned and the predicate is not evaluated.
This is a shortcircuiting terminal operation.
predicate
 a noninterfering,
stateless
predicate to apply to elements of this streamtrue
if any elements of the stream match the provided
predicate, otherwise false
boolean allMatch(LongPredicate predicate)
true
is
returned and the predicate is not evaluated.
This is a shortcircuiting terminal operation.
true
(regardless of P(x)).predicate
 a noninterfering,
stateless
predicate to apply to elements of this streamtrue
if either all elements of the stream match the
provided predicate or the stream is empty, otherwise false
boolean noneMatch(LongPredicate predicate)
true
is
returned and the predicate is not evaluated.
This is a shortcircuiting terminal operation.
true
, regardless of P(x).predicate
 a noninterfering,
stateless
predicate to apply to elements of this streamtrue
if either no elements of the stream match the
provided predicate or the stream is empty, otherwise false
OptionalLong findFirst()
OptionalLong
describing the first element of this
stream, or an empty OptionalLong
if the stream is empty. If the
stream has no encounter order, then any element may be returned.
This is a shortcircuiting terminal operation.
OptionalLong
describing the first element of this
stream, or an empty OptionalLong
if the stream is emptyOptionalLong findAny()
OptionalLong
describing some element of the stream, or
an empty OptionalLong
if the stream is empty.
This is a shortcircuiting 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.)
OptionalLong
describing some element of this stream,
or an empty OptionalLong
if the stream is emptyfindFirst()
DoubleStream asDoubleStream()
DoubleStream
consisting of the elements of this stream,
converted to double
.
This is an intermediate operation.
DoubleStream
consisting of the elements of this stream,
converted to double
Stream<Long> boxed()
Stream
consisting of the elements of this stream,
each boxed to a Long
.
This is an intermediate operation.
Stream
consistent of the elements of this stream,
each boxed to Long
LongStream sequential()
BaseStream
This is an intermediate operation.
sequential
in interface BaseStream<Long,LongStream>
LongStream parallel()
BaseStream
This is an intermediate operation.
parallel
in interface BaseStream<Long,LongStream>
PrimitiveIterator.OfLong iterator()
BaseStream
This is a terminal operation.
iterator
in interface BaseStream<Long,LongStream>
Spliterator.OfLong spliterator()
BaseStream
This is a terminal operation.
The returned spliterator should report the set of characteristics derived from the stream pipeline (namely the characteristics derived from the stream source spliterator and the intermediate operations). Implementations may report a subset of those characteristics. For example, it may be too expensive to compute the entire set for some or all possible stream pipelines.
spliterator
in interface BaseStream<Long,LongStream>
static LongStream.Builder builder()
LongStream
.static LongStream empty()
LongStream
.static LongStream of(long t)
LongStream
containing a single element.t
 the single elementstatic LongStream of(long... values)
values
 the elements of the new streamstatic LongStream iterate(long seed, LongUnaryOperator f)
LongStream
produced by iterative
application of a function f
to an initial element seed
,
producing a Stream
consisting of seed
, f(seed)
,
f(f(seed))
, etc.
The first element (position 0
) in the LongStream
will
be the provided seed
. For n > 0
, the element at position
n
, will be the result of applying the function f
to the
element at position n  1
.
The action of applying f
for one element
happensbefore
the action of applying f
for subsequent elements. For any given
element the action may be performed in whatever thread the library
chooses.
seed
 the initial elementf
 a function to be applied to the previous element to produce
a new elementLongStream
static LongStream iterate(long seed, LongPredicate hasNext, LongUnaryOperator next)
LongStream
produced by iterative
application of the given next
function to an initial element,
conditioned on satisfying the given hasNext
predicate. The
stream terminates as soon as the hasNext
predicate returns false.
LongStream.iterate
should produce the same sequence of elements as
produced by the corresponding forloop:
for (long index=seed; hasNext.test(index); index = next.applyAsLong(index)) {
...
}
The resulting sequence may be empty if the hasNext
predicate
does not hold on the seed value. Otherwise the first element will be the
supplied seed
value, the next element (if present) will be the
result of applying the next
function to the seed
value,
and so on iteratively until the hasNext
predicate indicates that
the stream should terminate.
The action of applying the hasNext
predicate to an element
happensbefore
the action of applying the next
function to that element. The
action of applying the next
function for one element
happensbefore the action of applying the hasNext
predicate for subsequent elements. For any given element an action may
be performed in whatever thread the library chooses.
seed
 the initial elementhasNext
 a predicate to apply to elements to determine when the
stream must terminate.next
 a function to be applied to the previous element to produce
a new elementLongStream
static LongStream generate(LongSupplier s)
LongSupplier
. This is suitable for
generating constant streams, streams of random elements, etc.s
 the LongSupplier
for generated elementsLongStream
static LongStream range(long startInclusive, long endExclusive)
LongStream
from startInclusive
(inclusive) to endExclusive
(exclusive) by an incremental step of
1
.An equivalent sequence of increasing values can be produced
sequentially using a for
loop as follows:
for (long i = startInclusive; i < endExclusive ; i++) { ... }
startInclusive
 the (inclusive) initial valueendExclusive
 the exclusive upper boundLongStream
for the range of long
elementsstatic LongStream rangeClosed(long startInclusive, long endInclusive)
LongStream
from startInclusive
(inclusive) to endInclusive
(inclusive) by an incremental step of
1
.An equivalent sequence of increasing values can be produced
sequentially using a for
loop as follows:
for (long i = startInclusive; i <= endInclusive ; i++) { ... }
startInclusive
 the (inclusive) initial valueendInclusive
 the inclusive upper boundLongStream
for the range of long
elementsstatic LongStream concat(LongStream a, LongStream b)
StackOverflowError
.a
 the first streamb
 the second stream Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developertargeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2017, Oracle and/or its affiliates. 500 Oracle Parkway
Redwood Shores, CA 94065 USA. All rights reserved.
DRAFT 9internal+0adhoc.mlchung.jdk9jdeps