Package org.codehaus.groovy.runtime

# Class StreamGroovyMethods

java.lang.Object
org.codehaus.groovy.runtime.StreamGroovyMethods

public class StreamGroovyMethods extends Object

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static DoubleStream`
  `doubleStream(double[] self)`
  Returns a sequential `DoubleStream` with the specified array as its source.
  `static <T> Stream<T>`
  `from(Stream<T> self, EmptyRange range)`
  Returns an empty stream.
  `static <T> Stream<T>`
  `from(Stream<T> self, IntRange range)`
  Returns a (possibly empty) stream.
  `static <T> T`
  `getAt(Stream<T> self, int index)`
  Returns element at `index` or `null`.
  `static <T> List<T>`
  `getAt(Stream<T> self, EmptyRange range)`
  Returns an empty list.
  `static <T> List<T>`
  `getAt(Stream<T> self, IntRange range)`
  Returns element(s) in `range` or an empty list.
  `static IntStream`
  `intStream(int[] self)`
  Returns a sequential `IntStream` with the specified array as its source.
  `static LongStream`
  `longStream(long[] self)`
  Returns a sequential `LongStream` with the specified array as its source.
  `static <T> Stream<T>`
  `plus(Stream<? extends T> lhs, Iterable<? extends T> rhs)`
  Returns a lazily concatenated stream whose elements are all the elements of this stream followed by all the elements of the `Iterable` object.
  `static <T> Stream<T>`
  `plus(Stream<? extends T> lhs, Collection<? extends T> rhs)`
  Returns a lazily concatenated stream whose elements are all the elements of this stream followed by all the elements of the `Collection` object.
  `static <T> Stream<T>`
  `plus(Stream<? extends T> lhs, Stream<? extends T> rhs)`
  Returns a lazily concatenated stream whose elements are all the elements of this stream followed by all the elements of the second stream.
  `static long`
  `size(DoubleStream self)`
  An alias for `count`.
  `static long`
  `size(IntStream self)`
  An alias for `count`.
  `static long`
  `size(LongStream self)`
  An alias for `count`.
  `static long`
  `size(Stream<?> self)`
  An alias for `count`.
  `static Stream<Boolean>`
  `stream(boolean[] self)`
  Returns a sequential `Stream` with the specified array as its source.
  `static Stream<Byte>`
  `stream(byte[] self)`
  Returns a sequential `Stream` with the specified array as its source.
  `static Stream<Character>`
  `stream(char[] self)`
  Returns a sequential `Stream` with the specified array as its source.
  `static Stream<Double>`
  `stream(double[] self)`
  Returns a sequential `Stream` with the specified array as its source.
  `static Stream<Float>`
  `stream(float[] self)`
  Returns a sequential `Stream` with the specified array as its source.
  `static Stream<Integer>`
  `stream(int[] self)`
  Returns a sequential `Stream` with the specified array as its source.
  `static Stream<Long>`
  `stream(long[] self)`
  Returns a sequential `Stream` with the specified array as its source.
  `static Stream<Short>`
  `stream(short[] self)`
  Returns a sequential `Stream` with the specified array as its source.
  `static <T> Stream<T>`
  `stream(Iterable<T> self)`
  Returns a sequential `Stream` with the specified element(s) as its source.
  `static <T> Stream<T>`
  `stream(Enumeration<T> self)`
  Returns a sequential `Stream` with the specified element(s) as its source.
  `static <T> Stream<T>`
  `stream(Iterator<T> self)`
  Returns a sequential `Stream` with the specified element(s) as its source.
  `static <T> Stream<T>`
  `stream(Optional<T> self)`
  If a value is present in the `Optional`, returns a `Stream` with the value as its source or else an empty stream.
  `static DoubleStream`
  `stream(OptionalDouble self)`
  If a value is present in the `OptionalDouble`, returns a `DoubleStream` with the value as its source or else an empty stream.
  `static IntStream`
  `stream(OptionalInt self)`
  If a value is present in the `OptionalInt`, returns an `IntStream` with the value as its source or else an empty stream.
  `static LongStream`
  `stream(OptionalLong self)`
  If a value is present in the `OptionalLong`, returns a `LongStream` with the value as its source or else an empty stream.
  `static <T> Stream<T>`
  `stream(Spliterator<T> self)`
  Returns a sequential `Stream` with the specified element(s) as its source.
  `static <T> Stream<T>`
  `stream(NullObject self)`
  Returns an empty sequential `Stream`.
  `static <T> Stream<T>`
  `stream(T self)`
  Returns a sequential `Stream` containing a single element.
  `static <T> Stream<T>`
  `stream(T[] self)`
  Returns a sequential `Stream` with the specified array as its source.
  `static <T> T[]`
  `toArray(Stream<? extends T> self, Class<T> type)`
  Returns an array containing the elements of the stream.
  `static <T> List<T>`
  `toImmutableList(BaseStream<T,? extends BaseStream> self)`
  Accumulates the elements of stream into an immutable List.
  `static <T> Set<T>`
  `toImmutableSet(BaseStream<T,? extends BaseStream> self)`
  Accumulates the elements of stream into an immutable Set.
  `static <T> Set<T>`
  `toImmutableSet(Stream<T> self)`
  Accumulates the elements of stream into an immutable Set.
  `static <T> List<T>`
  `toList(BaseStream<T,? extends BaseStream> self)`
  Accumulates the elements of stream into a new List.
  `static <T> List<T>`
  `toList(Stream<T> self)`
  Deprecated.
  since 6.0.0; the native `Stream.toList()` (JDK 16+) shadows this and returns an unmodifiable list.
  `static <T> List<T>`
  `toMutableList(BaseStream<T,? extends BaseStream> self)`
  Accumulates the elements of stream into a new mutable List.
  `static <T> List<T>`
  `toMutableList(Stream<T> self)`
  Accumulates the elements of stream into a new mutable List.
  `static <T> Set<T>`
  `toMutableSet(BaseStream<T,? extends BaseStream> self)`
  Accumulates the elements of stream into a new mutable Set.
  `static <T> Set<T>`
  `toMutableSet(Stream<T> self)`
  Accumulates the elements of stream into a new mutable Set.
  `static <T> Set<T>`
  `toSet(BaseStream<T,? extends BaseStream> self)`
  Accumulates the elements of stream into a new Set.
  `static <T> Set<T>`
  `toSet(Stream<T> self)`
  Accumulates the elements of stream into a new Set.

  ### Methods inherited from class java.lang.Object

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

- ## Method Details

  - ### getAt

    public static <T> T getAt(Stream<T> self, int index)
    Returns element at `index` or `null`.

    This is a short-circuiting terminal operation.

         import java.util.stream.Stream
         import static groovy.test.GroovyAssert.shouldFail

         Stream stream = ['foo','bar','baz'].stream()
         shouldFail(IllegalArgumentException) { stream[-1] }

         stream = ['foo','bar','baz'].stream()
         assert stream[0] == 'foo'

         stream = ['foo','bar','baz'].stream()
         assert stream[1] == 'bar'

         stream = ['foo','bar','baz'].stream()
         assert stream[2] == 'baz'

         stream = ['foo','bar','baz'].stream()
         assert stream[3] === null

    Throws:
      `IllegalArgumentException` - if `index` is negative
    Since:
      5.0.0

  - ### getAt

    public static <T> List<T> getAt(Stream<T> self, IntRange range)
    Returns element(s) in `range` or an empty list.

    This is a short-circuiting terminal operation.

         import java.util.stream.Stream
         import static groovy.test.GroovyAssert.shouldFail

         Stream<String> stream = ['foo','bar','baz'].stream()
         shouldFail(IllegalArgumentException) { stream[-1..0] }

         stream = ['foo','bar','baz'].stream()
         shouldFail(IllegalArgumentException) { stream[0..-1] }

         stream = ['foo','bar','baz'].stream()
         assert stream[0..<1] == ['foo']

         stream = ['foo','bar','baz'].stream()
         assert stream[1..<2] == ['bar']

         stream = ['foo','bar','baz'].stream()
         assert stream[2..<3] == ['baz']

         stream = ['foo','bar','baz'].stream()
         assert stream[3..<4] == []

         stream = ['foo','bar','baz'].stream()
         assert stream[0<..2] == ['bar','baz']

         stream = ['foo','bar','baz'].stream()
         assert stream[0..99] == ['foo','bar','baz']

    Throws:
      `IllegalArgumentException` - for negative index or reverse range
    Since:
      5.0.0

  - ### getAt

    public static <T> List<T> getAt(Stream<T> self, EmptyRange range)
    Returns an empty list.

         import java.util.stream.Stream
         Stream<String> stream = ['foo','bar','baz'].stream()
         assert stream[1..<1].isEmpty()

    Since:
      5.0.0

  - ### from

    public static <T> Stream<T> from(Stream<T> self, IntRange range)
    Returns a (possibly empty) stream.

    This is a short-circuiting intermediate operation.

         import java.util.stream.Stream
         import static groovy.test.GroovyAssert.shouldFail

         Stream<String> stream = ['foo','bar','baz'].stream()
         shouldFail(IllegalArgumentException) { stream.from(-1..0) }

         stream = ['foo','bar','baz'].stream()
         shouldFail(IllegalArgumentException) { stream.from(0..-1) }

         stream = ['foo','bar','baz'].stream()
         assert stream.from(0..<1).toList() == ['foo']

         stream = ['foo','bar','baz'].stream()
         assert stream.from(1..<2).toList() == ['bar']

         stream = ['foo','bar','baz'].stream()
         assert stream.from(2..<3).toList() == ['baz']

         stream = ['foo','bar','baz'].stream()
         assert stream.from(3..<4).toList() == []

         stream = ['foo','bar','baz'].stream()
         assert stream.from(0<..2).toList() == ['bar','baz']

         stream = ['foo','bar','baz'].stream()
         assert stream.from(0<..<2).toList() == ['bar']

         stream = ['foo','bar','baz'].stream()
         assert stream.from(0..99).toList() == ['foo','bar','baz']

    Throws:
      `IllegalArgumentException` - for negative index or reverse range
    Since:
      5.0.0

  - ### from

    public static <T> Stream<T> from(Stream<T> self, EmptyRange range)
    Returns an empty stream.

         import java.util.stream.Stream
         Stream<String> stream = ['foo','bar','baz'].stream()
         assert !stream.from(1..<1).findAny().isPresent()

    Since:
      5.0.0

  - ### plus

    public static <T> Stream<T> plus(Stream<? extends T> lhs, Collection<? extends T> rhs)
    Returns a lazily concatenated stream whose elements are all the elements of this stream followed by all the elements of the `Collection` object.

         import java.util.stream.Stream
         assert (Stream.of(1) + [2]).toList() == [1,2]
         assert (Stream.of(1) + []).toList() == [1]

    Since:
      4.0.0

  - ### plus

    public static <T> Stream<T> plus(Stream<? extends T> lhs, Iterable<? extends T> rhs)
    Returns a lazily concatenated stream whose elements are all the elements of this stream followed by all the elements of the `Iterable` object.

         import java.util.stream.Stream
         assert (Stream.of(1) + [2]).toList() == [1,2]
         assert (Stream.of(1) + []).toList() == [1]

    Since:
      4.0.0

  - ### plus

    public static <T> Stream<T> plus(Stream<? extends T> lhs, Stream<? extends T> rhs)
    Returns a lazily concatenated stream whose elements are all the elements of this stream followed by all the elements of the second stream.

         import java.util.stream.Stream
         assert (Stream.of(1) + Stream.<Integer>empty()).toList() == [1]
         assert (Stream.of(1) + Stream.of(2)).toList() == [1,2]
         assert (Stream.of(1) + [2].stream()).toList() == [1,2]

    Since:
      4.0.0

  - ### stream

    public static <T> Stream<T> stream(T self)
    Returns a sequential `Stream` containing a single element.

         def item = 'string'
         assert item.stream().toList() == ['string']
         assert item.stream().findFirst().isPresent()

    Since:
      3.0.0

  - ### stream

    public static <T> Stream<T> stream(T[] self)
    Returns a sequential `Stream` with the specified array as its source.
    Type Parameters:
      `T` - The type of the array elements
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      2.5.0

  - ### stream

    public static Stream<Integer> stream(int[] self)
    Returns a sequential `Stream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      2.5.0

  - ### stream

    public static Stream<Long> stream(long[] self)
    Returns a sequential `Stream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      2.5.0

  - ### stream

    public static Stream<Double> stream(double[] self)
    Returns a sequential `Stream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      2.5.0

  - ### stream

    public static Stream<Character> stream(char[] self)
    Returns a sequential `Stream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      2.5.0

  - ### stream

    public static Stream<Byte> stream(byte[] self)
    Returns a sequential `Stream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      2.5.0

  - ### stream

    public static Stream<Short> stream(short[] self)
    Returns a sequential `Stream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      2.5.0

  - ### stream

    public static Stream<Boolean> stream(boolean[] self)
    Returns a sequential `Stream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      2.5.0

  - ### stream

    public static Stream<Float> stream(float[] self)
    Returns a sequential `Stream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      2.5.0

  - ### stream

    public static <T> Stream<T> stream(Enumeration<T> self)
    Returns a sequential `Stream` with the specified element(s) as its source.

         def tokens = new StringTokenizer('one two')
         assert tokens.stream().toList() == ['one', 'two']

    Since:
      3.0.0

  - ### stream

    public static <T> Stream<T> stream(Iterable<T> self)
    Returns a sequential `Stream` with the specified element(s) as its source.

         class Items implements Iterable {
           Iterator<String> iterator() {
             ['one', 'two'].iterator()
           }
         }
         def items = new Items()
         assert items.stream().toList() == ['one', 'two']

    Since:
      3.0.0

  - ### stream

    public static <T> Stream<T> stream(Iterator<T> self)
    Returns a sequential `Stream` with the specified element(s) as its source.

         [].iterator().stream().toList().isEmpty()
         ['one', 'two'].iterator().stream().toList() == ['one', 'two']

    Since:
      3.0.0

  - ### stream

    public static <T> Stream<T> stream(Spliterator<T> self)
    Returns a sequential `Stream` with the specified element(s) as its source.

         assert [].spliterator().stream().toList().isEmpty()
         assert ['one', 'two'].spliterator().stream().toList() == ['one', 'two']

    Since:
      3.0.0

  - ### stream

    public static <T> Stream<T> stream(NullObject self)
    Returns an empty sequential `Stream`.

         def item = null
         assert item.stream().toList() == []
         assert !item.stream().findFirst().isPresent()

    Since:
      3.0.0

  - ### stream

    public static <T> Stream<T> stream(Optional<T> self)
    If a value is present in the `Optional`, returns a `Stream` with the value as its source or else an empty stream.
    Since:
      3.0.0

  - ### stream

    public static IntStream stream(OptionalInt self)
    If a value is present in the `OptionalInt`, returns an `IntStream` with the value as its source or else an empty stream.
    Since:
      3.0.0

  - ### stream

    public static LongStream stream(OptionalLong self)
    If a value is present in the `OptionalLong`, returns a `LongStream` with the value as its source or else an empty stream.
    Since:
      3.0.0

  - ### stream

    public static DoubleStream stream(OptionalDouble self)
    If a value is present in the `OptionalDouble`, returns a `DoubleStream` with the value as its source or else an empty stream.
    Since:
      3.0.0

  - ### intStream

    public static IntStream intStream(int[] self)
    Returns a sequential `IntStream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      3.0.8

  - ### longStream

    public static LongStream longStream(long[] self)
    Returns a sequential `LongStream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      3.0.8

  - ### doubleStream

    public static DoubleStream doubleStream(double[] self)
    Returns a sequential `DoubleStream` with the specified array as its source.
    Parameters:
      `self` - The array, assumed to be unmodified during use
    Returns:
      a `Stream` for the array
    Since:
      3.0.8

  - ### size

    public static long size(Stream<?> self)
    An alias for `count`. Returns the count of elements for this stream. This is a terminal operator and, depending on the underlying stream, may invoke the stream pipeline, leaving it empty after this call. Care should be taken with stream pipelines that have side effects. This method should not be called on an infinite stream.

         assert [1, 2, 3].stream().size() == 3

    Parameters:
      `self` - A Stream
    Returns:
      the count of elements in this stream
    Since:
      5.0.0
    See Also:
      - `Stream.count()`

  - ### size

    public static long size(IntStream self)
    An alias for `count`. Returns the count of elements for this stream. This is a terminal operator and, depending on the underlying stream, may invoke the stream pipeline, leaving it empty after this call. Care should be taken with stream pipelines that have side effects. This method should not be called on an infinite stream.

         int[] nums = [1, 2, 3]
         assert nums.intStream().size() == 3

    Parameters:
      `self` - An IntStream
    Returns:
      the count of elements in this stream
    Since:
      5.0.0
    See Also:
      - `IntStream.count()`

  - ### size

    public static long size(LongStream self)
    An alias for `count`. Returns the count of elements for this stream. This is a terminal operator and, depending on the underlying stream, may invoke the stream pipeline, leaving it empty after this call. Care should be taken with stream pipelines that have side effects. This method should not be called on an infinite stream.

         long[] nums = [1, 2, 3]
         assert nums.longStream().size() == 3

    Parameters:
      `self` - A LongStream
    Returns:
      the count of elements in this stream
    Since:
      5.0.0
    See Also:
      - `LongStream.count()`

  - ### size

    public static long size(DoubleStream self)
    An alias for `count`. Returns the count of elements for this stream. This is a terminal operator and, depending on the underlying stream, may invoke the stream pipeline, leaving it empty after this call. Care should be taken with stream pipelines that have side effects. This method should not be called on an infinite stream.

         double[] nums = [1.0d, 2.0d, 3.0d]
         assert nums.doubleStream().size() == 3

    Parameters:
      `self` - A DoubleStream
    Returns:
      the count of elements in this stream
    Since:
      5.0.0
    See Also:
      - `DoubleStream.count()`

  - ### toArray

    public static <T> T[] toArray(Stream<? extends T> self, Class<T> type)
    Returns an array containing the elements of the stream.

         import static groovy.test.GroovyAssert.shouldFail

         assert Arrays.equals([].stream().toArray(Object), new Object[0])
         assert Arrays.equals([].stream().toArray(String), new String[0])
         assert Arrays.equals([].stream().toArray(String[]), new String[0][])
         assert Arrays.equals(['x'].stream().toArray(Object), ['x'].toArray())
         assert Arrays.equals(['x'].stream().toArray(String), ['x'] as String[])
         assert Arrays.deepEquals([['x'] as String[]].stream().toArray(String[]), [['x'] as String[]] as String[][])
         assert Arrays.equals(['x'].stream().toArray(CharSequence), ['x'] as CharSequence[])

         shouldFail(ArrayStoreException) {
             ['x'].stream().toArray(Thread)
         }

         shouldFail(IllegalArgumentException) {
             ['x'].stream().toArray((Class) null)
         }

         // Stream#toArray(IntFunction) should still be used for closure literal:
         assert Arrays.equals(['x'].stream().toArray { n -> new String[n] }, ['x'] as String[])

         // Stream#toArray(IntFunction) should still be used for method reference:
         assert Arrays.equals(['x'].stream().toArray(String[]::new), ['x'] as String[])

    Parameters:
      `self` - the stream
      `type` - the array element type
    Since:
      3.0.4

  - ### toList

    @Deprecated(since="6.0.0") public static <T> List<T> toList(Stream<T> self)
    Deprecated.
    since 6.0.0; the native `Stream.toList()` (JDK 16+) shadows this and returns an unmodifiable list. If you need a mutable list, call `toMutableList(Stream)`; otherwise use `stream.toList()` directly (faster than this extension because it skips the `Collectors` path).
    Accumulates the elements of stream into a new mutable List.

    Note: since JDK 16, `Stream` has a native `toList()` method that returns an unmodifiable list. Java instance methods take precedence over GDK extensions in both `@CompileStatic` and dynamic dispatch, so `stream.toList()` now resolves to the native call and yields an immutable result — not a fresh `ArrayList` as it did pre-JDK 16. Direct callers of this extension method are pointed at the explicit replacements; see the deprecation note.

    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the stream
    Returns:
      a new mutable `java.util.List` instance
    Since:
      2.5.0

  - ### toList

    public static <T> List<T> toList(BaseStream<T,? extends BaseStream> self)
    Accumulates the elements of stream into a new List.
    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the `java.util.stream.BaseStream`
    Returns:
      a new `java.util.List` instance
    Since:
      2.5.0

  - ### toSet

    public static <T> Set<T> toSet(Stream<T> self)
    Accumulates the elements of stream into a new Set.
    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the stream
    Returns:
      a new `java.util.Set` instance
    Since:
      2.5.0

  - ### toSet

    public static <T> Set<T> toSet(BaseStream<T,? extends BaseStream> self)
    Accumulates the elements of stream into a new Set.
    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the `java.util.stream.BaseStream`
    Returns:
      a new `java.util.Set` instance
    Since:
      2.5.0

  - ### toMutableList

    public static <T> List<T> toMutableList(Stream<T> self)
    Accumulates the elements of stream into a new mutable List.

    Explicit alternative to the native `Stream.toList()` (which returns an unmodifiable list since JDK 16). Use this when you need to add to, remove from, or sort the returned list. The returned list is a concrete `ArrayList` — the cached collector pins the supplier so this is contract, not happenstance.

         import java.util.stream.Stream
         import org.codehaus.groovy.runtime.StreamGroovyMethods
         def list = StreamGroovyMethods.toMutableList(Stream.of('a', 'b'))
         assert list == ['a', 'b']
         list << 'c'   // mutable — no UnsupportedOperationException
         assert list == ['a', 'b', 'c']

    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the stream
    Returns:
      a new mutable `java.util.List` instance
    Since:
      6.0.0

  - ### toMutableList

    public static <T> List<T> toMutableList(BaseStream<T,? extends BaseStream> self)
    Accumulates the elements of stream into a new mutable List.

    Explicit-mutability alias for `toList(BaseStream)`, symmetric with `toMutableList(Stream)`.

    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the `java.util.stream.BaseStream`
    Returns:
      a new mutable `java.util.List` instance
    Since:
      6.0.0

  - ### toMutableSet

    public static <T> Set<T> toMutableSet(Stream<T> self)
    Accumulates the elements of stream into a new mutable Set.

    Explicit-mutability alias for `toSet(Stream)`. Provided defensively so user intent stays unambiguous if a future JDK release adds a native `Stream.toSet()` (which would shadow the GDK extension the way native `Stream.toList()` did in JDK 16).

    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the stream
    Returns:
      a new mutable `java.util.Set` instance
    Since:
      6.0.0

  - ### toMutableSet

    public static <T> Set<T> toMutableSet(BaseStream<T,? extends BaseStream> self)
    Accumulates the elements of stream into a new mutable Set.

    Explicit-mutability alias for `toSet(BaseStream)`, symmetric with `toMutableSet(Stream)`.

    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the `java.util.stream.BaseStream`
    Returns:
      a new mutable `java.util.Set` instance
    Since:
      6.0.0

  - ### toImmutableList

    public static <T> List<T> toImmutableList(BaseStream<T,? extends BaseStream> self)
    Accumulates the elements of stream into an immutable List.
    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the `java.util.stream.BaseStream`
    Returns:
      an immutable `java.util.List` instance
    Since:
      6.0.0

  - ### toImmutableSet

    public static <T> Set<T> toImmutableSet(Stream<T> self)
    Accumulates the elements of stream into an immutable Set.

    No native `Stream.toSet()` exists, so this provides the immutable counterpart to `toSet(Stream)`. Null elements are preserved (unlike `Collectors.toUnmodifiableSet()` which rejects nulls); the returned set is unmodifiable and mutation attempts throw `UnsupportedOperationException`. Returns the canonical empty set (`Collections.emptySet()`) when the stream is empty.

         import java.util.stream.Stream
         import static groovy.test.GroovyAssert.shouldFail
         import static org.codehaus.groovy.runtime.StreamGroovyMethods.toImmutableSet
         def set = toImmutableSet(Stream.of('a', null, 'b', 'a'))
         assert set == ['a', null, 'b'] as Set
         shouldFail(UnsupportedOperationException) { set << 'c' }
         assert toImmutableSet(Stream.<String>empty()) === Collections.emptySet()

    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the stream
    Returns:
      an immutable `java.util.Set` instance
    Since:
      6.0.0

  - ### toImmutableSet

    public static <T> Set<T> toImmutableSet(BaseStream<T,? extends BaseStream> self)
    Accumulates the elements of stream into an immutable Set.

    See `toImmutableSet(Stream)` for the null-tolerance and empty-set semantics — this overload is the `BaseStream` counterpart with the same contract.

    Type Parameters:
      `T` - the type of element
    Parameters:
      `self` - the `java.util.stream.BaseStream`
    Returns:
      an immutable `java.util.Set` instance
    Since:
      6.0.0