Package: org.codehaus.groovy.runtime

## [Java] Class StreamGroovyMethods

- org.codehaus.groovy.runtime.StreamGroovyMethods

-     public class StreamGroovyMethods
      extends Object

- - ### Methods Summary

    Methods
    Type Params | Return Type | Name and description
    --- | --- | ---
    `` | `public static DoubleStream` | `doubleStream(double[] self)` Returns a sequential DoubleStream with the specified array as its source.
    `<T>` | `public static Stream<T>` | `from(Stream<T> self, IntRange range)` Returns a (possibly empty) stream.
    `<T>` | `public static Stream<T>` | `from(Stream<T> self, EmptyRange range)` Returns an empty stream.
    `<T>` | `public static T` | `getAt(Stream<T> self, int index)` Returns element at `index` or `null`.
    `<T>` | `public static List<T>` | `getAt(Stream<T> self, IntRange range)` Returns element(s) in `range` or an empty list.
    `<T>` | `public static List<T>` | `getAt(Stream<T> self, EmptyRange range)` Returns an empty list.
    `` | `public static IntStream` | `intStream(int[] self)` Returns a sequential IntStream with the specified array as its source.
    `` | `public static LongStream` | `longStream(long[] self)` Returns a sequential LongStream with the specified array as its source.
    `<T>` | `public static 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.
    `<T>` | `public static 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.
    `<T>` | `public static 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.
    `` | `public static long` | `size(Stream<?> self)` An alias for `count`.
    `` | `public static long` | `size(IntStream self)` An alias for `count`.
    `` | `public static long` | `size(LongStream self)` An alias for `count`.
    `` | `public static long` | `size(DoubleStream self)` An alias for `count`.
    `<T>` | `public static Stream<T>` | `stream(T self)` Returns a sequential Stream containing a single element.
    `<T>` | `public static Stream<T>` | `stream(T[] self)` Returns a sequential Stream with the specified array as its source.
    `` | `public static Stream<Integer>` | `stream(int[] self)` Returns a sequential Stream with the specified array as its source.
    `` | `public static Stream<Long>` | `stream(long[] self)` Returns a sequential Stream with the specified array as its source.
    `` | `public static Stream<Double>` | `stream(double[] self)` Returns a sequential Stream with the specified array as its source.
    `` | `public static Stream<Character>` | `stream(char[] self)` Returns a sequential Stream with the specified array as its source.
    `` | `public static Stream<Byte>` | `stream(byte[] self)` Returns a sequential Stream with the specified array as its source.
    `` | `public static Stream<Short>` | `stream(short[] self)` Returns a sequential Stream with the specified array as its source.
    `` | `public static Stream<Boolean>` | `stream(boolean[] self)` Returns a sequential Stream with the specified array as its source.
    `` | `public static Stream<Float>` | `stream(float[] self)` Returns a sequential Stream with the specified array as its source.
    `<T>` | `public static Stream<T>` | `stream(Enumeration<T> self)` Returns a sequential Stream with the specified element(s) as its source.
    `<T>` | `public static Stream<T>` | `stream(Iterable<T> self)` Returns a sequential Stream with the specified element(s) as its source.
    `<T>` | `public static Stream<T>` | `stream(Iterator<T> self)` Returns a sequential Stream with the specified element(s) as its source.
    `<T>` | `public static Stream<T>` | `stream(Spliterator<T> self)` Returns a sequential Stream with the specified element(s) as its source.
    `<T>` | `public static Stream<T>` | `stream(NullObject self)` Returns an empty sequential Stream.
    `<T>` | `public static 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.
    `` | `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.
    `` | `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.
    `` | `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.
    `<T>` | `public static T[]` | `toArray(Stream<? extends T> self, Class<T> type)` Returns an array containing the elements of the stream.
    `<T>` | `public static List<T>` | `toImmutableList(BaseStream<T, ? extends BaseStream> self)` Accumulates the elements of stream into an immutable List.
    `<T>` | `public static Set<T>` | `toImmutableSet(Stream<T> self)` Accumulates the elements of stream into an immutable Set.
    `<T>` | `public static Set<T>` | `toImmutableSet(BaseStream<T, ? extends BaseStream> self)` Accumulates the elements of stream into an immutable Set.
    `<T>` | `public static List<T>` | `toList(Stream<T> self)` Accumulates the elements of stream into a new mutable List.
    `<T>` | `public static List<T>` | `toList(BaseStream<T, ? extends BaseStream> self)` Accumulates the elements of stream into a new List.
    `<T>` | `public static List<T>` | `toMutableList(Stream<T> self)` Accumulates the elements of stream into a new mutable List.
    `<T>` | `public static List<T>` | `toMutableList(BaseStream<T, ? extends BaseStream> self)` Accumulates the elements of stream into a new mutable List.
    `<T>` | `public static Set<T>` | `toMutableSet(Stream<T> self)` Accumulates the elements of stream into a new mutable Set.
    `<T>` | `public static Set<T>` | `toMutableSet(BaseStream<T, ? extends BaseStream> self)` Accumulates the elements of stream into a new mutable Set.
    `<T>` | `public static Set<T>` | `toSet(Stream<T> self)` Accumulates the elements of stream into a new Set.
    `<T>` | `public static Set<T>` | `toSet(BaseStream<T, ? extends BaseStream> self)` Accumulates the elements of stream into a new Set.

  - ### Inherited Methods Summary

    Inherited Methods
    Methods inherited from class | Name
    --- | ---
    `class Object` | `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### 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

    - #### 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### 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
      See Also:
        Stream.count
      Since:
        5.0.0

    - #### 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
      See Also:
        IntStream.count
      Since:
        5.0.0

    - #### 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
      See Also:
        LongStream.count
      Since:
        5.0.0

    - #### 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
      See Also:
        DoubleStream.count
      Since:
        5.0.0

    - #### <T> public static 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

    - #### <T> public static 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

    - #### 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

    - #### 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

    - #### 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

    - #### 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

    - #### 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

    - #### 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

    - #### 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

    - #### 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### <T> public static 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

    - #### 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

    - #### 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

    - #### 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

    - #### <T> public static 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

    - #### <T> public static List<T> toImmutableList(BaseStream<T, ? extends BaseStream> self)

      Accumulates the elements of stream into an immutable List.

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

    - #### <T> public static 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()

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

    - #### <T> public static 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.

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

    - #### <T> @Deprecated(since = "6.0.0")
      public static List<T> toList(Stream<T> self)

      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.

      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).
      Parameters:
        `self` - the stream
      Type Parameters:
        `T` - the type of element
      Returns:
        a new mutable `java.util.List` instance
      Since:
        2.5.0

    - #### <T> public static List<T> toList(BaseStream<T, ? extends BaseStream> self)

      Accumulates the elements of stream into a new List.

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

    - #### <T> public static 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']

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

    - #### <T> public static 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).

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

    - #### <T> public static 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).

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

    - #### <T> public static 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).

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

    - #### <T> public static Set<T> toSet(Stream<T> self)

      Accumulates the elements of stream into a new Set.

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

    - #### <T> public static Set<T> toSet(BaseStream<T, ? extends BaseStream> self)

      Accumulates the elements of stream into a new Set.

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