@GwtCompatible public final class Streams extends Object
Stream
instances.Modifier and Type | Class and Description |
---|---|
static interface |
Streams.DoubleFunctionWithIndex<R>
An analogue of
DoubleFunction also accepting an index. |
static interface |
Streams.FunctionWithIndex<T,R>
An analogue of
Function also accepting an index. |
static interface |
Streams.IntFunctionWithIndex<R>
An analogue of
IntFunction also accepting an index. |
static interface |
Streams.LongFunctionWithIndex<R>
An analogue of
LongFunction also accepting an index. |
Modifier and Type | Method and Description |
---|---|
static DoubleStream |
concat(DoubleStream... streams)
Returns a
DoubleStream containing the elements of the first stream, followed by the
elements of the second stream, and so on. |
static IntStream |
concat(IntStream... streams)
Returns an
IntStream containing the elements of the first stream, followed by the
elements of the second stream, and so on. |
static LongStream |
concat(LongStream... streams)
Returns a
LongStream containing the elements of the first stream, followed by the
elements of the second stream, and so on. |
static <T> Stream<T> |
concat(Stream<? extends T>... streams)
Returns a
Stream containing the elements of the first stream, followed by the elements
of the second stream, and so on. |
static OptionalDouble |
findLast(DoubleStream stream)
Returns the last element of the specified stream, or
OptionalDouble.empty() if the stream
is empty. |
static OptionalInt |
findLast(IntStream stream)
Returns the last element of the specified stream, or
OptionalInt.empty() if the stream is
empty. |
static OptionalLong |
findLast(LongStream stream)
Returns the last element of the specified stream, or
OptionalLong.empty() if the stream
is empty. |
static <T> Optional<T> |
findLast(Stream<T> stream)
Returns the last element of the specified stream, or
Optional.empty() if the
stream is empty. |
static <A,B> void |
forEachPair(Stream<A> streamA,
Stream<B> streamB,
BiConsumer<? super A,? super B> consumer)
Invokes
consumer once for each pair of corresponding elements in streamA
and streamB . |
static <R> Stream<R> |
mapWithIndex(DoubleStream stream,
Streams.DoubleFunctionWithIndex<R> function)
Returns a stream consisting of the results of applying the given function to the elements of
stream and their indexes in the stream. |
static <R> Stream<R> |
mapWithIndex(IntStream stream,
Streams.IntFunctionWithIndex<R> function)
Returns a stream consisting of the results of applying the given function to the elements of
stream and their indexes in the stream. |
static <R> Stream<R> |
mapWithIndex(LongStream stream,
Streams.LongFunctionWithIndex<R> function)
Returns a stream consisting of the results of applying the given function to the elements of
stream and their indexes in the stream. |
static <T,R> Stream<R> |
mapWithIndex(Stream<T> stream,
Streams.FunctionWithIndex<? super T,? extends R> function)
Returns a stream consisting of the results of applying the given function to the elements of
stream and their indices in the stream. |
static <T> Stream<T> |
stream(Collection<T> collection)
Deprecated.
There is no reason to use this; just invoke
collection.stream() directly. |
static <T> Stream<T> |
stream(Iterable<T> iterable)
Returns a sequential
Stream of the contents of iterable , delegating to Collection.stream() if possible. |
static <T> Stream<T> |
stream(Iterator<T> iterator)
Returns a sequential
Stream of the remaining contents of iterator . |
static <T> Stream<T> |
stream(Optional<T> optional)
If a value is present in
optional , returns a stream containing only that element,
otherwise returns an empty stream. |
static <T> Stream<T> |
stream(Optional<T> optional)
If a value is present in
optional , returns a stream containing only that element,
otherwise returns an empty stream. |
static DoubleStream |
stream(OptionalDouble optional)
If a value is present in
optional , returns a stream containing only that element,
otherwise returns an empty stream. |
static IntStream |
stream(OptionalInt optional)
If a value is present in
optional , returns a stream containing only that element,
otherwise returns an empty stream. |
static LongStream |
stream(OptionalLong optional)
If a value is present in
optional , returns a stream containing only that element,
otherwise returns an empty stream. |
static <A,B,R> Stream<R> |
zip(Stream<A> streamA,
Stream<B> streamB,
BiFunction<? super A,? super B,R> function)
Returns a stream in which each element is the result of passing the corresponding elementY of
each of
streamA and streamB to function . |
public static <T> Stream<T> stream(Iterable<T> iterable)
Stream
of the contents of iterable
, delegating to Collection.stream()
if possible.@Beta @Deprecated public static <T> Stream<T> stream(Collection<T> collection)
collection.stream()
directly.Collection.stream()
.@Beta public static <T> Stream<T> stream(Iterator<T> iterator)
Stream
of the remaining contents of iterator
. Do not use
iterator
directly after passing it to this method.@Beta public static <T> Stream<T> stream(Optional<T> optional)
optional
, returns a stream containing only that element,
otherwise returns an empty stream.@Beta public static <T> Stream<T> stream(Optional<T> optional)
optional
, returns a stream containing only that element,
otherwise returns an empty stream.
Java 9 users: use optional.stream()
instead.
@Beta public static IntStream stream(OptionalInt optional)
optional
, returns a stream containing only that element,
otherwise returns an empty stream.
Java 9 users: use optional.stream()
instead.
@Beta public static LongStream stream(OptionalLong optional)
optional
, returns a stream containing only that element,
otherwise returns an empty stream.
Java 9 users: use optional.stream()
instead.
@Beta public static DoubleStream stream(OptionalDouble optional)
optional
, returns a stream containing only that element,
otherwise returns an empty stream.
Java 9 users: use optional.stream()
instead.
@SafeVarargs public static <T> Stream<T> concat(Stream<? extends T>... streams)
Stream
containing the elements of the first stream, followed by the elements
of the second stream, and so on.
This is equivalent to Stream.of(streams).flatMap(stream -> stream)
, but the returned
stream may perform better.
Stream.concat(Stream, Stream)
public static IntStream concat(IntStream... streams)
IntStream
containing the elements of the first stream, followed by the
elements of the second stream, and so on.
This is equivalent to Stream.of(streams).flatMapToInt(stream -> stream)
, but the
returned stream may perform better.
IntStream.concat(IntStream, IntStream)
public static LongStream concat(LongStream... streams)
LongStream
containing the elements of the first stream, followed by the
elements of the second stream, and so on.
This is equivalent to Stream.of(streams).flatMapToLong(stream -> stream)
, but the
returned stream may perform better.
public static DoubleStream concat(DoubleStream... streams)
DoubleStream
containing the elements of the first stream, followed by the
elements of the second stream, and so on.
This is equivalent to Stream.of(streams).flatMapToDouble(stream -> stream)
, but the
returned stream may perform better.
@Beta public static <A,B,R> Stream<R> zip(Stream<A> streamA, Stream<B> streamB, BiFunction<? super A,? super B,R> function)
streamA
and streamB
to function
.
For example:
Streams.zip(
Stream.of("foo1", "foo2", "foo3"),
Stream.of("bar1", "bar2"),
(arg1, arg2) -> arg1 + ":" + arg2)
will return Stream.of("foo1:bar1", "foo2:bar2")
.
The resulting stream will only be as long as the shorter of the two input streams; if one stream is longer, its extra elements will be ignored.
Note that if you are calling Stream.forEach(java.util.function.Consumer<? super T>)
on the resulting stream, you might want
to consider using forEachPair(java.util.stream.Stream<A>, java.util.stream.Stream<B>, java.util.function.BiConsumer<? super A, ? super B>)
instead of this method.
Performance note: The resulting stream is not efficiently splittable. This may harm parallel performance.
@Beta public static <A,B> void forEachPair(Stream<A> streamA, Stream<B> streamB, BiConsumer<? super A,? super B> consumer)
consumer
once for each pair of corresponding elements in streamA
and streamB
. If one stream is longer than the other, the extra elements are silently
ignored. Elements passed to the consumer are guaranteed to come from the same position in their
respective source streams. For example:
Streams.forEachPair(
Stream.of("foo1", "foo2", "foo3"),
Stream.of("bar1", "bar2"),
(arg1, arg2) -> System.out.println(arg1 + ":" + arg2)
will print:
foo1:bar1
foo2:bar2
Warning: If either supplied stream is a parallel stream, the same correspondence between elements will be made, but the order in which those pairs of elements are passed to the consumer is not defined.
Note that many usages of this method can be replaced with simpler calls to zip(java.util.stream.Stream<A>, java.util.stream.Stream<B>, java.util.function.BiFunction<? super A, ? super B, R>)
.
This method behaves equivalently to zipping the stream elements into
temporary pair objects and then using Stream.forEach(java.util.function.Consumer<? super T>)
on that stream.
@Beta public static <T,R> Stream<R> mapWithIndex(Stream<T> stream, Streams.FunctionWithIndex<? super T,? extends R> function)
stream
and their indices in the stream. For example,
mapWithIndex(
Stream.of("a", "b", "c"),
(str, index) -> str + ":" + index)
would return Stream.of("a:0", "b:1", "c:2")
.
The resulting stream is efficiently splittable
if and only if stream
was efficiently splittable and its underlying spliterator
reported Spliterator.SUBSIZED
. This is generally the case if the underlying stream
comes from a data structure supporting efficient indexed random access, typically an array or
list.
The order of the resulting stream is defined if and only if the order of the original stream was defined.
@Beta public static <R> Stream<R> mapWithIndex(IntStream stream, Streams.IntFunctionWithIndex<R> function)
stream
and their indexes in the stream. For example,
mapWithIndex(
IntStream.of(0, 1, 2),
(i, index) -> i + ":" + index)
...would return Stream.of("0:0", "1:1", "2:2")
.
The resulting stream is efficiently splittable
if and only if stream
was efficiently splittable and its underlying spliterator
reported Spliterator.SUBSIZED
. This is generally the case if the underlying stream
comes from a data structure supporting efficient indexed random access, typically an array or
list.
The order of the resulting stream is defined if and only if the order of the original stream was defined.
@Beta public static <R> Stream<R> mapWithIndex(LongStream stream, Streams.LongFunctionWithIndex<R> function)
stream
and their indexes in the stream. For example,
mapWithIndex(
LongStream.of(0, 1, 2),
(i, index) -> i + ":" + index)
...would return Stream.of("0:0", "1:1", "2:2")
.
The resulting stream is efficiently splittable
if and only if stream
was efficiently splittable and its underlying spliterator
reported Spliterator.SUBSIZED
. This is generally the case if the underlying stream
comes from a data structure supporting efficient indexed random access, typically an array or
list.
The order of the resulting stream is defined if and only if the order of the original stream was defined.
@Beta public static <R> Stream<R> mapWithIndex(DoubleStream stream, Streams.DoubleFunctionWithIndex<R> function)
stream
and their indexes in the stream. For example,
mapWithIndex(
DoubleStream.of(0, 1, 2),
(x, index) -> x + ":" + index)
...would return Stream.of("0.0:0", "1.0:1", "2.0:2")
.
The resulting stream is efficiently splittable
if and only if stream
was efficiently splittable and its underlying spliterator
reported Spliterator.SUBSIZED
. This is generally the case if the underlying stream
comes from a data structure supporting efficient indexed random access, typically an array or
list.
The order of the resulting stream is defined if and only if the order of the original stream was defined.
@Beta public static <T> Optional<T> findLast(Stream<T> stream)
Optional.empty()
if the
stream is empty.
Equivalent to stream.reduce((a, b) -> b)
, but may perform significantly better. This
method's runtime will be between O(log n) and O(n), performing better on efficiently splittable
streams.
If the stream has nondeterministic order, this has equivalent semantics to Stream.findAny()
(which you might as well use).
NullPointerException
- if the last element of the stream is nullStream.findFirst()
@Beta public static OptionalInt findLast(IntStream stream)
OptionalInt.empty()
if the stream is
empty.
Equivalent to stream.reduce((a, b) -> b)
, but may perform significantly better. This
method's runtime will be between O(log n) and O(n), performing better on efficiently splittable
streams.
NullPointerException
- if the last element of the stream is nullIntStream.findFirst()
@Beta public static OptionalLong findLast(LongStream stream)
OptionalLong.empty()
if the stream
is empty.
Equivalent to stream.reduce((a, b) -> b)
, but may perform significantly better. This
method's runtime will be between O(log n) and O(n), performing better on efficiently splittable
streams.
NullPointerException
- if the last element of the stream is nullLongStream.findFirst()
@Beta public static OptionalDouble findLast(DoubleStream stream)
OptionalDouble.empty()
if the stream
is empty.
Equivalent to stream.reduce((a, b) -> b)
, but may perform significantly better. This
method's runtime will be between O(log n) and O(n), performing better on efficiently splittable
streams.
NullPointerException
- if the last element of the stream is nullDoubleStream.findFirst()
Copyright © 2010–2019. All rights reserved.