StreamSupport (net.sourceforge.streamsupport:streamsupport 1.4 API)

java.lang.Object
- java8.util.stream.StreamSupport

```
public final class StreamSupport
extends Object
```
Low-level utility methods for creating and manipulating streams.
This class is mostly for library writers presenting stream views of data structures; most static stream methods intended for end users are in the various Streams classes.

Since:

1.8

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> Stream.Builder<T>`	`builder()` Deprecated. Use `RefStreams.builder()` instead
`static <T> Stream<T>`	`concat(Stream<? extends T> a, Stream<? extends T> b)` Deprecated. Use `RefStreams.concat(Stream, Stream)` instead
`static DoubleStream`	`doubleStream(Spliterator.OfDouble spliterator, boolean parallel)` Creates a new sequential or parallel `DoubleStream` from a `Spliterator.OfDouble`.
`static DoubleStream`	`doubleStream(Supplier<? extends Spliterator.OfDouble> supplier, int characteristics, boolean parallel)` Creates a new sequential or parallel `DoubleStream` from a `Supplier` of `Spliterator.OfDouble`.
`static <T> Stream<T>`	`empty()` Deprecated. Use `RefStreams.empty()` instead
`static <T> Stream<T>`	`generate(Supplier<? extends T> s)` Deprecated. Use `RefStreams.generate(Supplier)` instead
`static IntStream`	`intStream(Spliterator.OfInt spliterator, boolean parallel)` Creates a new sequential or parallel `IntStream` from a `Spliterator.OfInt`.
`static IntStream`	`intStream(Supplier<? extends Spliterator.OfInt> supplier, int characteristics, boolean parallel)` Creates a new sequential or parallel `IntStream` from a `Supplier` of `Spliterator.OfInt`.
`static <T,S extends T> Stream<T>`	`iterate(S seed, UnaryOperator<S> f)` Deprecated. Use `RefStreams.iterate(Object, UnaryOperator)` instead
`static LongStream`	`longStream(Spliterator.OfLong spliterator, boolean parallel)` Creates a new sequential or parallel `LongStream` from a `Spliterator.OfLong`.
`static LongStream`	`longStream(Supplier<? extends Spliterator.OfLong> supplier, int characteristics, boolean parallel)` Creates a new sequential or parallel `LongStream` from a `Supplier` of `Spliterator.OfLong`.
`static <T> Stream<T>`	`of(T... values)` Deprecated. Use `RefStreams.of(Object...)` instead
`static <T> Stream<T>`	`of(T t)` Deprecated. Use `RefStreams.of(Object)` instead
`static <T> Stream<T>`	`ofNullable(T t)` Deprecated. Use `RefStreams.ofNullable(Object)` instead
`static <T> Stream<T>`	`parallelStream(Collection<? extends T> c)` Creates a new possibly parallel `Stream` using either the given collection's `Collection.iterator()` as the source of elements for an internally created `Spliterator` which will report the collection's `Collection.size()` as its initial size or a specialized `Spliterator` implementation (effectively the same one that Java 8 uses) if the passed `Collection` is one of the types listed below.
`static <T> Stream<T>`	`stream(Collection<? extends T> c)` Creates a new sequential `Stream` using either the given collection's `Collection.iterator()` as the source of elements for an internally created `Spliterator` which will report the collection's `Collection.size()` as its initial size or a specialized `Spliterator` implementation (effectively the same one that Java 8 uses) if the passed `Collection` is one of the types listed below.
`static <T> Stream<T>`	`stream(Collection<? extends T> c, int characteristics)` Creates a new sequential `Stream` using the given collection's `Collection.iterator()` as the source of elements for an internally created `Spliterator` which will report the collection's `Collection.size()` as its initial size.
`static <T> Stream<T>`	`stream(Collection<? extends T> c, int characteristics, boolean parallel)` Creates a new sequential or parallel `Stream` using the given collection's `Collection.iterator()` as the source of elements for an internally created `Spliterator` which will report the collection's `Collection.size()` as its initial size.
`static <T> Stream<T>`	`stream(Spliterator<T> spliterator, boolean parallel)` Creates a new sequential or parallel `Stream` from a `Spliterator`.
`static <T> Stream<T>`	`stream(Supplier<? extends Spliterator<T>> supplier, int characteristics, boolean parallel)` Creates a new sequential or parallel `Stream` from a `Supplier` of `Spliterator`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - builder
```
@Deprecated
public static <T> Stream.Builder<T> builder()
```
    Deprecated. Use RefStreams.builder() instead
    
    Returns a builder for a Stream.
    
    Type Parameters:
    
    T - type of elements
    
    Returns:
    
    a stream builder
  - empty
```
@Deprecated
public static <T> Stream<T> empty()
```
    Deprecated. Use RefStreams.empty() instead
    
    Returns an empty sequential Stream.
    
    Type Parameters:
    
    T - the type of stream elements
    
    Returns:
    
    an empty sequential stream
  - of
```
@Deprecated
public static <T> Stream<T> of(T t)
```
    Deprecated. Use RefStreams.of(Object) instead
    
    Returns a sequential Stream containing a single element.
    
    Type Parameters:
    
    T - the type of stream elements
    
    Parameters:
    
    t - the single element
    
    Returns:
    
    a singleton sequential stream
  - ofNullable
```
@Deprecated
public static <T> Stream<T> ofNullable(T t)
```
    Deprecated. Use RefStreams.ofNullable(Object) instead
    
    Returns a sequential Stream containing a single element, if non-null, otherwise returns an empty Stream.
    
    Type Parameters:
    
    T - the type of stream elements
    
    Parameters:
    
    t - the single element
    
    Returns:
    
    a stream with a single element if the specified element is non-null, otherwise an empty stream
    
    Since:
    
    9
  - of
```
@Deprecated
public static <T> Stream<T> of(T... values)
```
    Deprecated. Use RefStreams.of(Object...) instead
    
    Returns a sequential ordered stream whose elements are the specified values.
    
    Type Parameters:
    
    T - the type of stream elements
    
    Parameters:
    
    values - the elements of the new stream
    
    Returns:
    
    the new stream
  - iterate
```
@Deprecated
public static <T,S extends T> Stream<T> iterate(S seed,
                                                             UnaryOperator<S> f)
```
    Deprecated. Use RefStreams.iterate(Object, UnaryOperator) instead
    
    Returns an infinite sequential ordered Stream 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 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.
    
    Type Parameters:
    
    S - the type of the operand and seed, a subtype of T
    
    T - the type of stream elements
    
    Parameters:
    
    seed - the initial element
    
    f - a function to be applied to the previous element to produce a new element
    
    Returns:
    
    a new sequential Stream
  - generate
```
@Deprecated
public static <T> Stream<T> generate(Supplier<? extends T> s)
```
    Deprecated. Use RefStreams.generate(Supplier) instead
    
    Returns an infinite sequential unordered stream where each element is generated by the provided Supplier. This is suitable for generating constant streams, streams of random elements, etc.
    
    Type Parameters:
    
    T - the type of stream elements
    
    Parameters:
    
    s - the Supplier of generated elements
    
    Returns:
    
    a new infinite sequential unordered Stream
  - concat
```
@Deprecated
public static <T> Stream<T> concat(Stream<? extends T> a,
                                                Stream<? extends T> b)
```
    Deprecated. Use RefStreams.concat(Stream, Stream) instead
    
    Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream. The resulting stream is ordered if both of the input streams are ordered, and parallel if either of the input streams is parallel. When the resulting stream is closed, the close handlers for both input streams are invoked.
    Implementation Note:
    Use caution when constructing streams from repeated concatenation. Accessing an element of a deeply concatenated stream can result in deep call chains, or even StackOverflowError.
    Subsequent changes to the sequential/parallel execution mode of the returned stream are not guaranteed to be propagated to the input streams.
    
    Type Parameters:
    
    T - The type of stream elements
    
    Parameters:
    
    a - the first stream
    
    b - the second stream
    
    Returns:
    
    the concatenation of the two input streams
  - stream
```
public static <T> Stream<T> stream(Collection<? extends T> c)
```
    Creates a new sequential Stream using either the given collection's Collection.iterator() as the source of elements for an internally created Spliterator which will report the collection's Collection.size() as its initial size or a specialized Spliterator implementation (effectively the same one that Java 8 uses) if the passed Collection is one of the types listed below.
    - java.util.ArrayList
    - java.util.Arrays.ArrayList
    - java.util.ArrayDeque
    - java.util.Vector
    - java.util.LinkedList
    - java.util.HashSet
    - java.util.LinkedHashSet
    - java.util.PriorityQueue
    - java.util.concurrent.ArrayBlockingQueue
    - java.util.concurrent.LinkedBlockingQueue
    - java.util.concurrent.LinkedBlockingDeque
    - java.util.concurrent.PriorityBlockingQueue
    - java.util.concurrent.CopyOnWriteArrayList
    - java.util.concurrent.CopyOnWriteArraySet
    - The collections returned from the java.util.HashMap methods #keySet(), #entrySet() and #values()
    The Spliterators for CopyOnWriteArrayList and CopyOnWriteArraySet provide a snapshot of the state of the collection when the Stream was created, otherwise the created spliterator is late-binding, inherits the fail-fast properties of the collection's iterator, and implements trySplit to permit limited parallelism.
    The created spliterator is only traversed, split, or queried for estimated size after the terminal operation of the stream pipeline commences.
    Type Parameters:
    
    T - Type of elements
    
    Parameters:
    
    c - The collection
    
    Returns:
    
    a new sequential Stream
    
    Throws:
    
    NullPointerException - if the given collection is null
  - parallelStream
```
public static <T> Stream<T> parallelStream(Collection<? extends T> c)
```
    Creates a new possibly parallel Stream using either the given collection's Collection.iterator() as the source of elements for an internally created Spliterator which will report the collection's Collection.size() as its initial size or a specialized Spliterator implementation (effectively the same one that Java 8 uses) if the passed Collection is one of the types listed below.
    - java.util.ArrayList
    - java.util.Arrays.ArrayList
    - java.util.ArrayDeque
    - java.util.Vector
    - java.util.LinkedList
    - java.util.HashSet
    - java.util.LinkedHashSet
    - java.util.PriorityQueue
    - java.util.concurrent.ArrayBlockingQueue
    - java.util.concurrent.LinkedBlockingQueue
    - java.util.concurrent.LinkedBlockingDeque
    - java.util.concurrent.PriorityBlockingQueue
    - java.util.concurrent.CopyOnWriteArrayList
    - java.util.concurrent.CopyOnWriteArraySet
    - The collections returned from the java.util.HashMap methods #keySet(), #entrySet() and #values()
    The Spliterators for CopyOnWriteArrayList and CopyOnWriteArraySet provide a snapshot of the state of the collection when the Stream was created, otherwise the created spliterator is late-binding, inherits the fail-fast properties of the collection's iterator, and implements trySplit to permit limited parallelism.
    The created spliterator is only traversed, split, or queried for estimated size after the terminal operation of the stream pipeline commences.
    Type Parameters:
    
    T - Type of elements
    
    Parameters:
    
    c - The collection
    
    Returns:
    
    a new possibly parallel Stream
    
    Throws:
    
    NullPointerException - if the given collection is null
  - stream
```
public static <T> Stream<T> stream(Collection<? extends T> c,
                                   int characteristics)
```
    Creates a new sequential Stream using the given collection's Collection.iterator() as the source of elements for an internally created Spliterator which will report the collection's Collection.size() as its initial size.
    The created spliterator is late-binding, inherits the fail-fast properties of the collection's iterator, and implements trySplit to permit limited parallelism.
    The created spliterator is only traversed, split, or queried for estimated size after the terminal operation of the stream pipeline commences.
    If the collection is immutable it is recommended to report a characteristic of IMMUTABLE. The characteristics SIZED and SUBSIZED are additionally (automatically) reported unless CONCURRENT is supplied.
    
    Type Parameters:
    
    T - Type of elements
    
    Parameters:
    
    c - The collection
    
    characteristics - Characteristics of the source collection's iterator or elements. The characteristics SIZED and SUBSIZED are additionally reported unless CONCURRENT is supplied.
    
    Returns:
    
    a new sequential Stream
    
    Throws:
    
    NullPointerException - if the given collection is null
  - stream
```
public static <T> Stream<T> stream(Collection<? extends T> c,
                                   int characteristics,
                                   boolean parallel)
```
    Creates a new sequential or parallel Stream using the given collection's Collection.iterator() as the source of elements for an internally created Spliterator which will report the collection's Collection.size() as its initial size.
    The created spliterator is late-binding, inherits the fail-fast properties of the collection's iterator, and implements trySplit to permit limited parallelism.
    The created spliterator is only traversed, split, or queried for estimated size after the terminal operation of the stream pipeline commences.
    If possible for the collection, it is strongly recommended to report a characteristic of IMMUTABLE or CONCURRENT especially if you want a parallel Stream. The characteristics SIZED and SUBSIZED are additionally (automatically) reported unless CONCURRENT is supplied.
    
    Type Parameters:
    
    T - Type of elements
    
    Parameters:
    
    c - The collection
    
    characteristics - Characteristics of the source collection's iterator or elements. The characteristics SIZED and SUBSIZED are additionally reported unless CONCURRENT is supplied.
    
    parallel - if true then the returned stream is a parallel stream; if false the returned stream is a sequential stream.
    
    Returns:
    
    a new sequential or parallel Stream
    
    Throws:
    
    NullPointerException - if the given collection is null
  - stream
```
public static <T> Stream<T> stream(Spliterator<T> spliterator,
                                   boolean parallel)
```
    Creates a new sequential or parallel Stream from a Spliterator.
    The spliterator is only traversed, split, or queried for estimated size after the terminal operation of the stream pipeline commences.
    It is strongly recommended the spliterator report a characteristic of IMMUTABLE or CONCURRENT, or be late-binding. Otherwise, stream(java8.util.function.Supplier, int, boolean) should be used to reduce the scope of potential interference with the source. See Non-Interference for more details.
    
    Type Parameters:
    
    T - the type of stream elements
    
    Parameters:
    
    spliterator - a Spliterator describing the stream elements
    
    parallel - if true then the returned stream is a parallel stream; if false the returned stream is a sequential stream.
    
    Returns:
    
    a new sequential or parallel Stream
  - stream
```
public static <T> Stream<T> stream(Supplier<? extends Spliterator<T>> supplier,
                                   int characteristics,
                                   boolean parallel)
```
    Creates a new sequential or parallel Stream from a Supplier of Spliterator.
    The Supplier.get() method will be invoked on the supplier no more than once, and only after the terminal operation of the stream pipeline commences.
    For spliterators that report a characteristic of IMMUTABLE or CONCURRENT, or that are late-binding, it is likely more efficient to use stream(java8.util.Spliterator, boolean) instead.
    The use of a Supplier in this form provides a level of indirection that reduces the scope of potential interference with the source. Since the supplier is only invoked after the terminal operation commences, any modifications to the source up to the start of the terminal operation are reflected in the stream result. See Non-Interference for more details.
    
    Type Parameters:
    
    T - the type of stream elements
    
    Parameters:
    
    supplier - a Supplier of a Spliterator
    
    characteristics - Spliterator characteristics of the supplied Spliterator. The characteristics must be equal to supplier.get().characteristics(), otherwise undefined behavior may occur when terminal operation commences.
    
    parallel - if true then the returned stream is a parallel stream; if false the returned stream is a sequential stream.
    
    Returns:
    
    a new sequential or parallel Stream
    
    See Also:
    
    stream(java8.util.Spliterator, boolean)
  - intStream
```
public static IntStream intStream(Spliterator.OfInt spliterator,
                                  boolean parallel)
```
    Creates a new sequential or parallel IntStream from a Spliterator.OfInt.
    The spliterator is only traversed, split, or queried for estimated size after the terminal operation of the stream pipeline commences.
    It is strongly recommended the spliterator report a characteristic of IMMUTABLE or CONCURRENT, or be late-binding. Otherwise, intStream(java8.util.function.Supplier, int, boolean) should be used to reduce the scope of potential interference with the source. See Non-Interference for more details.
    
    Parameters:
    
    spliterator - a Spliterator.OfInt describing the stream elements
    
    parallel - if true then the returned stream is a parallel stream; if false the returned stream is a sequential stream.
    
    Returns:
    
    a new sequential or parallel IntStream
  - intStream
```
public static IntStream intStream(Supplier<? extends Spliterator.OfInt> supplier,
                                  int characteristics,
                                  boolean parallel)
```
    Creates a new sequential or parallel IntStream from a Supplier of Spliterator.OfInt.
    The Supplier.get() method will be invoked on the supplier no more than once, and only after the terminal operation of the stream pipeline commences.
    For spliterators that report a characteristic of IMMUTABLE or CONCURRENT, or that are late-binding, it is likely more efficient to use intStream(java8.util.Spliterator.OfInt, boolean) instead.
    The use of a Supplier in this form provides a level of indirection that reduces the scope of potential interference with the source. Since the supplier is only invoked after the terminal operation commences, any modifications to the source up to the start of the terminal operation are reflected in the stream result. See Non-Interference for more details.
    
    Parameters:
    
    supplier - a Supplier of a Spliterator.OfInt
    
    characteristics - Spliterator characteristics of the supplied Spliterator.OfInt. The characteristics must be equal to supplier.get().characteristics(), otherwise undefined behavior may occur when terminal operation commences.
    
    parallel - if true then the returned stream is a parallel stream; if false the returned stream is a sequential stream.
    
    Returns:
    
    a new sequential or parallel IntStream
    
    See Also:
    
    intStream(java8.util.Spliterator.OfInt, boolean)
  - longStream
```
public static LongStream longStream(Spliterator.OfLong spliterator,
                                    boolean parallel)
```
    Creates a new sequential or parallel LongStream from a Spliterator.OfLong.
    The spliterator is only traversed, split, or queried for estimated size after the terminal operation of the stream pipeline commences.
    It is strongly recommended the spliterator report a characteristic of IMMUTABLE or CONCURRENT, or be late-binding. Otherwise, longStream(java8.util.function.Supplier, int, boolean) should be used to reduce the scope of potential interference with the source. See Non-Interference for more details.
    
    Parameters:
    
    spliterator - a Spliterator.OfLong describing the stream elements
    
    parallel - if true then the returned stream is a parallel stream; if false the returned stream is a sequential stream.
    
    Returns:
    
    a new sequential or parallel LongStream
  - longStream
```
public static LongStream longStream(Supplier<? extends Spliterator.OfLong> supplier,
                                    int characteristics,
                                    boolean parallel)
```
    Creates a new sequential or parallel LongStream from a Supplier of Spliterator.OfLong.
    The Supplier.get() method will be invoked on the supplier no more than once, and only after the terminal operation of the stream pipeline commences.
    For spliterators that report a characteristic of IMMUTABLE or CONCURRENT, or that are late-binding, it is likely more efficient to use longStream(java8.util.Spliterator.OfLong, boolean) instead.
    The use of a Supplier in this form provides a level of indirection that reduces the scope of potential interference with the source. Since the supplier is only invoked after the terminal operation commences, any modifications to the source up to the start of the terminal operation are reflected in the stream result. See Non-Interference for more details.
    
    Parameters:
    
    supplier - a Supplier of a Spliterator.OfLong
    
    characteristics - Spliterator characteristics of the supplied Spliterator.OfLong. The characteristics must be equal to supplier.get().characteristics(), otherwise undefined behavior may occur when terminal operation commences.
    
    parallel - if true then the returned stream is a parallel stream; if false the returned stream is a sequential stream.
    
    Returns:
    
    a new sequential or parallel LongStream
    
    See Also:
    
    longStream(java8.util.Spliterator.OfLong, boolean)
  - doubleStream
```
public static DoubleStream doubleStream(Spliterator.OfDouble spliterator,
                                        boolean parallel)
```
    Creates a new sequential or parallel DoubleStream from a Spliterator.OfDouble.
    The spliterator is only traversed, split, or queried for estimated size after the terminal operation of the stream pipeline commences.
    It is strongly recommended the spliterator report a characteristic of IMMUTABLE or CONCURRENT, or be late-binding. Otherwise, doubleStream(java8.util.function.Supplier, int, boolean) should be used to reduce the scope of potential interference with the source. See Non-Interference for more details.
    
    Parameters:
    
    spliterator - A Spliterator.OfDouble describing the stream elements
    
    parallel - if true then the returned stream is a parallel stream; if false the returned stream is a sequential stream.
    
    Returns:
    
    a new sequential or parallel DoubleStream
  - doubleStream
```
public static DoubleStream doubleStream(Supplier<? extends Spliterator.OfDouble> supplier,
                                        int characteristics,
                                        boolean parallel)
```
    Creates a new sequential or parallel DoubleStream from a Supplier of Spliterator.OfDouble.
    The Supplier.get() method will be invoked on the supplier no more than once, and only after the terminal operation of the stream pipeline commences.
    For spliterators that report a characteristic of IMMUTABLE or CONCURRENT, or that are late-binding, it is likely more efficient to use doubleStream(java8.util.Spliterator.OfDouble, boolean) instead.
    The use of a Supplier in this form provides a level of indirection that reduces the scope of potential interference with the source. Since the supplier is only invoked after the terminal operation commences, any modifications to the source up to the start of the terminal operation are reflected in the stream result. See Non-Interference for more details.
    
    Parameters:
    
    supplier - A Supplier of a Spliterator.OfDouble
    
    characteristics - Spliterator characteristics of the supplied Spliterator.OfDouble. The characteristics must be equal to supplier.get().characteristics(), otherwise undefined behavior may occur when terminal operation commences.
    
    parallel - if true then the returned stream is a parallel stream; if false the returned stream is a sequential stream.
    
    Returns:
    
    a new sequential or parallel DoubleStream
    
    See Also:
    
    doubleStream(java8.util.Spliterator.OfDouble, boolean)

Class StreamSupport

Method Summary

Methods inherited from class java.lang.Object

Method Detail

builder

empty

of

ofNullable

of

iterate

generate

concat

stream

parallelStream

stream

stream

stream

stream

intStream

intStream

longStream

longStream

doubleStream

doubleStream