changeset 7678:be096613bfb5

8019395: Consolidate StreamSupport.{stream,parallelStream} into a single method Reviewed-by: henryjen, briangoetz
author psandoz
date Wed, 03 Jul 2013 21:43:49 +0200
parents 5b6f94559589
children b3ca5fb77e2c
files src/share/classes/java/io/BufferedReader.java src/share/classes/java/lang/CharSequence.java src/share/classes/java/nio/X-Buffer.java.template src/share/classes/java/nio/file/Files.java src/share/classes/java/util/Arrays.java src/share/classes/java/util/BitSet.java src/share/classes/java/util/Collection.java src/share/classes/java/util/Collections.java src/share/classes/java/util/jar/JarFile.java src/share/classes/java/util/regex/Pattern.java src/share/classes/java/util/stream/DoubleStream.java src/share/classes/java/util/stream/IntStream.java src/share/classes/java/util/stream/LongStream.java src/share/classes/java/util/stream/Stream.java src/share/classes/java/util/stream/StreamSupport.java src/share/classes/java/util/stream/Streams.java src/share/classes/java/util/zip/ZipFile.java test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java test/java/util/stream/bootlib/java/util/stream/TestData.java test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java test/java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest.java test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java
diffstat 28 files changed, 262 insertions(+), 460 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/java/io/BufferedReader.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/io/BufferedReader.java	Wed Jul 03 21:43:49 2013 +0200
@@ -587,6 +587,6 @@
                 }
             }
         };
-        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iter, Spliterator.ORDERED));
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iter, Spliterator.ORDERED), false);
     }
 }
--- a/src/share/classes/java/lang/CharSequence.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/lang/CharSequence.java	Wed Jul 03 21:43:49 2013 +0200
@@ -156,7 +156,8 @@
                         new CharIterator(),
                         length(),
                         Spliterator.ORDERED),
-                Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED);
+                Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
+                false);
     }
 
     /**
@@ -227,6 +228,7 @@
                 Spliterators.spliteratorUnknownSize(
                         new CodePointIterator(),
                         Spliterator.ORDERED),
-                Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED);
+                Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
+                false);
     }
 }
--- a/src/share/classes/java/nio/X-Buffer.java.template	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/nio/X-Buffer.java.template	Wed Jul 03 21:43:49 2013 +0200
@@ -1495,7 +1495,7 @@
 #end[char]
     public $Streamtype$Stream $type$s() {
         return StreamSupport.$streamtype$Stream(() -> new $Type$BufferSpliterator(this),
-            Buffer.SPLITERATOR_CHARACTERISTICS);
+            Buffer.SPLITERATOR_CHARACTERISTICS, false);
     }
 
 #end[streamableType]
--- a/src/share/classes/java/nio/file/Files.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/nio/file/Files.java	Wed Jul 03 21:43:49 2013 +0200
@@ -3269,9 +3269,10 @@
             }
         };
 
-        return new DelegatingCloseableStream<>(ds,
-            StreamSupport.stream(Spliterators.spliteratorUnknownSize(it,
-                                                                     Spliterator.DISTINCT)));
+        Stream<Path> s = StreamSupport.stream(
+                Spliterators.spliteratorUnknownSize(it, Spliterator.DISTINCT),
+                false);
+        return new DelegatingCloseableStream<>(ds, s);
     }
 
     /**
@@ -3358,9 +3359,12 @@
         throws IOException
     {
         FileTreeIterator iterator = new FileTreeIterator(start, maxDepth, options);
-        return new DelegatingCloseableStream<>(iterator,
-            StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.DISTINCT))
-                   .map(entry -> entry.file()));
+
+        Stream<Path> s = StreamSupport.stream(
+                Spliterators.spliteratorUnknownSize(iterator, Spliterator.DISTINCT),
+                false).
+                map(entry -> entry.file());
+        return new DelegatingCloseableStream<>(iterator, s);
     }
 
     /**
@@ -3455,10 +3459,13 @@
         throws IOException
     {
         FileTreeIterator iterator = new FileTreeIterator(start, maxDepth, options);
-        return new DelegatingCloseableStream<>(iterator,
-            StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.DISTINCT))
-                   .filter(entry -> matcher.test(entry.file(), entry.attributes()))
-                   .map(entry -> entry.file()));
+
+        Stream<Path> s = StreamSupport.stream(
+                Spliterators.spliteratorUnknownSize(iterator, Spliterator.DISTINCT),
+                false).
+                filter(entry -> matcher.test(entry.file(), entry.attributes())).
+                map(entry -> entry.file());
+        return new DelegatingCloseableStream<>(iterator, s);
     }
 
     /**
--- a/src/share/classes/java/util/Arrays.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/Arrays.java	Wed Jul 03 21:43:49 2013 +0200
@@ -4966,7 +4966,7 @@
      * @since 1.8
      */
     public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
-        return StreamSupport.stream(spliterator(array, startInclusive, endExclusive));
+        return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
     }
 
     /**
@@ -4996,7 +4996,7 @@
      * @since 1.8
      */
     public static IntStream stream(int[] array, int startInclusive, int endExclusive) {
-        return StreamSupport.intStream(spliterator(array, startInclusive, endExclusive));
+        return StreamSupport.intStream(spliterator(array, startInclusive, endExclusive), false);
     }
 
     /**
@@ -5026,7 +5026,7 @@
      * @since 1.8
      */
     public static LongStream stream(long[] array, int startInclusive, int endExclusive) {
-        return StreamSupport.longStream(spliterator(array, startInclusive, endExclusive));
+        return StreamSupport.longStream(spliterator(array, startInclusive, endExclusive), false);
     }
 
     /**
@@ -5056,6 +5056,6 @@
      * @since 1.8
      */
     public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
-        return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive));
+        return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive), false);
     }
 }
--- a/src/share/classes/java/util/BitSet.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/BitSet.java	Wed Jul 03 21:43:49 2013 +0200
@@ -1231,6 +1231,7 @@
                         new BitSetIterator(), cardinality(),
                         Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.SORTED),
                 Spliterator.SIZED | Spliterator.SUBSIZED |
-                        Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.SORTED);
+                        Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.SORTED,
+                false);
     }
 }
--- a/src/share/classes/java/util/Collection.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/Collection.java	Wed Jul 03 21:43:49 2013 +0200
@@ -557,7 +557,7 @@
      * @since 1.8
      */
     default Stream<E> stream() {
-        return StreamSupport.stream(spliterator());
+        return StreamSupport.stream(spliterator(), false);
     }
 
     /**
@@ -578,6 +578,6 @@
      * @since 1.8
      */
     default Stream<E> parallelStream() {
-        return StreamSupport.parallelStream(spliterator());
+        return StreamSupport.stream(spliterator(), true);
     }
 }
--- a/src/share/classes/java/util/Collections.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/Collections.java	Wed Jul 03 21:43:49 2013 +0200
@@ -1674,12 +1674,12 @@
 
             @Override
             public Stream<Entry<K,V>> stream() {
-                return StreamSupport.stream(spliterator());
+                return StreamSupport.stream(spliterator(), false);
             }
 
             @Override
             public Stream<Entry<K,V>> parallelStream() {
-                return StreamSupport.parallelStream(spliterator());
+                return StreamSupport.stream(spliterator(), true);
             }
 
             public Iterator<Map.Entry<K,V>> iterator() {
--- a/src/share/classes/java/util/jar/JarFile.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/jar/JarFile.java	Wed Jul 03 21:43:49 2013 +0200
@@ -272,7 +272,7 @@
         return StreamSupport.stream(Spliterators.spliterator(
                 new JarEntryIterator(), size(),
                 Spliterator.ORDERED | Spliterator.DISTINCT |
-                        Spliterator.IMMUTABLE | Spliterator.NONNULL));
+                        Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
     }
 
     private class JarFileEntry extends JarEntry {
--- a/src/share/classes/java/util/regex/Pattern.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/regex/Pattern.java	Wed Jul 03 21:43:49 2013 +0200
@@ -5815,6 +5815,6 @@
             }
         }
         return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
-                new MatcherIterator(), Spliterator.ORDERED | Spliterator.NONNULL));
+                new MatcherIterator(), Spliterator.ORDERED | Spliterator.NONNULL), false);
     }
 }
--- a/src/share/classes/java/util/stream/DoubleStream.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/stream/DoubleStream.java	Wed Jul 03 21:43:49 2013 +0200
@@ -672,7 +672,7 @@
      * @return an empty sequential stream
      */
     public static DoubleStream empty() {
-        return StreamSupport.doubleStream(Spliterators.emptyDoubleSpliterator());
+        return StreamSupport.doubleStream(Spliterators.emptyDoubleSpliterator(), false);
     }
 
     /**
@@ -682,7 +682,7 @@
      * @return a singleton sequential stream
      */
     public static DoubleStream of(double t) {
-        return StreamSupport.doubleStream(new Streams.DoubleStreamBuilderImpl(t));
+        return StreamSupport.doubleStream(new Streams.DoubleStreamBuilderImpl(t), false);
     }
 
     /**
@@ -730,7 +730,7 @@
         };
         return StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(
                 iterator,
-                Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL));
+                Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
     }
 
     /**
@@ -744,7 +744,7 @@
     public static DoubleStream generate(DoubleSupplier s) {
         Objects.requireNonNull(s);
         return StreamSupport.doubleStream(
-                new StreamSpliterators.InfiniteSupplyingSpliterator.OfDouble(Long.MAX_VALUE, s));
+                new StreamSpliterators.InfiniteSupplyingSpliterator.OfDouble(Long.MAX_VALUE, s), false);
     }
 
     /**
@@ -764,8 +764,6 @@
 
         Spliterator.OfDouble split = new Streams.ConcatSpliterator.OfDouble(
                 a.spliterator(), b.spliterator());
-        return (a.isParallel() || b.isParallel())
-               ? StreamSupport.doubleParallelStream(split)
-               : StreamSupport.doubleStream(split);
+        return StreamSupport.doubleStream(split, a.isParallel() || b.isParallel());
     }
 }
--- a/src/share/classes/java/util/stream/IntStream.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/stream/IntStream.java	Wed Jul 03 21:43:49 2013 +0200
@@ -674,7 +674,7 @@
      * @return an empty sequential stream
      */
     public static IntStream empty() {
-        return StreamSupport.intStream(Spliterators.emptyIntSpliterator());
+        return StreamSupport.intStream(Spliterators.emptyIntSpliterator(), false);
     }
 
     /**
@@ -684,7 +684,7 @@
      * @return a singleton sequential stream
      */
     public static IntStream of(int t) {
-        return StreamSupport.intStream(new Streams.IntStreamBuilderImpl(t));
+        return StreamSupport.intStream(new Streams.IntStreamBuilderImpl(t), false);
     }
 
     /**
@@ -732,7 +732,7 @@
         };
         return StreamSupport.intStream(Spliterators.spliteratorUnknownSize(
                 iterator,
-                Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL));
+                Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
     }
 
     /**
@@ -746,7 +746,7 @@
     public static IntStream generate(IntSupplier s) {
         Objects.requireNonNull(s);
         return StreamSupport.intStream(
-                new StreamSpliterators.InfiniteSupplyingSpliterator.OfInt(Long.MAX_VALUE, s));
+                new StreamSpliterators.InfiniteSupplyingSpliterator.OfInt(Long.MAX_VALUE, s), false);
     }
 
     /**
@@ -771,7 +771,7 @@
             return empty();
         } else {
             return StreamSupport.intStream(
-                    new Streams.RangeIntSpliterator(startInclusive, endExclusive, false));
+                    new Streams.RangeIntSpliterator(startInclusive, endExclusive, false), false);
         }
     }
 
@@ -797,7 +797,7 @@
             return empty();
         } else {
             return StreamSupport.intStream(
-                    new Streams.RangeIntSpliterator(startInclusive, endInclusive, true));
+                    new Streams.RangeIntSpliterator(startInclusive, endInclusive, true), false);
         }
     }
 
@@ -818,8 +818,6 @@
 
         Spliterator.OfInt split = new Streams.ConcatSpliterator.OfInt(
                 a.spliterator(), b.spliterator());
-        return (a.isParallel() || b.isParallel())
-               ? StreamSupport.intParallelStream(split)
-               : StreamSupport.intStream(split);
+        return StreamSupport.intStream(split, a.isParallel() || b.isParallel());
     }
 }
--- a/src/share/classes/java/util/stream/LongStream.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/stream/LongStream.java	Wed Jul 03 21:43:49 2013 +0200
@@ -665,7 +665,7 @@
      * @return an empty sequential stream
      */
     public static LongStream empty() {
-        return StreamSupport.longStream(Spliterators.emptyLongSpliterator());
+        return StreamSupport.longStream(Spliterators.emptyLongSpliterator(), false);
     }
 
     /**
@@ -675,7 +675,7 @@
      * @return a singleton sequential stream
      */
     public static LongStream of(long t) {
-        return StreamSupport.longStream(new Streams.LongStreamBuilderImpl(t));
+        return StreamSupport.longStream(new Streams.LongStreamBuilderImpl(t), false);
     }
 
     /**
@@ -723,7 +723,7 @@
         };
         return StreamSupport.longStream(Spliterators.spliteratorUnknownSize(
                 iterator,
-                Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL));
+                Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
     }
 
     /**
@@ -737,7 +737,7 @@
     public static LongStream generate(LongSupplier s) {
         Objects.requireNonNull(s);
         return StreamSupport.longStream(
-                new StreamSpliterators.InfiniteSupplyingSpliterator.OfLong(Long.MAX_VALUE, s));
+                new StreamSpliterators.InfiniteSupplyingSpliterator.OfLong(Long.MAX_VALUE, s), false);
     }
 
     /**
@@ -769,7 +769,7 @@
             return concat(range(startInclusive, m), range(m, endExclusive));
         } else {
             return StreamSupport.longStream(
-                    new Streams.RangeLongSpliterator(startInclusive, endExclusive, false));
+                    new Streams.RangeLongSpliterator(startInclusive, endExclusive, false), false);
         }
     }
 
@@ -803,7 +803,7 @@
             return concat(range(startInclusive, m), rangeClosed(m, endInclusive));
         } else {
             return StreamSupport.longStream(
-                    new Streams.RangeLongSpliterator(startInclusive, endInclusive, true));
+                    new Streams.RangeLongSpliterator(startInclusive, endInclusive, true), false);
         }
     }
 
@@ -824,8 +824,6 @@
 
         Spliterator.OfLong split = new Streams.ConcatSpliterator.OfLong(
                 a.spliterator(), b.spliterator());
-        return (a.isParallel() || b.isParallel())
-               ? StreamSupport.longParallelStream(split)
-               : StreamSupport.longStream(split);
+        return StreamSupport.longStream(split, a.isParallel() || b.isParallel());
     }
 }
--- a/src/share/classes/java/util/stream/Stream.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/stream/Stream.java	Wed Jul 03 21:43:49 2013 +0200
@@ -805,7 +805,7 @@
      * @return an empty sequential stream
      */
     public static<T> Stream<T> empty() {
-        return StreamSupport.stream(Spliterators.<T>emptySpliterator());
+        return StreamSupport.stream(Spliterators.<T>emptySpliterator(), false);
     }
 
     /**
@@ -816,7 +816,7 @@
      * @return a singleton sequential stream
      */
     public static<T> Stream<T> of(T t) {
-        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t));
+        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
     }
 
     /**
@@ -866,7 +866,7 @@
         };
         return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
                 iterator,
-                Spliterator.ORDERED | Spliterator.IMMUTABLE));
+                Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
     }
 
     /**
@@ -881,7 +881,7 @@
     public static<T> Stream<T> generate(Supplier<T> s) {
         Objects.requireNonNull(s);
         return StreamSupport.stream(
-                new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s));
+                new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
     }
 
     /**
@@ -904,8 +904,6 @@
         @SuppressWarnings("unchecked")
         Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
                 (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
-        return (a.isParallel() || b.isParallel())
-               ? StreamSupport.parallelStream(split)
-               : StreamSupport.stream(split);
+        return StreamSupport.stream(split, a.isParallel() || b.isParallel());
     }
 }
--- a/src/share/classes/java/util/stream/StreamSupport.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/stream/StreamSupport.java	Wed Jul 03 21:43:49 2013 +0200
@@ -47,7 +47,8 @@
     private StreamSupport() {}
 
     /**
-     * Creates a new sequential {@code Stream} from a {@code Spliterator}.
+     * Creates a new sequential or parallel {@code Stream} from a
+     * {@code Spliterator}.
      *
      * <p>The spliterator is only traversed, split, or queried for estimated
      * size after the terminal operation of the stream pipeline commences.
@@ -55,50 +56,28 @@
      * <p>It is strongly recommended the spliterator report a characteristic of
      * {@code IMMUTABLE} or {@code CONCURRENT}, or be
      * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
-     * {@link #stream(Supplier, int)} should be used to
-     * reduce the scope of potential interference with the source.  See
+     * {@link #stream(java.util.function.Supplier, int, boolean)} should be used
+     * to reduce the scope of potential interference with the source.  See
      * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
      * more details.
      *
      * @param <T> the type of stream elements
      * @param spliterator a {@code Spliterator} describing the stream elements
-     * @return a new sequential {@code Stream}
+     * @param parallel if {@code true} then the returned stream is a parallel
+     *        stream; if {@code false} the returned stream is a sequential
+     *        stream.
+     * @return a new sequential or parallel {@code Stream}
      */
-    public static <T> Stream<T> stream(Spliterator<T> spliterator) {
+    public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
         Objects.requireNonNull(spliterator);
         return new ReferencePipeline.Head<>(spliterator,
                                             StreamOpFlag.fromCharacteristics(spliterator),
-                                            false);
+                                            parallel);
     }
 
     /**
-     * Creates a new parallel {@code Stream} from a {@code Spliterator}.
-     *
-     * <p>The spliterator is only traversed, split, or queried for estimated
-     * size after the terminal operation of the stream pipeline commences.
-     *
-     * <p>It is strongly recommended the spliterator report a characteristic of
-     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
-     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
-     * {@link #stream(Supplier, int)} should be used to
-     * reduce the scope of potential interference with the source.  See
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param <T> the type of stream elements
-     * @param spliterator a {@code Spliterator} describing the stream elements
-     * @return a new parallel {@code Stream}
-     */
-    public static <T> Stream<T> parallelStream(Spliterator<T> spliterator) {
-        Objects.requireNonNull(spliterator);
-        return new ReferencePipeline.Head<>(spliterator,
-                                            StreamOpFlag.fromCharacteristics(spliterator),
-                                            true);
-    }
-
-    /**
-     * Creates a new sequential {@code Stream} from a {@code Supplier} of
-     * {@code Spliterator}.
+     * Creates a new sequential or parallel {@code Stream} from a
+     * {@code Supplier} of {@code Spliterator}.
      *
      * <p>The {@link Supplier#get()} method will be invoked on the supplier no
      * more than once, and after the terminal operation of the stream pipeline
@@ -107,7 +86,8 @@
      * <p>For spliterators that report a characteristic of {@code IMMUTABLE}
      * or {@code CONCURRENT}, or that are
      * <a href="../Spliterator.html#binding">late-binding</a>, it is likely
-     * more efficient to use {@link #stream(java.util.Spliterator)} instead.
+     * more efficient to use {@link #stream(java.util.Spliterator, boolean)}
+     * instead.
      * The use of a {@code 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
@@ -116,25 +96,55 @@
      * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
      * more details.
      *
-     * @param <T> the type of stream elements
      * @param supplier a {@code Supplier} of a {@code Spliterator}
      * @param characteristics Spliterator characteristics of the supplied
      *        {@code Spliterator}.  The characteristics must be equal to
-     *        {@code source.get().getCharacteristics()}.
-     * @return a new sequential {@code Stream}
-     * @see #stream(Spliterator)
+     *        {@code supplier.get().characteristics()}.
+     * @param parallel if {@code true} then the returned stream is a parallel
+     *        stream; if {@code false} the returned stream is a sequential
+     *        stream.
+     * @return a new sequential or parallel {@code Stream}
+     * @see #stream(java.util.Spliterator, boolean)
      */
     public static <T> Stream<T> stream(Supplier<? extends Spliterator<T>> supplier,
-                                      int characteristics) {
+                                       int characteristics,
+                                       boolean parallel) {
         Objects.requireNonNull(supplier);
         return new ReferencePipeline.Head<>(supplier,
                                             StreamOpFlag.fromCharacteristics(characteristics),
-                                            false);
+                                            parallel);
     }
 
     /**
-     * Creates a new parallel {@code Stream} from a {@code Supplier} of
-     * {@code Spliterator}.
+     * Creates a new sequential or parallel {@code IntStream} from a
+     * {@code Spliterator.OfInt}.
+     *
+     * <p>The spliterator is only traversed, split, or queried for estimated size
+     * after the terminal operation of the stream pipeline commences.
+     *
+     * <p>It is strongly recommended the spliterator report a characteristic of
+     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
+     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
+     * {@link #intStream(java.util.function.Supplier, int, boolean)} should be
+     * used to reduce the scope of potential interference with the source.  See
+     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
+     * more details.
+     *
+     * @param spliterator a {@code Spliterator.OfInt} describing the stream elements
+     * @param parallel if {@code true} then the returned stream is a parallel
+     *        stream; if {@code false} the returned stream is a sequential
+     *        stream.
+     * @return a new sequential or parallel {@code IntStream}
+     */
+    public static IntStream intStream(Spliterator.OfInt spliterator, boolean parallel) {
+        return new IntPipeline.Head<>(spliterator,
+                                      StreamOpFlag.fromCharacteristics(spliterator),
+                                      parallel);
+    }
+
+    /**
+     * Creates a new sequential or parallel {@code IntStream} from a
+     * {@code Supplier} of {@code Spliterator.OfInt}.
      *
      * <p>The {@link Supplier#get()} method will be invoked on the supplier no
      * more than once, and after the terminal operation of the stream pipeline
@@ -143,89 +153,8 @@
      * <p>For spliterators that report a characteristic of {@code IMMUTABLE}
      * or {@code CONCURRENT}, or that are
      * <a href="../Spliterator.html#binding">late-binding</a>, it is likely
-     * more efficient to use {@link #stream(Spliterator)} instead.
-     * The use of a {@code 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
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param <T> the type of stream elements
-     * @param supplier a {@code Supplier} of a {@code Spliterator}
-     * @param characteristics Spliterator characteristics of the supplied
-     *        {@code Spliterator}.  The characteristics must be equal to
-     *        {@code source.get().getCharacteristics()}
-     * @return a new parallel {@code Stream}
-     * @see #parallelStream(Spliterator)
-     */
-    public static <T> Stream<T> parallelStream(Supplier<? extends Spliterator<T>> supplier,
-                                              int characteristics) {
-        Objects.requireNonNull(supplier);
-        return new ReferencePipeline.Head<>(supplier,
-                                            StreamOpFlag.fromCharacteristics(characteristics),
-                                            true);
-    }
-
-    /**
-     * Creates a new sequential {@code IntStream} from a {@code Spliterator.OfInt}.
-     *
-     * <p>The spliterator is only traversed, split, or queried for estimated size
-     * after the terminal operation of the stream pipeline commences.
-     *
-     * <p>It is strongly recommended the spliterator report a characteristic of
-     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
-     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
-     * {@link #stream(Supplier, int)}} should be used to
-     * reduce the scope of potential interference with the source.  See
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param spliterator a {@code Spliterator.OfInt} describing the stream elements
-     * @return a new sequential {@code IntStream}
-     */
-    public static IntStream intStream(Spliterator.OfInt spliterator) {
-        return new IntPipeline.Head<>(spliterator,
-                                      StreamOpFlag.fromCharacteristics(spliterator),
-                                      false);
-    }
-
-    /**
-     * Creates a new parallel {@code IntStream} from a {@code Spliterator.OfInt}.
-     *
-     * <p>he spliterator is only traversed, split, or queried for estimated size
-     * after the terminal operation of the stream pipeline commences.
-     *
-     * <p>It is strongly recommended the spliterator report a characteristic of
-     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
-     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
-     * {@link #stream(Supplier, int)}} should be used to
-     * reduce the scope of potential interference with the source.  See
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param spliterator a {@code Spliterator.OfInt} describing the stream elements
-     * @return a new parallel {@code IntStream}
-     */
-    public static IntStream intParallelStream(Spliterator.OfInt spliterator) {
-        return new IntPipeline.Head<>(spliterator,
-                                      StreamOpFlag.fromCharacteristics(spliterator),
-                                      true);
-    }
-
-    /**
-     * Creates a new sequential {@code IntStream} from a {@code Supplier} of
-     * {@code Spliterator.OfInt}.
-     *
-     * <p>The {@link Supplier#get()} method will be invoked on the supplier no
-     * more than once, and after the terminal operation of the stream pipeline
-     * commences.
-     *
-     * <p>For spliterators that report a characteristic of {@code IMMUTABLE}
-     * or {@code CONCURRENT}, or that are
-     * <a href="../Spliterator.html#binding">late-binding</a>, it is likely
-     * more efficient to use {@link #intStream(Spliterator.OfInt)} instead.
+     * more efficient to use {@link #intStream(java.util.Spliterator.OfInt, boolean)}
+     * instead.
      * The use of a {@code 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
@@ -237,20 +166,52 @@
      * @param supplier a {@code Supplier} of a {@code Spliterator.OfInt}
      * @param characteristics Spliterator characteristics of the supplied
      *        {@code Spliterator.OfInt}.  The characteristics must be equal to
-     *        {@code source.get().getCharacteristics()}
-     * @return a new sequential {@code IntStream}
-     * @see #intStream(Spliterator.OfInt)
+     *        {@code supplier.get().characteristics()}
+     * @param parallel if {@code true} then the returned stream is a parallel
+     *        stream; if {@code false} the returned stream is a sequential
+     *        stream.
+     * @return a new sequential or parallel {@code IntStream}
+     * @see #intStream(java.util.Spliterator.OfInt, boolean)
      */
     public static IntStream intStream(Supplier<? extends Spliterator.OfInt> supplier,
-                                      int characteristics) {
+                                      int characteristics,
+                                      boolean parallel) {
         return new IntPipeline.Head<>(supplier,
                                       StreamOpFlag.fromCharacteristics(characteristics),
-                                      false);
+                                      parallel);
     }
 
     /**
-     * Creates a new parallel {@code IntStream} from a {@code Supplier} of
-     * {@code Spliterator.OfInt}.
+     * Creates a new sequential or parallel {@code LongStream} from a
+     * {@code Spliterator.OfLong}.
+     *
+     * <p>The spliterator is only traversed, split, or queried for estimated
+     * size after the terminal operation of the stream pipeline commences.
+     *
+     * <p>It is strongly recommended the spliterator report a characteristic of
+     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
+     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
+     * {@link #longStream(java.util.function.Supplier, int, boolean)} should be
+     * used to reduce the scope of potential interference with the source.  See
+     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
+     * more details.
+     *
+     * @param spliterator a {@code Spliterator.OfLong} describing the stream elements
+     * @param parallel if {@code true} then the returned stream is a parallel
+     *        stream; if {@code false} the returned stream is a sequential
+     *        stream.
+     * @return a new sequential or parallel {@code LongStream}
+     */
+    public static LongStream longStream(Spliterator.OfLong spliterator,
+                                        boolean parallel) {
+        return new LongPipeline.Head<>(spliterator,
+                                       StreamOpFlag.fromCharacteristics(spliterator),
+                                       parallel);
+    }
+
+    /**
+     * Creates a new sequential or parallel {@code LongStream} from a
+     * {@code Supplier} of {@code Spliterator.OfLong}.
      *
      * <p>The {@link Supplier#get()} method will be invoked on the supplier no
      * more than once, and after the terminal operation of the stream pipeline
@@ -259,88 +220,8 @@
      * <p>For spliterators that report a characteristic of {@code IMMUTABLE}
      * or {@code CONCURRENT}, or that are
      * <a href="../Spliterator.html#binding">late-binding</a>, it is likely
-     * more efficient to use {@link #intStream(Spliterator.OfInt)} instead.
-     * The use of a {@code 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
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param supplier a {@code Supplier} of a {@code Spliterator.OfInt}
-     * @param characteristics Spliterator characteristics of the supplied
-     *        {@code Spliterator.OfInt}.  The characteristics must be equal to
-     *        {@code source.get().getCharacteristics()}
-     * @return a new parallel {@code IntStream}
-     * @see #intParallelStream(Spliterator.OfInt)
-     */
-    public static IntStream intParallelStream(Supplier<? extends Spliterator.OfInt> supplier,
-                                              int characteristics) {
-        return new IntPipeline.Head<>(supplier,
-                                      StreamOpFlag.fromCharacteristics(characteristics),
-                                      true);
-    }
-
-    /**
-     * Creates a new sequential {@code LongStream} from a {@code Spliterator.OfLong}.
-     *
-     * <p>The spliterator is only traversed, split, or queried for estimated
-     * size after the terminal operation of the stream pipeline commences.
-     *
-     * <p>It is strongly recommended the spliterator report a characteristic of
-     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
-     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
-     * {@link #stream(Supplier, int)} should be used to
-     * reduce the scope of potential interference with the source.  See
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param spliterator a {@code Spliterator.OfLong} describing the stream
-     * elements
-     * @return a new sequential {@code LongStream}
-     */
-    public static LongStream longStream(Spliterator.OfLong spliterator) {
-        return new LongPipeline.Head<>(spliterator,
-                                       StreamOpFlag.fromCharacteristics(spliterator),
-                                       false);
-    }
-
-    /**
-     * Creates a new parallel {@code LongStream} from a {@code Spliterator.OfLong}.
-     *
-     * <p>The spliterator is only traversed, split, or queried for estimated
-     * size after the terminal operation of the stream pipeline commences.
-     *
-     * <p>It is strongly recommended the spliterator report a characteristic of
-     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
-     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
-     * {@link #stream(Supplier, int)} should be used to
-     * reduce the scope of potential interference with the source.  See
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param spliterator a {@code Spliterator.OfLong} describing the stream elements
-     * @return a new parallel {@code LongStream}
-     */
-    public static LongStream longParallelStream(Spliterator.OfLong spliterator) {
-        return new LongPipeline.Head<>(spliterator,
-                                       StreamOpFlag.fromCharacteristics(spliterator),
-                                       true);
-    }
-
-    /**
-     * Creates a new sequential {@code LongStream} from a {@code Supplier} of
-     * {@code Spliterator.OfLong}.
-     *
-     * <p>The {@link Supplier#get()} method will be invoked on the supplier no
-     * more than once, and after the terminal operation of the stream pipeline
-     * commences.
-     *
-     * <p>For spliterators that report a characteristic of {@code IMMUTABLE}
-     * or {@code CONCURRENT}, or that are
-     * <a href="../Spliterator.html#binding">late-binding</a>, it is likely
-     * more efficient to use {@link #longStream(Spliterator.OfLong)} instead.
+     * more efficient to use {@link #longStream(java.util.Spliterator.OfLong, boolean)}
+     * instead.
      * The use of a {@code 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
@@ -352,20 +233,52 @@
      * @param supplier a {@code Supplier} of a {@code Spliterator.OfLong}
      * @param characteristics Spliterator characteristics of the supplied
      *        {@code Spliterator.OfLong}.  The characteristics must be equal to
-     *        {@code source.get().getCharacteristics()}
-     * @return a new sequential {@code LongStream}
-     * @see #longStream(Spliterator.OfLong)
+     *        {@code supplier.get().characteristics()}
+     * @param parallel if {@code true} then the returned stream is a parallel
+     *        stream; if {@code false} the returned stream is a sequential
+     *        stream.
+     * @return a new sequential or parallel {@code LongStream}
+     * @see #longStream(java.util.Spliterator.OfLong, boolean)
      */
     public static LongStream longStream(Supplier<? extends Spliterator.OfLong> supplier,
-                                        int characteristics) {
+                                        int characteristics,
+                                        boolean parallel) {
         return new LongPipeline.Head<>(supplier,
                                        StreamOpFlag.fromCharacteristics(characteristics),
-                                       false);
+                                       parallel);
     }
 
     /**
-     * Creates a new parallel {@code LongStream} from a {@code Supplier} of
-     * {@code Spliterator.OfLong}.
+     * Creates a new sequential or parallel {@code DoubleStream} from a
+     * {@code Spliterator.OfDouble}.
+     *
+     * <p>The spliterator is only traversed, split, or queried for estimated size
+     * after the terminal operation of the stream pipeline commences.
+     *
+     * <p>It is strongly recommended the spliterator report a characteristic of
+     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
+     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
+     * {@link #doubleStream(java.util.function.Supplier, int, boolean)} should
+     * be used to reduce the scope of potential interference with the source.  See
+     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
+     * more details.
+     *
+     * @param spliterator A {@code Spliterator.OfDouble} describing the stream elements
+     * @param parallel if {@code true} then the returned stream is a parallel
+     *        stream; if {@code false} the returned stream is a sequential
+     *        stream.
+     * @return a new sequential or parallel {@code DoubleStream}
+     */
+    public static DoubleStream doubleStream(Spliterator.OfDouble spliterator,
+                                            boolean parallel) {
+        return new DoublePipeline.Head<>(spliterator,
+                                         StreamOpFlag.fromCharacteristics(spliterator),
+                                         parallel);
+    }
+
+    /**
+     * Creates a new sequential or parallel {@code DoubleStream} from a
+     * {@code Supplier} of {@code Spliterator.OfDouble}.
      *
      * <p>The {@link Supplier#get()} method will be invoked on the supplier no
      * more than once, and after the terminal operation of the stream pipeline
@@ -374,89 +287,8 @@
      * <p>For spliterators that report a characteristic of {@code IMMUTABLE}
      * or {@code CONCURRENT}, or that are
      * <a href="../Spliterator.html#binding">late-binding</a>, it is likely
-     * more efficient to use {@link #longStream(Spliterator.OfLong)} instead.
-     * The use of a {@code 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
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param supplier A {@code Supplier} of a {@code Spliterator.OfLong}
-     * @param characteristics Spliterator characteristics of the supplied
-     *        {@code Spliterator.OfLong}.  The characteristics must be equal to
-     *        {@code source.get().getCharacteristics()}
-     * @return A new parallel {@code LongStream}
-     * @see #longParallelStream(Spliterator.OfLong)
-     */
-    public static LongStream longParallelStream(Supplier<? extends Spliterator.OfLong> supplier,
-                                                int characteristics) {
-        return new LongPipeline.Head<>(supplier,
-                                       StreamOpFlag.fromCharacteristics(characteristics),
-                                       true);
-    }
-
-    /**
-     * Creates a new sequential {@code DoubleStream} from a
-     * {@code Spliterator.OfDouble}.
-     *
-     * <p>The spliterator is only traversed, split, or queried for estimated size
-     * after the terminal operation of the stream pipeline commences.
-     *
-     * <p>It is strongly recommended the spliterator report a characteristic of
-     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
-     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
-     * {@link #stream(Supplier, int)} should be used to
-     * reduce the scope of potential interference with the source.  See
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param spliterator A {@code Spliterator.OfDouble} describing the stream elements
-     * @return A new sequential {@code DoubleStream}
-     */
-    public static DoubleStream doubleStream(Spliterator.OfDouble spliterator) {
-        return new DoublePipeline.Head<>(spliterator,
-                                         StreamOpFlag.fromCharacteristics(spliterator),
-                                         false);
-    }
-
-    /**
-     * Creates a new parallel {@code DoubleStream} from a
-     * {@code Spliterator.OfDouble}.
-     *
-     * <p>The spliterator is only traversed, split, or queried for estimated size
-     * after the terminal operation of the stream pipeline commences.
-     *
-     * <p>It is strongly recommended the spliterator report a characteristic of
-     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
-     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
-     * {@link #stream(Supplier, int)} should be used to
-     * reduce the scope of potential interference with the source.  See
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param spliterator A {@code Spliterator.OfDouble} describing the stream elements
-     * @return A new parallel {@code DoubleStream}
-     */
-    public static DoubleStream doubleParallelStream(Spliterator.OfDouble spliterator) {
-        return new DoublePipeline.Head<>(spliterator,
-                                         StreamOpFlag.fromCharacteristics(spliterator),
-                                         true);
-    }
-
-    /**
-     * Creates a new sequential {@code DoubleStream} from a {@code Supplier} of
-     * {@code Spliterator.OfDouble}.
-     * <p>
-     * The {@link Supplier#get()} method will be invoked on the supplier no
-     * more than once, and after the terminal operation of the stream pipeline
-     * commences.
-     * <p>
-     * For spliterators that report a characteristic of {@code IMMUTABLE}
-     * or {@code CONCURRENT}, or that are
-     * <a href="../Spliterator.html#binding">late-binding</a>, it is likely
-     * more efficient to use {@link #doubleStream(Spliterator.OfDouble)} instead.
+     * more efficient to use {@link #doubleStream(java.util.Spliterator.OfDouble, boolean)}
+     * instead.
      * The use of a {@code 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
@@ -468,48 +300,18 @@
      * @param supplier A {@code Supplier} of a {@code Spliterator.OfDouble}
      * @param characteristics Spliterator characteristics of the supplied
      *        {@code Spliterator.OfDouble}.  The characteristics must be equal to
-     *        {@code source.get().getCharacteristics()}
-     * @return A new sequential {@code DoubleStream}
-     * @see #doubleStream(Spliterator.OfDouble)
+     *        {@code supplier.get().characteristics()}
+     * @param parallel if {@code true} then the returned stream is a parallel
+     *        stream; if {@code false} the returned stream is a sequential
+     *        stream.
+     * @return a new sequential or parallel {@code DoubleStream}
+     * @see #doubleStream(java.util.Spliterator.OfDouble, boolean)
      */
     public static DoubleStream doubleStream(Supplier<? extends Spliterator.OfDouble> supplier,
-                                            int characteristics) {
+                                            int characteristics,
+                                            boolean parallel) {
         return new DoublePipeline.Head<>(supplier,
                                          StreamOpFlag.fromCharacteristics(characteristics),
-                                         false);
-    }
-
-    /**
-     * Creates a new parallel {@code DoubleStream} from a {@code Supplier} of
-     * {@code Spliterator.OfDouble}.
-     *
-     * <p>The {@link Supplier#get()} method will be invoked on the supplier no
-     * more than once, and after the terminal operation of the stream pipeline
-     * commences.
-     *
-     * <p>For spliterators that report a characteristic of {@code IMMUTABLE}
-     * or {@code CONCURRENT}, or that are
-     * <a href="../Spliterator.html#binding">late-binding</a>, it is likely
-     * more efficient to use {@link #doubleStream(Spliterator.OfDouble)} instead.
-     * The use of a {@code 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
-     * <a href="package-summary.html#Non-Interference">Non-Interference</a> for
-     * more details.
-     *
-     * @param supplier a {@code Supplier} of a {@code Spliterator.OfDouble}
-     * @param characteristics Spliterator characteristics of the supplied
-     *        {@code Spliterator.OfDouble}.  The characteristics must be equal to
-     *        {@code source.get().getCharacteristics()}
-     * @return a new parallel {@code DoubleStream}
-     * @see #doubleParallelStream(Spliterator.OfDouble)
-     */
-    public static DoubleStream doubleParallelStream(Supplier<? extends Spliterator.OfDouble> supplier,
-                                                    int characteristics) {
-        return new DoublePipeline.Head<>(supplier,
-                                         StreamOpFlag.fromCharacteristics(characteristics),
-                                         true);
+                                         parallel);
     }
 }
--- a/src/share/classes/java/util/stream/Streams.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/stream/Streams.java	Wed Jul 03 21:43:49 2013 +0200
@@ -25,10 +25,7 @@
 package java.util.stream;
 
 import java.util.Comparator;
-import java.util.Objects;
 import java.util.Spliterator;
-import java.util.Spliterators;
-import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.DoubleConsumer;
 import java.util.function.IntConsumer;
@@ -379,7 +376,7 @@
                 count = -count - 1;
                 // Use this spliterator if 0 or 1 elements, otherwise use
                 // the spliterator of the spined buffer
-                return (c < 2) ? StreamSupport.stream(this) : StreamSupport.stream(buffer.spliterator());
+                return (c < 2) ? StreamSupport.stream(this, false) : StreamSupport.stream(buffer.spliterator(), false);
             }
 
             throw new IllegalStateException();
@@ -466,7 +463,7 @@
                 count = -count - 1;
                 // Use this spliterator if 0 or 1 elements, otherwise use
                 // the spliterator of the spined buffer
-                return (c < 2) ? StreamSupport.intStream(this) : StreamSupport.intStream(buffer.spliterator());
+                return (c < 2) ? StreamSupport.intStream(this, false) : StreamSupport.intStream(buffer.spliterator(), false);
             }
 
             throw new IllegalStateException();
@@ -553,7 +550,7 @@
                 count = -count - 1;
                 // Use this spliterator if 0 or 1 elements, otherwise use
                 // the spliterator of the spined buffer
-                return (c < 2) ? StreamSupport.longStream(this) : StreamSupport.longStream(buffer.spliterator());
+                return (c < 2) ? StreamSupport.longStream(this, false) : StreamSupport.longStream(buffer.spliterator(), false);
             }
 
             throw new IllegalStateException();
@@ -640,7 +637,7 @@
                 count = -count - 1;
                 // Use this spliterator if 0 or 1 elements, otherwise use
                 // the spliterator of the spined buffer
-                return (c < 2) ? StreamSupport.doubleStream(this) : StreamSupport.doubleStream(buffer.spliterator());
+                return (c < 2) ? StreamSupport.doubleStream(this, false) : StreamSupport.doubleStream(buffer.spliterator(), false);
             }
 
             throw new IllegalStateException();
--- a/src/share/classes/java/util/zip/ZipFile.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/src/share/classes/java/util/zip/ZipFile.java	Wed Jul 03 21:43:49 2013 +0200
@@ -551,7 +551,7 @@
         return StreamSupport.stream(Spliterators.spliterator(
                 new ZipEntryIterator(), size(),
                 Spliterator.ORDERED | Spliterator.DISTINCT |
-                        Spliterator.IMMUTABLE | Spliterator.NONNULL));
+                        Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
     }
 
     private ZipEntry getZipEntry(String name, long jzentry) {
--- a/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java	Wed Jul 03 21:43:49 2013 +0200
@@ -140,9 +140,9 @@
         void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
             DoubleStream s = m.apply(data.parallelStream());
             Spliterator.OfDouble sp = s.spliterator();
-            DoubleStream ss = StreamSupport.doubleParallelStream(() -> sp,
-                                                                 StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
-                                                                 | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED));
+            DoubleStream ss = StreamSupport.doubleStream(() -> sp,
+                                                         StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
+                                                         | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED), true);
             for (double t : ss.toArray())
                 b.accept(t);
         }
--- a/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java	Wed Jul 03 21:43:49 2013 +0200
@@ -140,9 +140,10 @@
         void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
             IntStream s = m.apply(data.parallelStream());
             Spliterator.OfInt sp = s.spliterator();
-            IntStream ss = StreamSupport.intParallelStream(() -> sp,
-                                                           StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
-                                                           | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED));
+            IntStream ss = StreamSupport.intStream(() -> sp,
+                                                   StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
+                                                   | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED),
+                                                   true);
             for (int t : ss.toArray())
                 b.accept(t);
         }
--- a/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java	Wed Jul 03 21:43:49 2013 +0200
@@ -140,9 +140,9 @@
         void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
             LongStream s = m.apply(data.parallelStream());
             Spliterator.OfLong sp = s.spliterator();
-            LongStream ss = StreamSupport.longParallelStream(() -> sp,
-                                                             StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
-                                                             | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED));
+            LongStream ss = StreamSupport.longStream(() -> sp,
+                                                     StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
+                                                     | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED), true);
             for (long t : ss.toArray())
                 b.accept(t);
         }
--- a/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java	Wed Jul 03 21:43:49 2013 +0200
@@ -151,9 +151,9 @@
         void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
             Stream<U> s = m.apply(data.parallelStream());
             Spliterator<U> sp = s.spliterator();
-            Stream<U> ss = StreamSupport.parallelStream(() -> sp,
-                                                        StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
-                                                        | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED));
+            Stream<U> ss = StreamSupport.stream(() -> sp,
+                                                StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
+                                                | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED), true);
             for (Object t : ss.toArray())
                 b.accept((U) t);
         }
--- a/test/java/util/stream/bootlib/java/util/stream/TestData.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/bootlib/java/util/stream/TestData.java	Wed Jul 03 21:43:49 2013 +0200
@@ -87,8 +87,8 @@
 
         public static <T> OfRef<T> ofSpinedBuffer(String name, SpinedBuffer<T> buffer) {
             return new AbstractTestData.RefTestData<>(name, buffer,
-                                                      b -> StreamSupport.stream(b.spliterator()),
-                                                      b -> StreamSupport.parallelStream(b.spliterator()),
+                                                      b -> StreamSupport.stream(b.spliterator(), false),
+                                                      b -> StreamSupport.stream(b.spliterator(), true),
                                                       SpinedBuffer::spliterator,
                                                       b -> (int) b.count());
         }
@@ -103,8 +103,8 @@
 
         public static <T> OfRef<T> ofRefNode(String name, Node<T> node) {
             return new AbstractTestData.RefTestData<>(name, node,
-                                                      n -> StreamSupport.stream(n::spliterator, Spliterator.SIZED | Spliterator.ORDERED),
-                                                      n -> StreamSupport.parallelStream(n::spliterator, Spliterator.SIZED | Spliterator.ORDERED),
+                                                      n -> StreamSupport.stream(n::spliterator, Spliterator.SIZED | Spliterator.ORDERED, false),
+                                                      n -> StreamSupport.stream(n::spliterator, Spliterator.SIZED | Spliterator.ORDERED, true),
                                                       Node::spliterator,
                                                       n -> (int) n.count());
         }
@@ -117,8 +117,8 @@
 
         public static OfInt ofSpinedBuffer(String name, SpinedBuffer.OfInt buffer) {
             return new AbstractTestData.IntTestData<>(name, buffer,
-                                                      b -> StreamSupport.intStream(b.spliterator()),
-                                                      b -> StreamSupport.intParallelStream(b.spliterator()),
+                                                      b -> StreamSupport.intStream(b.spliterator(), false),
+                                                      b -> StreamSupport.intStream(b.spliterator(), true),
                                                       SpinedBuffer.OfInt::spliterator,
                                                       b -> (int) b.count());
         }
@@ -134,8 +134,8 @@
         public static OfInt ofNode(String name, Node.OfInt node) {
             int characteristics = Spliterator.SIZED | Spliterator.ORDERED;
             return new AbstractTestData.IntTestData<>(name, node,
-                                                      n -> StreamSupport.intStream(n::spliterator, characteristics),
-                                                      n -> StreamSupport.intParallelStream(n::spliterator, characteristics),
+                                                      n -> StreamSupport.intStream(n::spliterator, characteristics, false),
+                                                      n -> StreamSupport.intStream(n::spliterator, characteristics, true),
                                                       Node.OfInt::spliterator,
                                                       n -> (int) n.count());
         }
@@ -148,8 +148,8 @@
 
         public static OfLong ofSpinedBuffer(String name, SpinedBuffer.OfLong buffer) {
             return new AbstractTestData.LongTestData<>(name, buffer,
-                                                      b -> StreamSupport.longStream(b.spliterator()),
-                                                      b -> StreamSupport.longParallelStream(b.spliterator()),
+                                                      b -> StreamSupport.longStream(b.spliterator(), false),
+                                                      b -> StreamSupport.longStream(b.spliterator(), true),
                                                       SpinedBuffer.OfLong::spliterator,
                                                       b -> (int) b.count());
         }
@@ -165,8 +165,8 @@
         public static OfLong ofNode(String name, Node.OfLong node) {
             int characteristics = Spliterator.SIZED | Spliterator.ORDERED;
             return new AbstractTestData.LongTestData<>(name, node,
-                                                      n -> StreamSupport.longStream(n::spliterator, characteristics),
-                                                      n -> StreamSupport.longParallelStream(n::spliterator, characteristics),
+                                                      n -> StreamSupport.longStream(n::spliterator, characteristics, false),
+                                                      n -> StreamSupport.longStream(n::spliterator, characteristics, true),
                                                       Node.OfLong::spliterator,
                                                       n -> (int) n.count());
         }
@@ -179,8 +179,8 @@
 
         public static OfDouble ofSpinedBuffer(String name, SpinedBuffer.OfDouble buffer) {
             return new AbstractTestData.DoubleTestData<>(name, buffer,
-                                                         b -> StreamSupport.doubleStream(b.spliterator()),
-                                                         b -> StreamSupport.doubleParallelStream(b.spliterator()),
+                                                         b -> StreamSupport.doubleStream(b.spliterator(), false),
+                                                         b -> StreamSupport.doubleStream(b.spliterator(), true),
                                                          SpinedBuffer.OfDouble::spliterator,
                                                          b -> (int) b.count());
         }
@@ -196,8 +196,8 @@
         public static OfDouble ofNode(String name, Node.OfDouble node) {
             int characteristics = Spliterator.SIZED | Spliterator.ORDERED;
             return new AbstractTestData.DoubleTestData<>(name, node,
-                                                         n -> StreamSupport.doubleStream(n::spliterator, characteristics),
-                                                         n -> StreamSupport.doubleParallelStream(n::spliterator, characteristics),
+                                                         n -> StreamSupport.doubleStream(n::spliterator, characteristics, false),
+                                                         n -> StreamSupport.doubleStream(n::spliterator, characteristics, true),
                                                          Node.OfDouble::spliterator,
                                                          n -> (int) n.count());
         }
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java	Wed Jul 03 21:43:49 2013 +0200
@@ -86,8 +86,8 @@
     static class SortedTestData<T> extends TestData.AbstractTestData.RefTestData<T, List<T>> {
         SortedTestData(List<T> coll) {
             super("SortedTestData", coll,
-                  c -> StreamSupport.stream(Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED)),
-                  c -> StreamSupport.parallelStream(Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED)),
+                  c -> StreamSupport.stream(Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED), false),
+                  c -> StreamSupport.stream(Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED), true),
                   c -> Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED),
                   List::size);
         }
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest.java	Wed Jul 03 21:43:49 2013 +0200
@@ -306,7 +306,7 @@
     private TestData.OfLong proxiedLongRange(long l, long u) {
         return TestData.Factory.ofLongSupplier(
                 String.format("[%d, %d)", l, u),
-                () -> StreamSupport.longStream(proxyNotSubsized(LongStream.range(l, u).spliterator())));
+                () -> StreamSupport.longStream(proxyNotSubsized(LongStream.range(l, u).spliterator()), false));
     }
 
     @Test(dataProvider = "Stream.limit")
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java	Wed Jul 03 21:43:49 2013 +0200
@@ -155,7 +155,7 @@
         }
 
         Supplier<Iterator<Integer>> source = () -> Arrays.asList(1, 2, 3, 4).iterator();
-        Supplier<Stream<Integer>> s = () -> StreamSupport.stream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0));
+        Supplier<Stream<Integer>> s = () -> StreamSupport.stream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false);
 
         assertFalse(s.get().allMatch(i -> i > 3));
         assertTrue(s.get().anyMatch(i -> i > 3));
@@ -240,7 +240,7 @@
         }
 
         Supplier<PrimitiveIterator.OfInt> source = () -> Arrays.stream(new int[]{1, 2, 3, 4}).iterator();
-        Supplier<IntStream> s = () -> StreamSupport.intStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0));
+        Supplier<IntStream> s = () -> StreamSupport.intStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false);
 
         assertFalse(s.get().allMatch(i -> i > 3));
         assertTrue(s.get().anyMatch(i -> i > 3));
@@ -325,7 +325,7 @@
         }
 
         Supplier<PrimitiveIterator.OfLong> source = () -> Arrays.stream(new long[]{1, 2, 3, 4}).iterator();
-        Supplier<LongStream> s = () -> StreamSupport.longStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0));
+        Supplier<LongStream> s = () -> StreamSupport.longStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false);
 
         assertFalse(s.get().allMatch(i -> i > 3));
         assertTrue(s.get().anyMatch(i -> i > 3));
@@ -410,7 +410,7 @@
         }
 
         Supplier<PrimitiveIterator.OfDouble> source = () -> Arrays.stream(new double[]{1, 2, 3, 4}).iterator();
-        Supplier<DoubleStream> s = () -> StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0));
+        Supplier<DoubleStream> s = () -> StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false);
 
         assertFalse(s.get().allMatch(i -> i > 3));
         assertTrue(s.get().anyMatch(i -> i > 3));
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java	Wed Jul 03 21:43:49 2013 +0200
@@ -237,7 +237,7 @@
         List<Integer> list = IntStream.range(0, 100).boxed().collect(Collectors.toList());
         TestData.OfRef<Integer> data = TestData.Factory.ofSupplier(
                 "Non splitting, not SUBSIZED, ORDERED, stream",
-                () -> StreamSupport.stream(new NonSplittingNotSubsizedOrderedSpliterator<>(list.spliterator())));
+                () -> StreamSupport.stream(new NonSplittingNotSubsizedOrderedSpliterator<>(list.spliterator()), false));
 
         testSkipLimitOps("testSkipLimitOpsWithNonSplittingSpliterator", data);
     }
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java	Wed Jul 03 21:43:49 2013 +0200
@@ -78,7 +78,7 @@
     }
 
     private <T> Stream<T> unknownSizeStream(List<T> l) {
-        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(l.iterator(), 0));
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(l.iterator(), 0), false);
     }
 
     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
@@ -150,7 +150,7 @@
     }
 
     private IntStream unknownSizeIntStream(int[] a) {
-        return StreamSupport.intStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0));
+        return StreamSupport.intStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0), false);
     }
 
     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
@@ -193,7 +193,7 @@
     }
 
     private LongStream unknownSizeLongStream(long[] a) {
-        return StreamSupport.longStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0));
+        return StreamSupport.longStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0), false);
     }
 
     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
@@ -236,7 +236,7 @@
     }
 
     private DoubleStream unknownSizeDoubleStream(double[] a) {
-        return StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0));
+        return StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0), false);
     }
 
     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java	Fri Jul 12 12:15:59 2013 -0700
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java	Wed Jul 03 21:43:49 2013 +0200
@@ -266,7 +266,7 @@
                     setContext("proxyEstimateSize", proxyEstimateSize);
                     Spliterator<Integer> sp = intermediateOp.apply(l.stream()).spliterator();
                     ProxyNoExactSizeSpliterator<Integer> psp = new ProxyNoExactSizeSpliterator<>(sp, proxyEstimateSize);
-                    Stream<Integer> s = StreamSupport.parallelStream(psp);
+                    Stream<Integer> s = StreamSupport.stream(psp, true);
                     terminalOp.accept(s);
                     Assert.assertTrue(psp.splits > 0,
                                       String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
@@ -290,14 +290,14 @@
             withData(data).
                     stream((Stream<Integer> in) -> {
                         Stream<Integer> out = f.apply(in);
-                        return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out));
+                        return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
                     }).
                     exercise();
 
             withData(data).
                     stream((Stream<Integer> in) -> {
                         Stream<Integer> out = f.apply(in);
-                        return StreamSupport.parallelStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out));
+                        return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
                     }).
                     exercise();
         }
@@ -362,7 +362,7 @@
                     // @@@ Need way to obtain the target size
                     Spliterator.OfInt sp = intermediateOp.apply(IntStream.range(0, 1000)).spliterator();
                     ProxyNoExactSizeSpliterator.OfInt psp = new ProxyNoExactSizeSpliterator.OfInt(sp, proxyEstimateSize);
-                    IntStream s = StreamSupport.intParallelStream(psp);
+                    IntStream s = StreamSupport.intStream(psp, true);
                     terminalOp.accept(s);
                     Assert.assertTrue(psp.splits > 0,
                                       String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
@@ -386,14 +386,14 @@
             withData(data).
                     stream(in -> {
                         IntStream out = f.apply(in);
-                        return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out));
+                        return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
                     }).
                     exercise();
 
             withData(data).
                     stream((in) -> {
                         IntStream out = f.apply(in);
-                        return StreamSupport.intParallelStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out));
+                        return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
                     }).
                     exercise();
         }
@@ -455,7 +455,7 @@
                     // @@@ Need way to obtain the target size
                     Spliterator.OfLong sp = intermediateOp.apply(LongStream.range(0, 1000)).spliterator();
                     ProxyNoExactSizeSpliterator.OfLong psp = new ProxyNoExactSizeSpliterator.OfLong(sp, proxyEstimateSize);
-                    LongStream s = StreamSupport.longParallelStream(psp);
+                    LongStream s = StreamSupport.longStream(psp, true);
                     terminalOp.accept(s);
                     Assert.assertTrue(psp.splits > 0,
                                       String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
@@ -479,14 +479,14 @@
             withData(data).
                     stream(in -> {
                         LongStream out = f.apply(in);
-                        return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out));
+                        return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
                     }).
                     exercise();
 
             withData(data).
                     stream((in) -> {
                         LongStream out = f.apply(in);
-                        return StreamSupport.longParallelStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out));
+                        return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
                     }).
                     exercise();
         }
@@ -548,7 +548,7 @@
                     // @@@ Need way to obtain the target size
                     Spliterator.OfDouble sp = intermediateOp.apply(IntStream.range(0, 1000).asDoubleStream()).spliterator();
                     ProxyNoExactSizeSpliterator.OfDouble psp = new ProxyNoExactSizeSpliterator.OfDouble(sp, proxyEstimateSize);
-                    DoubleStream s = StreamSupport.doubleParallelStream(psp);
+                    DoubleStream s = StreamSupport.doubleStream(psp, true);
                     terminalOp.accept(s);
                     Assert.assertTrue(psp.splits > 0,
                                       String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
@@ -572,14 +572,14 @@
             withData(data).
                     stream(in -> {
                         DoubleStream out = f.apply(in);
-                        return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out));
+                        return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
                     }).
                     exercise();
 
             withData(data).
                     stream((in) -> {
                         DoubleStream out = f.apply(in);
-                        return StreamSupport.doubleParallelStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out));
+                        return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
                     }).
                     exercise();
         }