com.google.common.collect

Class Streams

java.lang.Object

com.google.common.collect.Streams

@Beta
 @GwtCompatible
public final class Streams
extends Object

Static utility methods related to Stream instances.

Since:

21.0

Nested Class Summary

Nested Classes

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.

Method Summary

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 <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 element of each of streamA and streamB to function.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

stream

public static <T> Stream<T> stream(Iterable<T> iterable)

Returns a sequential Stream of the contents of iterable, delegating to Collection.stream() if possible.

stream

@Deprecated
public static <T> Stream<T> stream(Collection<T> collection)

Deprecated. There is no reason to use this; just invoke collection.stream() directly.

Returns Collection.stream().

stream

public static <T> Stream<T> stream(Iterator<T> iterator)

Returns a sequential Stream of the remaining contents of iterator. Do not use iterator directly after passing it to this method.

stream

public 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.

stream

public 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.

Java 9 users: use optional.stream() instead.

concat

@SafeVarargs
public 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.

This is equivalent to Stream.of(streams).flatMap(stream -> stream), but the returned stream may perform better.

See Also:

Stream.concat(Stream, Stream)

concat

public 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.

This is equivalent to Stream.of(streams).flatMapToInt(stream -> stream), but the returned stream may perform better.

See Also:

IntStream.concat(IntStream, IntStream)

concat

public 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.

This is equivalent to Stream.of(streams).flatMapToLong(stream -> stream), but the returned stream may perform better.

See Also:

LongStream.concat(LongStream, LongStream)

concat

public 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.

This is equivalent to Stream.of(streams).flatMapToDouble(stream -> stream), but the returned stream may perform better.

See Also:

DoubleStream.concat(DoubleStream, DoubleStream)

stream

public static IntStream stream(OptionalInt optional)

If a value is present in optional, returns a stream containing only that element, otherwise returns an empty stream.

Java 9 users: use optional.stream() instead.

stream

public static LongStream stream(OptionalLong optional)

If a value is present in optional, returns a stream containing only that element, otherwise returns an empty stream.

Java 9 users: use optional.stream() instead.

stream

public static DoubleStream stream(OptionalDouble optional)

If a value is present in optional, returns a stream containing only that element, otherwise returns an empty stream.

Java 9 users: use optional.stream() instead.

findLast

public static <T> Optional<T> findLast(Stream<T> stream)

Returns the last element of the specified stream, or 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).

Throws:

NullPointerException - if the last element of the stream is null

See Also:

Stream.findFirst()

findLast

public static OptionalInt findLast(IntStream stream)

Returns the last element of the specified stream, or 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.

Throws:

NullPointerException - if the last element of the stream is null

See Also:

IntStream.findFirst()

findLast

public static OptionalLong findLast(LongStream stream)

Returns the last element of the specified stream, or 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.

Throws:

NullPointerException - if the last element of the stream is null

See Also:

LongStream.findFirst()

findLast

public static OptionalDouble findLast(DoubleStream stream)

Returns the last element of the specified stream, or 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.

Throws:

NullPointerException - if the last element of the stream is null

See Also:

DoubleStream.findFirst()

zip

public 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 element of each of 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.

The resulting stream is not efficiently splittable. This may harm parallel performance.

mapWithIndex

public 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. 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.

mapWithIndex

public 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. 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.

mapWithIndex

public 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. 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.

mapWithIndex

public 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. 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.