In addition to Stream , which is a stream of object references, there are primitive specializations for IntStream , LongStream , and DoubleStream , all of which are referred to as "streams" and conform to the characteristics and restrictions described here.

To perform a computation, stream operations are composed into a stream pipeline . A stream pipeline consists of a source (which might be an array, a collection, a generator function, an I/O channel, etc), zero or more intermediate operations (which transform a stream into another stream, such as filter(Predicate) ), and a terminal operation (which produces a result or side-effect, such as count() or forEach(Consumer) ). Streams are lazy; computation on the source data is only performed when the terminal operation is initiated, and source elements are consumed only as needed.

Collections and streams, while bearing some superficial similarities, have different goals. Collections are primarily concerned with the efficient management of, and access to, their elements. By contrast, streams do not provide a means to directly access or manipulate their elements, and are instead concerned with declaratively describing their source and the computational operations which will be performed in aggregate on that source. However, if the provided stream operations do not offer the desired functionality, the BaseStream.iterator() and BaseStream.spliterator() operations can be used to perform a controlled traversal.

A stream pipeline, like the "widgets" example above, can be viewed as a query on the stream source. Unless the source was explicitly designed for concurrent modification (such as a ConcurrentHashMap ), unpredictable or erroneous behavior may result from modifying the stream source while it is being queried.

Most stream operations accept parameters that describe user-specified behavior, such as the lambda expression w -> w.getWeight() passed to mapToInt in the example above. To preserve correct behavior, these behavioral parameters :

Such parameters are always instances of a functional interface such as Function , and are often lambda expressions or method references. Unless otherwise specified these parameters must be non-null .

A stream should be operated on (invoking an intermediate or terminal stream operation) only once. This rules out, for example, "forked" streams, where the same source feeds two or more pipelines, or multiple traversals of the same stream. A stream implementation may throw IllegalStateException if it detects that the stream is being reused. However, since some stream operations may return their receiver rather than a new stream object, it may not be possible to detect reuse in all cases.

Streams have a BaseStream.close() method and implement AutoCloseable , but nearly all stream instances do not actually need to be closed after use. Generally, only streams whose source is an IO channel (such as those returned by Files.lines(Path, Charset) ) will require closing. Most streams are backed by collections, arrays, or generating functions, which require no special resource management. (If a stream does require closing, it can be declared as a resource in a try -with-resources statement.)

Stream pipelines may execute either sequentially or in parallel . This execution mode is a property of the stream. Streams are created with an initial choice of sequential or parallel execution. (For example, Collection.stream() creates a sequential stream, and Collection.parallelStream() creates a parallel one.) This choice of execution mode may be modified by the BaseStream.sequential() or BaseStream.parallel() methods, and may be queried with the BaseStream.isParallel() method.

This is an intermediate operation .

This is an intermediate operation .

This is an intermediate operation .

This is an intermediate operation .

This is an intermediate operation .

This is an intermediate operation .

This is an intermediate operation .

This is an intermediate operation .

This is an intermediate operation .

For ordered streams, the selection of distinct elements is stable (for duplicated elements, the element appearing first in the encounter order is preserved.) For unordered streams, no stability guarantees are made.

This is a stateful intermediate operation .

For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.

This is a stateful intermediate operation .

For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.

This is a stateful intermediate operation .

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.

This is a short-circuiting stateful intermediate operation .

This is a stateful intermediate operation .

This is a terminal operation .

The behavior of this operation is explicitly nondeterministic. 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.

This is a terminal operation .

This operation processes the elements one at a time, in encounter order if one exists. Performing the action for one element happens-before performing the action for subsequent elements, but for any given element, the action may be performed in whatever thread the library chooses.

This is a terminal operation .

The identity value must be an identity for the accumulator function. This means that for all t , accumulator.apply(identity, t) is equal to t . The accumulator function must be an associative function.

This is a terminal operation .

The accumulator function must be an associative function.

This is a terminal operation .

The identity value must be an identity for the combiner function. This means that for all u , combiner(identity, u) is equal to u . Additionally, the combiner function must be compatible with the accumulator function; for all u and t , the following must hold: combiner.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t)

This is a terminal operation .

Like reduce(Object, BinaryOperator) , collect operations can be parallelized without requiring additional synchronization.

This is a terminal operation .

If the stream is parallel, and the Collector is concurrent , and either the stream is unordered or the collector is unordered , then a concurrent reduction will be performed (see Collector for details on concurrent reduction.)

This is a terminal operation .

When executed in parallel, multiple intermediate results may be instantiated, populated, and merged so as to maintain isolation of mutable data structures. Therefore, even when executed in parallel with non-thread-safe data structures (such as ArrayList ), no additional synchronization is needed for a parallel reduction.

This is a terminal operation .

This is a terminal operation .

This is a terminal operation .

This is a short-circuiting terminal operation .

This is a short-circuiting terminal operation .

This is a short-circuiting terminal operation .

This is a short-circuiting terminal operation .

This is a short-circuiting terminal operation .

The behavior of this operation is explicitly nondeterministic; it is free to select any element in the stream. This is to allow for maximal performance in parallel operations; the cost is that multiple invocations on the same source may not return the same result. (If a stable result is desired, use findFirst() instead.)

The first element (position 0 ) in the Stream 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 .