public interface IntStream
filter
and map
, and terminal
operations (consuming the contents of a stream to produce a result or
sideeffect), such as forEach
, findFirst
, and iterator
. Once an operation has been performed on a stream, it
is considered consumed and no longer usable for other operations.
For sequential stream pipelines, all operations are performed in the encounter order of the pipeline source, if the pipeline source has a defined encounter order.
For parallel stream pipelines, unless otherwise specified, intermediate
stream operations preserve the
encounter order of their source, and terminal operations
respect the encounter order of their source, if the source
has an encounter order. Provided that and parameters to stream operations
satisfy the noninterference
requirements, and excepting differences arising from the absence of
a defined encounter order, the result of a stream pipeline should be the
stable across multiple executions of the same operations on the same source.
However, the timing and thread in which sideeffects occur (for those
operations which are allowed to produce sideeffects, such as
forEach(IntConsumer)
), are explicitly nondeterministic for parallel
execution of stream pipelines.
Unless otherwise noted, passing a null
argument to any stream
method may result in a NullPointerException
.
iterator()
or spliterator()
operations to
perform a controlled traversal.Modifier and Type  Method and Description 

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

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

OptionalDouble 
average()
Returns an
OptionalDouble describing the average of elements of
this stream, or an empty optional if this stream is empty. 
Stream<Integer> 
boxed()
Returns a
Stream consisting of the elements of this stream,
each boxed to an Integer . 
static StreamBuilder.OfInt 
builder()
Returns a builder for an
IntStream . 
<R> R 
collect(Supplier<R> resultFactory,
ObjIntConsumer<R> accumulator,
BiConsumer<R,R> combiner)
Performs a mutable
reduction operation on the elements of this stream.

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

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

DoubleStream 
doubles()
Returns a
DoubleStream consisting of the elements of this stream,
converted to double . 
static IntStream 
empty()
Returns an empty sequential
IntStream . 
IntStream 
filter(IntPredicate predicate)
Returns a stream consisting of the elements of this stream that match
the given predicate.

OptionalInt 
findAny()
Returns an
OptionalInt describing some element of the stream, or
an empty OptionalInt if the stream is empty. 
OptionalInt 
findFirst()
Returns an
OptionalInt describing the first element of this
stream (in the encounter order), or an empty OptionalInt if the
stream is empty. 
IntStream 
flatMap(IntFunction<? extends IntStream> mapper)
Returns a stream consisting of the results of replacing each element of
this stream with the contents of the stream produced by applying the
provided mapping function to each element.

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

void 
forEachOrdered(IntConsumer 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 IntStream 
generate(IntSupplier s)
Returns a sequential
IntStream where each element is
generated by an IntSupplier . 
boolean 
isParallel()
Returns whether this stream, when executed, would execute in parallel
(assuming no further modification of the stream, such as appending
further intermediate operations or changing its parallelism).

static IntStream 
iterate(int seed,
IntUnaryOperator f)
Returns an infinite sequential
IntStream 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.OfInt 
iterator()
Returns an iterator for the elements of this stream.

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

DoubleStream 
mapToDouble(IntToDoubleFunction mapper)
Returns a
DoubleStream consisting of the results of applying the
given function to the elements of this stream. 
LongStream 
mapToLong(IntToLongFunction mapper)
Returns a
LongStream consisting of the results of applying the
given function to the elements of this stream. 
<U> Stream<U> 
mapToObj(IntFunction<? extends U> mapper)
Returns an objectvalued
Stream consisting of the results of
applying the given function to the elements of this stream. 
OptionalInt 
max()
Returns an
OptionalInt describing the maximum element of this
stream, or an empty optional if this stream is empty. 
OptionalInt 
min()
Returns an
OptionalInt describing the minimum element of this
stream, or an empty optional if this stream is empty. 
boolean 
noneMatch(IntPredicate predicate)
Returns whether no elements of this stream match the provided predicate.

static IntStream 
of(int... values)
Returns a sequential stream whose elements are the specified values.

static IntStream 
of(int t)
Returns a sequential
IntStream containing a single element. 
IntStream 
parallel()
Returns an equivalent stream that is parallel.

IntStream 
peek(IntConsumer consumer)
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 IntStream 
range(int startInclusive,
int endExclusive)
Returns a sequential
IntStream from startInclusive
(inclusive) to endExclusive (exclusive) by an incremental step of
1. 
static IntStream 
range(int startInclusive,
int endExclusive,
int step)
Returns a sequential
IntStream from startInclusive
(inclusive) to endExclusive (exclusive) by a positive step . 
OptionalInt 
reduce(IntBinaryOperator op)
Performs a reduction on the
elements of this stream, using an
associative accumulation
function, and returns an
OptionalInt describing the reduced value,
if any. 
int 
reduce(int identity,
IntBinaryOperator 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.

IntStream 
sequential()
Returns an equivalent stream that is sequential.

IntStream 
sorted()
Returns a stream consisting of the elements of this stream in sorted
order.

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

IntStream 
substream(long startInclusive)
Returns a stream consisting of the remaining elements of this stream
after indexing
startInclusive elements into the stream. 
IntStream 
substream(long startInclusive,
long endExclusive)
Returns a stream consisting of the remaining elements of this stream
after indexing
startInclusive elements into the stream and
truncated to contain no more than endExclusive  startInclusive
elements. 
int 
sum()
Returns the sum of elements in this stream.

IntSummaryStatistics 
summaryStatistics()
Returns an
IntSummaryStatistics describing various
summary data about the elements of this stream. 
int[] 
toArray()
Returns an array containing the elements of this stream.

S 
unordered()
Returns an equivalent stream that is
unordered.

IntStream filter(IntPredicate predicate)
This is an intermediate operation.
predicate
 a
noninterfering, stateless predicate to apply to
each element to determine if it should be includedIntStream map(IntUnaryOperator mapper)
This is an intermediate operation.
mapper
 a
noninterfering, stateless function to apply to each
element<U> Stream<U> mapToObj(IntFunction<? 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
elementLongStream mapToLong(IntToLongFunction mapper)
LongStream
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(IntToDoubleFunction 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
elementIntStream flatMap(IntFunction<? extends IntStream> mapper)
This is an intermediate operation.
flatMap()
operation has the effect of applying a onetomany
tranformation to the elements of the stream, and then flattening the
resulting elements into a new stream. For example, if orders
is a stream of purchase orders, and each purchase order contains a
collection of line items, then the following produces a stream of line
items:
orderStream.flatMap(order > order.getLineItems().stream())...
mapper
 a
noninterfering, stateless function to apply to
each element which produces an IntStream
of new
valuesStream.flatMap(Function)
IntStream distinct()
This is a stateful intermediate operation.
IntStream sorted()
This is a stateful intermediate operation.
IntStream peek(IntConsumer consumer)
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.
list.stream()
.filter(filteringFunction)
.peek(e > {System.out.println("Filtered value: " + e); });
.map(mappingFunction)
.peek(e > {System.out.println("Mapped value: " + e); });
.collect(Collectors.toIntSummaryStastistics());
consumer
 a
noninterfering action to perform on the elements as
they are consumed from the streamIntStream limit(long maxSize)
maxSize
in length.
maxSize
 the number of elements the stream should be limited toIllegalArgumentException
 if maxSize
is negativeIntStream substream(long startInclusive)
startInclusive
elements into the stream. If the
startInclusive
index lies past the end of this stream then an
empty stream will be returned.
This is a stateful intermediate operation.
startInclusive
 the number of leading elements to skipIllegalArgumentException
 if startInclusive
is negativeIntStream substream(long startInclusive, long endExclusive)
startInclusive
elements into the stream and
truncated to contain no more than endExclusive  startInclusive
elements. If the startInclusive
index lies past the end
of this stream then an empty stream will be returned.
startInclusive
 the starting position of the substream, inclusiveendExclusive
 the ending position of the substream, exclusiveIllegalArgumentException
 if startInclusive
or
endExclusive
is negative or startInclusive
is greater
than endExclusive
void forEach(IntConsumer 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(IntConsumer action)
This is a terminal operation.
action
 a
noninterfering action to perform on the elementsforEach(IntConsumer)
int[] toArray()
This is a terminal operation.
int reduce(int identity, IntBinaryOperator op)
int result = identity;
for (int element : this stream)
result = accumulator.apply(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.
int sum = integers.reduce(0, (a, b) > a+b);
or more compactly:
int sum = integers.reduce(0, Integer::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()
OptionalInt reduce(IntBinaryOperator op)
OptionalInt
describing the reduced value,
if any. This is equivalent to:
boolean foundAny = false;
int result = null;
for (int element : this stream) {
if (!foundAny) {
foundAny = true;
result = element;
}
else
result = accumulator.apply(result, element);
}
return foundAny ? OptionalInt.of(result) : OptionalInt.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(int, IntBinaryOperator)
<R> R collect(Supplier<R> resultFactory, ObjIntConsumer<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 = resultFactory.get();
for (int element : this stream)
accumulator.accept(result, element);
return result;
Like reduce(int, IntBinaryOperator)
, collect
operations
can be parallelized without requiring additional synchronization.
This is a terminal operation.
R
 type of the resultresultFactory
 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
noninterfering,
stateless function for incorporating an additional
element into a resultcombiner
 an associative
noninterfering,
stateless function for combining two values, which
must be compatible with the accumulator functionStream.collect(Supplier, BiConsumer, BiConsumer)
int sum()
return reduce(0, Integer::sum);
OptionalInt min()
OptionalInt
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(Integer::min);
This is a terminal operation.
OptionalInt
containing the minimum element of this
stream, or an empty OptionalInt
if the stream is emptyOptionalInt max()
OptionalInt
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(Integer::max);
This is a terminal operation.
OptionalInt
containing the maximum element of this
stream, or an empty OptionalInt
if the stream is emptylong count()
return mapToLong(e > 1L).sum();
This is a terminal operation.
OptionalDouble average()
OptionalDouble
describing the average of elements of
this stream, or an empty optional if this stream is empty. This is a
special case of a
reduction.OptionalDouble
containing the average element of this
stream, or an empty optional if the stream is emptyIntSummaryStatistics summaryStatistics()
IntSummaryStatistics
describing various
summary data about the elements of this stream. This is a special
case of a reduction.IntSummaryStatistics
describing various summary data
about the elements of this streamboolean anyMatch(IntPredicate predicate)
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(IntPredicate predicate)
This is a shortcircuiting terminal operation.
predicate
 a noninterfering,
stateless predicate to apply to elements of this
streamtrue
if all elements of the stream match the provided
predicate otherwise false
boolean noneMatch(IntPredicate predicate)
This is a shortcircuiting terminal operation.
predicate
 a noninterfering,
stateless predicate to apply to elements of this
streamtrue
if no elements of the stream match the provided
predicate otherwise false
OptionalInt findFirst()
OptionalInt
describing the first element of this
stream (in the encounter order), or an empty OptionalInt
if the
stream is empty. If the stream has no encounter order, than any element
may be returned.
This is a shortcircuiting terminal operation.
OptionalInt
describing the first element of this stream,
or an empty OptionalInt
if the stream is emptyOptionalInt findAny()
OptionalInt
describing some element of the stream, or
an empty OptionalInt
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 the first element
in the encounter order is desired, use findFirst()
instead.)
OptionalInt
describing some element of this stream, or
an empty OptionalInt
if the stream is emptyfindFirst()
LongStream longs()
LongStream
consisting of the elements of this stream,
converted to long
.LongStream
consisting of the elements of this stream,
converted to long
DoubleStream doubles()
DoubleStream
consisting of the elements of this stream,
converted to double
.DoubleStream
consisting of the elements of this stream,
converted to double
Stream<Integer> boxed()
Stream
consisting of the elements of this stream,
each boxed to an Integer
.Stream
consistent of the elements of this stream,
each boxed to an Integer
IntStream sequential()
This is an intermediate operation.
IntStream parallel()
This is an intermediate operation.
PrimitiveIterator.OfInt iterator()
This is a terminal operation.
Spliterator.OfInt spliterator()
This is a terminal operation.
static StreamBuilder.OfInt builder()
IntStream
.static IntStream empty()
IntStream
.static IntStream of(int t)
IntStream
containing a single element.t
 the single elementstatic IntStream of(int... values)
values
 the elements of the new streamstatic IntStream iterate(int seed, IntUnaryOperator f)
IntStream
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 IntStream
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
.
seed
 the initial elementf
 a function to be applied to to the previous element to produce
a new elementIntStream
static IntStream generate(IntSupplier s)
IntStream
where each element is
generated by an IntSupplier
. This is suitable for generating
constant streams, streams of random elements, etc.s
 the IntSupplier
for generated elementsIntStream
static IntStream range(int startInclusive, int endExclusive)
IntStream
from startInclusive
(inclusive) to endExclusive
(exclusive) by an incremental step of
1.
intRange(startInclusive, endExclusive, 1);
startInclusive
 the (inclusive) initial valueendExclusive
 the exclusive upper boundIntStream
for the range of int
elementsstatic IntStream range(int startInclusive, int endExclusive, int step)
IntStream
from startInclusive
(inclusive) to endExclusive
(exclusive) by a positive step
. If startInclusive
is greater than or equal to endExclusive
, an empty stream is returned.
An equivalent sequence of increasing values can be produced
sequentially using a for
loop as follows:
for (int i = startInclusive; i < endExclusive ; i += step) { ... }
startInclusive
 the (inclusive) initial valueendExclusive
 the exclusive upper boundstep
 the positive difference between consecutive valuesIntStream
for the range of int
elementsIllegalArgumentException
 if step
is less than or equal to
0boolean isParallel()
true
if this stream would execute in parallel if executed
without further modification otherwise false
S unordered()
This is an intermediate operation.
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, 2013, Oracle and/or its affiliates. All rights reserved.
DRAFT eab92