8020062: Nest StreamBuilder interfaces inside relevant Stream interfaces

Reviewed-by: psandoz, mduigou
Contributed-by: Nbrian goetz <brian.goetz@oracle.com>

src/share/classes/java/util/stream/DoubleStream.java

@@ -662,7 +662,7 @@ public interface DoubleStream extends BaseStream<Double, DoubleStream> {
      *
      * @return a stream builder
      */
-    public static StreamBuilder.OfDouble builder() {
+    public static Builder builder() {
         return new Streams.DoubleStreamBuilderImpl();
     }
 
@@ -766,4 +766,61 @@ public interface DoubleStream extends BaseStream<Double, DoubleStream> {
                 a.spliterator(), b.spliterator());
         return StreamSupport.doubleStream(split, a.isParallel() || b.isParallel());
     }
+
+    /**
+     * A mutable builder for a {@code DoubleStream}.
+     *
+     * <p>A stream builder has a lifecycle, where it starts in a building
+     * phase, during which elements can be added, and then transitions to a
+     * built phase, after which elements may not be added.  The built phase
+     * begins when the {@link #build()} method is called, which creates an
+     * ordered stream whose elements are the elements that were added to the
+     * stream builder, in the order they were added.
+     *
+     * @see DoubleStream#builder()
+     * @since 1.8
+     */
+    public interface Builder extends DoubleConsumer {
+
+        /**
+         * Adds an element to the stream being built.
+         *
+         * @throws IllegalStateException if the builder has already transitioned
+         * to the built state
+         */
+        @Override
+        void accept(double t);
+
+        /**
+         * Adds an element to the stream being built.
+         *
+         * @implSpec
+         * The default implementation behaves as if:
+         * <pre>{@code
+         *     accept(t)
+         *     return this;
+         * }</pre>
+         *
+         * @param t the element to add
+         * @return {@code this} builder
+         * @throws IllegalStateException if the builder has already transitioned
+         * to the built state
+         */
+        default Builder add(double t) {
+            accept(t);
+            return this;
+        }
+
+        /**
+         * Builds the stream, transitioning this builder to the built state.
+         * An {@code IllegalStateException} is thrown if there are further
+         * attempts to operate on the builder after it has entered the built
+         * state.
+         *
+         * @return the built stream
+         * @throws IllegalStateException if the builder has already transitioned
+         * to the built state
+         */
+        DoubleStream build();
+    }
 }

src/share/classes/java/util/stream/IntStream.java

@@ -664,7 +664,7 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
      *
      * @return a stream builder
      */
-    public static StreamBuilder.OfInt builder() {
+    public static Builder builder() {
         return new Streams.IntStreamBuilderImpl();
     }
 
@@ -820,4 +820,61 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
                 a.spliterator(), b.spliterator());
         return StreamSupport.intStream(split, a.isParallel() || b.isParallel());
     }
+
+    /**
+     * A mutable builder for an {@code IntStream}.
+     *
+     * <p>A stream builder has a lifecycle, where it starts in a building
+     * phase, during which elements can be added, and then transitions to a
+     * built phase, after which elements may not be added.  The built phase
+     * begins when the {@link #build()} method is called, which creates an
+     * ordered stream whose elements are the elements that were added to the
+     * stream builder, in the order they were added.
+     *
+     * @see IntStream#builder()
+     * @since 1.8
+     */
+    public interface Builder extends IntConsumer {
+
+        /**
+         * Adds an element to the stream being built.
+         *
+         * @throws IllegalStateException if the builder has already transitioned
+         * to the built state
+         */
+        @Override
+        void accept(int t);
+
+        /**
+         * Adds an element to the stream being built.
+         *
+         * @implSpec
+         * The default implementation behaves as if:
+         * <pre>{@code
+         *     accept(t)
+         *     return this;
+         * }</pre>
+         *
+         * @param t the element to add
+         * @return {@code this} builder
+         * @throws IllegalStateException if the builder has already transitioned
+         * to the built state
+         */
+        default Builder add(int t) {
+            accept(t);
+            return this;
+        }
+
+        /**
+         * Builds the stream, transitioning this builder to the built state.
+         * An {@code IllegalStateException} is thrown if there are further
+         * attempts to operate on the builder after it has entered the built
+         * state.
+         *
+         * @return the built stream
+         * @throws IllegalStateException if the builder has already transitioned to
+         * the built state
+         */
+        IntStream build();
+    }
 }

src/share/classes/java/util/stream/LongStream.java

@@ -655,7 +655,7 @@ public interface LongStream extends BaseStream<Long, LongStream> {
      *
      * @return a stream builder
      */
-    public static StreamBuilder.OfLong builder() {
+    public static Builder builder() {
         return new Streams.LongStreamBuilderImpl();
     }
 
@@ -826,4 +826,61 @@ public interface LongStream extends BaseStream<Long, LongStream> {
                 a.spliterator(), b.spliterator());
         return StreamSupport.longStream(split, a.isParallel() || b.isParallel());
     }
+
+    /**
+     * A mutable builder for a {@code LongStream}.
+     *
+     * <p>A stream builder has a lifecycle, where it starts in a building
+     * phase, during which elements can be added, and then transitions to a
+     * built phase, after which elements may not be added.  The built phase
+     * begins when the {@link #build()} method is called, which creates an
+     * ordered stream whose elements are the elements that were added to the
+     * stream builder, in the order they were added.
+     *
+     * @see LongStream#builder()
+     * @since 1.8
+     */
+    public interface Builder extends LongConsumer {
+
+        /**
+         * Adds an element to the stream being built.
+         *
+         * @throws IllegalStateException if the builder has already transitioned
+         * to the built state
+         */
+        @Override
+        void accept(long t);
+
+        /**
+         * Adds an element to the stream being built.
+         *
+         * @implSpec
+         * The default implementation behaves as if:
+         * <pre>{@code
+         *     accept(t)
+         *     return this;
+         * }</pre>
+         *
+         * @param t the element to add
+         * @return {@code this} builder
+         * @throws IllegalStateException if the builder has already transitioned
+         * to the built state
+         */
+        default Builder add(long t) {
+            accept(t);
+            return this;
+        }
+
+        /**
+         * Builds the stream, transitioning this builder to the built state.
+         * An {@code IllegalStateException} is thrown if there are further
+         * attempts to operate on the builder after it has entered the built
+         * state.
+         *
+         * @return the built stream
+         * @throws IllegalStateException if the builder has already transitioned
+         * to the built state
+         */
+        LongStream build();
+    }
 }

src/share/classes/java/util/stream/Stream.java

@@ -794,7 +794,7 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
      * @param <T> type of elements
      * @return a stream builder
      */
-    public static<T> StreamBuilder<T> builder() {
+    public static<T> Builder<T> builder() {
         return new Streams.StreamBuilderImpl<>();
     }
 
@@ -906,4 +906,65 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
                 (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
         return StreamSupport.stream(split, a.isParallel() || b.isParallel());
     }
+
+    /**
+     * A mutable builder for a {@code Stream}.  This allows the creation of a
+     * {@code Stream} by generating elements individually and adding them to the
+     * {@code Builder} (without the copying overhead that comes from using
+     * an {@code ArrayList} as a temporary buffer.)
+     *
+     * <p>A {@code Stream.Builder} has a lifecycle, where it starts in a building
+     * phase, during which elements can be added, and then transitions to a built
+     * phase, after which elements may not be added.  The built phase begins
+     * when the {@link #build()} method is called, which creates an ordered
+     * {@code Stream} whose elements are the elements that were added to the stream
+     * builder, in the order they were added.
+     *
+     * @param <T> the type of stream elements
+     * @see Stream#builder()
+     * @since 1.8
+     */
+    public interface Builder<T> extends Consumer<T> {
+
+        /**
+         * Adds an element to the stream being built.
+         *
+         * @throws IllegalStateException if the builder has already transitioned to
+         * the built state
+         */
+        @Override
+        void accept(T t);
+
+        /**
+         * Adds an element to the stream being built.
+         *
+         * @implSpec
+         * The default implementation behaves as if:
+         * <pre>{@code
+         *     accept(t)
+         *     return this;
+         * }</pre>
+         *
+         * @param t the element to add
+         * @return {@code this} builder
+         * @throws IllegalStateException if the builder has already transitioned to
+         * the built state
+         */
+        default Builder<T> add(T t) {
+            accept(t);
+            return this;
+        }
+
+        /**
+         * Builds the stream, transitioning this builder to the built state.
+         * An {@code IllegalStateException} is thrown if there are further attempts
+         * to operate on the builder after it has entered the built state.
+         *
+         * @return the built stream
+         * @throws IllegalStateException if the builder has already transitioned to
+         * the built state
+         */
+        Stream<T> build();
+
+    }
 }

src/share/classes/java/util/stream/StreamBuilder.java

-/*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-package java.util.stream;
-
-import java.util.function.Consumer;
-import java.util.function.DoubleConsumer;
-import java.util.function.IntConsumer;
-import java.util.function.LongConsumer;
-
-/**
- * A mutable builder for a {@code Stream}.  This allows the creation of a
- * {@code Stream} by generating elements individually and adding them to the
- * {@code StreamBuilder} (without the copying overhead that comes from using
- * an {@code ArrayList} as a temporary buffer.)
- *
- * <p>A {@code StreamBuilder} has a lifecycle, where it starts in a building
- * phase, during which elements can be added, and then transitions to a built
- * phase, after which elements may not be added.  The built phase begins
- * when the {@link #build()} method is called, which creates an ordered
- * {@code Stream} whose elements are the elements that were added to the stream
- * builder, in the order they were added.
- *
- * <p>Primitive specializations of {@code StreamBuilder} are provided
- * for {@link OfInt int}, {@link OfLong long}, and {@link OfDouble double}
- * values.
- *
- * @param <T> the type of stream elements
- * @see Stream#builder()
- * @since 1.8
- */
-public interface StreamBuilder<T> extends Consumer<T> {
-
-    /**
-     * Adds an element to the stream being built.
-     *
-     * @throws IllegalStateException if the builder has already transitioned to
-     * the built state
-     */
-    @Override
-    void accept(T t);
-
-    /**
-     * Adds an element to the stream being built.
-     *
-     * @implSpec
-     * The default implementation behaves as if:
-     * <pre>{@code
-     *     accept(t)
-     *     return this;
-     * }</pre>
-     *
-     * @param t the element to add
-     * @return {@code this} builder
-     * @throws IllegalStateException if the builder has already transitioned to
-     * the built state
-     */
-    default StreamBuilder<T> add(T t) {
-        accept(t);
-        return this;
-    }
-
-    /**
-     * Builds the stream, transitioning this builder to the built state.
-     * An {@code IllegalStateException} is thrown if there are further attempts
-     * to operate on the builder after it has entered the built state.
-     *
-     * @return the built stream
-     * @throws IllegalStateException if the builder has already transitioned to
-     * the built state
-     */
-    Stream<T> build();
-
-    /**
-     * A mutable builder for an {@code IntStream}.
-     *
-     * <p>A stream builder has a lifecycle, where it starts in a building
-     * phase, during which elements can be added, and then transitions to a
-     * built phase, after which elements may not be added.  The built phase
-     * begins when the {@link #build()} method is called, which creates an
-     * ordered stream whose elements are the elements that were added to the
-     * stream builder, in the order they were added.
-     *
-     * @see IntStream#builder()
-     * @since 1.8
-     */
-    interface OfInt extends IntConsumer {
-
-        /**
-         * Adds an element to the stream being built.
-         *
-         * @throws IllegalStateException if the builder has already transitioned
-         * to the built state
-         */
-        @Override
-        void accept(int t);
-
-        /**
-         * Adds an element to the stream being built.
-         *
-         * @implSpec
-         * The default implementation behaves as if:
-         * <pre>{@code
-         *     accept(t)
-         *     return this;
-         * }</pre>
-         *
-         * @param t the element to add
-         * @return {@code this} builder
-         * @throws IllegalStateException if the builder has already transitioned
-         * to the built state
-         */
-        default StreamBuilder.OfInt add(int t) {
-            accept(t);
-            return this;
-        }
-
-        /**
-         * Builds the stream, transitioning this builder to the built state.
-         * An {@code IllegalStateException} is thrown if there are further
-         * attempts to operate on the builder after it has entered the built
-         * state.
-         *
-         * @return the built stream
-         * @throws IllegalStateException if the builder has already transitioned to
-         * the built state
-         */
-        IntStream build();
-    }
-
-    /**
-     * A mutable builder for a {@code LongStream}.
-     *
-     * <p>A stream builder has a lifecycle, where it starts in a building
-     * phase, during which elements can be added, and then transitions to a
-     * built phase, after which elements may not be added.  The built phase
-     * begins when the {@link #build()} method is called, which creates an
-     * ordered stream whose elements are the elements that were added to the
-     * stream builder, in the order they were added.
-     *
-     * @see LongStream#builder()
-     * @since 1.8
-     */
-    interface OfLong extends LongConsumer {
-
-        /**
-         * Adds an element to the stream being built.
-         *
-         * @throws IllegalStateException if the builder has already transitioned
-         * to the built state
-         */
-        @Override
-        void accept(long t);
-
-        /**
-         * Adds an element to the stream being built.
-         *
-         * @implSpec
-         * The default implementation behaves as if:
-         * <pre>{@code
-         *     accept(t)
-         *     return this;
-         * }</pre>
-         *
-         * @param t the element to add
-         * @return {@code this} builder
-         * @throws IllegalStateException if the builder has already transitioned
-         * to the built state
-         */
-        default StreamBuilder.OfLong add(long t) {
-            accept(t);
-            return this;
-        }
-
-        /**
-         * Builds the stream, transitioning this builder to the built state.
-         * An {@code IllegalStateException} is thrown if there are further
-         * attempts to operate on the builder after it has entered the built
-         * state.
-         *
-         * @return the built stream
-         * @throws IllegalStateException if the builder has already transitioned
-         * to the built state
-         */
-        LongStream build();
-    }
-
-    /**
-     * A mutable builder for a {@code DoubleStream}.
-     *
-     * <p>A stream builder has a lifecycle, where it starts in a building
-     * phase, during which elements can be added, and then transitions to a
-     * built phase, after which elements may not be added.  The built phase
-     * begins when the {@link #build()} method is called, which creates an
-     * ordered stream whose elements are the elements that were added to the
-     * stream builder, in the order they were added.
-     *
-     * @see LongStream#builder()
-     * @since 1.8
-     */
-    interface OfDouble extends DoubleConsumer {
-
-        /**
-         * Adds an element to the stream being built.
-         *
-         * @throws IllegalStateException if the builder has already transitioned
-         * to the built state
-         */
-        @Override
-        void accept(double t);
-
-        /**
-         * Adds an element to the stream being built.
-         *
-         * @implSpec
-         * The default implementation behaves as if:
-         * <pre>{@code
-         *     accept(t)
-         *     return this;
-         * }</pre>
-         *
-         * @param t the element to add
-         * @return {@code this} builder
-         * @throws IllegalStateException if the builder has already transitioned
-         * to the built state
-         */
-        default StreamBuilder.OfDouble add(double t) {
-            accept(t);
-            return this;
-        }
-
-        /**
-         * Builds the stream, transitioning this builder to the built state.
-         * An {@code IllegalStateException} is thrown if there are further
-         * attempts to operate on the builder after it has entered the built
-         * state.
-         *
-         * @return the built stream
-         * @throws IllegalStateException if the builder has already transitioned
-         * to the built state
-         */
-        DoubleStream build();
-    }
-}

src/share/classes/java/util/stream/Streams.java

@@ -317,7 +317,7 @@ final class Streams {
 
     static final class StreamBuilderImpl<T>
             extends AbstractStreamBuilderImpl<T, Spliterator<T>>
-            implements StreamBuilder<T> {
+            implements Stream.Builder<T> {
         // The first element in the stream
         // valid if count == 1
         T first;
@@ -363,7 +363,7 @@ final class Streams {
             }
         }
 
-        public StreamBuilder<T> add(T t) {
+        public Stream.Builder<T> add(T t) {
             accept(t);
             return this;
         }
@@ -409,7 +409,7 @@ final class Streams {
 
     static final class IntStreamBuilderImpl
             extends AbstractStreamBuilderImpl<Integer, Spliterator.OfInt>
-            implements StreamBuilder.OfInt, Spliterator.OfInt {
+            implements IntStream.Builder, Spliterator.OfInt {
         // The first element in the stream
         // valid if count == 1
         int first;
@@ -496,7 +496,7 @@ final class Streams {
 
     static final class LongStreamBuilderImpl
             extends AbstractStreamBuilderImpl<Long, Spliterator.OfLong>
-            implements StreamBuilder.OfLong, Spliterator.OfLong {
+            implements LongStream.Builder, Spliterator.OfLong {
         // The first element in the stream
         // valid if count == 1
         long first;
@@ -583,7 +583,7 @@ final class Streams {
 
     static final class DoubleStreamBuilderImpl
             extends AbstractStreamBuilderImpl<Double, Spliterator.OfDouble>
-            implements StreamBuilder.OfDouble, Spliterator.OfDouble {
+            implements DoubleStream.Builder, Spliterator.OfDouble {
         // The first element in the stream
         // valid if count == 1
         double first;

test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamBuilderTest.java

@@ -35,7 +35,6 @@ import java.util.stream.LambdaTestHelpers;
 import java.util.stream.LongStream;
 import java.util.stream.OpTestCase;
 import java.util.stream.Stream;
-import java.util.stream.StreamBuilder;
 import java.util.stream.TestData;
 
 import static java.util.stream.Collectors.toList;
@@ -89,7 +88,7 @@ public class StreamBuilderTest extends OpTestCase {
 
     @Test(dataProvider = "sizes")
     public void testAfterBuilding(int size) {
-        StreamBuilder<Integer> sb = Stream.builder();
+        Stream.Builder<Integer> sb = Stream.builder();
         IntStream.range(0, size).boxed().forEach(sb);
         sb.build();
 
@@ -101,15 +100,15 @@ public class StreamBuilderTest extends OpTestCase {
     @Test(dataProvider = "sizes")
     public void testStreamBuilder(int size) {
         testStreamBuilder(size, (s) -> {
-            StreamBuilder<Integer> sb = Stream.builder();
+            Stream.Builder<Integer> sb = Stream.builder();
             IntStream.range(0, s).boxed().forEach(sb);
             return sb.build();
         });
 
         testStreamBuilder(size, (s) -> {
-            StreamBuilder<Integer> sb = Stream.builder();
+            Stream.Builder<Integer> sb = Stream.builder();
             IntStream.range(0, s).boxed().forEach(i -> {
-                StreamBuilder<Integer> _sb = sb.add(i);
+                Stream.Builder<Integer> _sb = sb.add(i);
                 assertTrue(sb == _sb);
             });
             return sb.build();
@@ -151,7 +150,7 @@ public class StreamBuilderTest extends OpTestCase {
 
     @Test(dataProvider = "sizes")
     public void testIntAfterBuilding(int size) {
-        StreamBuilder.OfInt sb = IntStream.builder();
+        IntStream.Builder sb = IntStream.builder();
         IntStream.range(0, size).forEach(sb);
         sb.build();
 
@@ -163,15 +162,15 @@ public class StreamBuilderTest extends OpTestCase {
     @Test(dataProvider = "sizes")
     public void testIntStreamBuilder(int size) {
         testIntStreamBuilder(size, (s) -> {
-            StreamBuilder.OfInt sb = IntStream.builder();
+            IntStream.Builder sb = IntStream.builder();
             IntStream.range(0, s).forEach(sb);
             return sb.build();
         });
 
         testIntStreamBuilder(size, (s) -> {
-            StreamBuilder.OfInt sb = IntStream.builder();
+            IntStream.Builder sb = IntStream.builder();
             IntStream.range(0, s).forEach(i -> {
-                StreamBuilder.OfInt _sb = sb.add(i);
+                IntStream.Builder _sb = sb.add(i);
                 assertTrue(sb == _sb);
             });
             return sb.build();
@@ -213,7 +212,7 @@ public class StreamBuilderTest extends OpTestCase {
 
     @Test(dataProvider = "sizes")
     public void testLongAfterBuilding(int size) {
-        StreamBuilder.OfLong sb = LongStream.builder();
+        LongStream.Builder sb = LongStream.builder();
         LongStream.range(0, size).forEach(sb);
         sb.build();
 
@@ -225,15 +224,15 @@ public class StreamBuilderTest extends OpTestCase {
     @Test(dataProvider = "sizes")
     public void testLongStreamBuilder(int size) {
         testLongStreamBuilder(size, (s) -> {
-            StreamBuilder.OfLong sb = LongStream.builder();
+            LongStream.Builder sb = LongStream.builder();
             LongStream.range(0, s).forEach(sb);
             return sb.build();
         });
 
         testLongStreamBuilder(size, (s) -> {
-            StreamBuilder.OfLong sb = LongStream.builder();
+            LongStream.Builder sb = LongStream.builder();
             LongStream.range(0, s).forEach(i -> {
-                StreamBuilder.OfLong _sb = sb.add(i);
+                LongStream.Builder _sb = sb.add(i);
                 assertTrue(sb == _sb);
             });
             return sb.build();
@@ -274,7 +273,7 @@ public class StreamBuilderTest extends OpTestCase {
 
     @Test(dataProvider = "sizes")
     public void testDoubleAfterBuilding(int size) {
-        StreamBuilder.OfDouble sb = DoubleStream.builder();
+        DoubleStream.Builder sb = DoubleStream.builder();
         IntStream.range(0, size).asDoubleStream().forEach(sb);
         sb.build();
 
@@ -286,15 +285,15 @@ public class StreamBuilderTest extends OpTestCase {
     @Test(dataProvider = "sizes")
     public void testDoubleStreamBuilder(int size) {
         testDoubleStreamBuilder(size, (s) -> {
-            StreamBuilder.OfDouble sb = DoubleStream.builder();
+            DoubleStream.Builder sb = DoubleStream.builder();
             IntStream.range(0, s).asDoubleStream().forEach(sb);
             return sb.build();
         });
 
         testDoubleStreamBuilder(size, (s) -> {
-            StreamBuilder.OfDouble sb = DoubleStream.builder();
+            DoubleStream.Builder sb = DoubleStream.builder();
             IntStream.range(0, s).asDoubleStream().forEach(i -> {
-                StreamBuilder.OfDouble _sb = sb.add(i);
+                DoubleStream.Builder _sb = sb.add(i);
                 assertTrue(sb == _sb);
             });
             return sb.build();