infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-02-19 06:45:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

8019395: Consolidate StreamSupport.{stream,parallelStream} into a single method

Browse Source 
Reviewed-by: henryjen, briangoetz
This commit is contained in:
Paul Sandoz 2013-07-03 21:43:49 +02:00
parent be6f63a1f8
commit c5fcef26c9
28 changed files with 246 additions and 444 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jdk/src/share/classes/java/io/BufferedReader.java
View File

@ -587,6 +587,6 @@ public class BufferedReader extends Reader {
}
}
};
return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iter, Spliterator.ORDERED));
return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iter, Spliterator.ORDERED), false);
}
}

6
jdk/src/share/classes/java/lang/CharSequence.java
View File

@ -156,7 +156,8 @@ public interface CharSequence {
new CharIterator(),
length(),
Spliterator.ORDERED),
Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED);
Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
false);
}
/**
@ -227,6 +228,7 @@ public interface CharSequence {
Spliterators.spliteratorUnknownSize(
new CodePointIterator(),
Spliterator.ORDERED),
Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED);
Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
false);
}
}

2
jdk/src/share/classes/java/nio/X-Buffer.java.template
View File

@ -1495,7 +1495,7 @@ public abstract class $Type$Buffer
#end[char]
public $Streamtype$Stream $type$s() {
return StreamSupport.$streamtype$Stream(() -> new $Type$BufferSpliterator(this),
Buffer.SPLITERATOR_CHARACTERISTICS);
Buffer.SPLITERATOR_CHARACTERISTICS, false);
}
#end[streamableType]

27
jdk/src/share/classes/java/nio/file/Files.java
View File

@ -3269,9 +3269,10 @@ public final class Files {
}
};
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 @@ public final class Files {
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 @@ public final class Files {
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);
}
/**

8
jdk/src/share/classes/java/util/Arrays.java
View File

@ -4966,7 +4966,7 @@ public class Arrays {
* @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 @@ public class Arrays {
* @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 @@ public class Arrays {
* @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 @@ public class Arrays {
* @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);
}
}

3
jdk/src/share/classes/java/util/BitSet.java
View File

@ -1231,6 +1231,7 @@ public class BitSet implements Cloneable, java.io.Serializable {
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);
}
}

4
jdk/src/share/classes/java/util/Collection.java
View File

@ -557,7 +557,7 @@ public interface Collection<E> extends Iterable<E> {
* @since 1.8
*/
default Stream<E> stream() {
return StreamSupport.stream(spliterator());
return StreamSupport.stream(spliterator(), false);
}
/**
@ -578,6 +578,6 @@ public interface Collection<E> extends Iterable<E> {
* @since 1.8
*/
default Stream<E> parallelStream() {
return StreamSupport.parallelStream(spliterator());
return StreamSupport.stream(spliterator(), true);
}
}

4
jdk/src/share/classes/java/util/Collections.java
View File

@ -1674,12 +1674,12 @@ public class Collections {
@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() {

2
jdk/src/share/classes/java/util/jar/JarFile.java
View File

@ -272,7 +272,7 @@ class JarFile extends ZipFile {
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 {

2
jdk/src/share/classes/java/util/regex/Pattern.java
View File

@ -5815,6 +5815,6 @@ NEXT: while (i <= last) {
}
}
return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
new MatcherIterator(), Spliterator.ORDERED | Spliterator.NONNULL));
new MatcherIterator(), Spliterator.ORDERED | Spliterator.NONNULL), false);
}
}

12
jdk/src/share/classes/java/util/stream/DoubleStream.java
View File

@ -672,7 +672,7 @@ public interface DoubleStream extends BaseStream<Double, DoubleStream> {
* @return an empty sequential stream
*/
public static DoubleStream empty() {
return StreamSupport.doubleStream(Spliterators.emptyDoubleSpliterator());
return StreamSupport.doubleStream(Spliterators.emptyDoubleSpliterator(), false);
}
/**
@ -682,7 +682,7 @@ public interface DoubleStream extends BaseStream<Double, DoubleStream> {
* @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 @@ public interface DoubleStream extends BaseStream<Double, DoubleStream> {
};
return StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(
iterator,
Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL));
Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
}
/**
@ -744,7 +744,7 @@ public interface DoubleStream extends BaseStream<Double, DoubleStream> {
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 @@ public interface DoubleStream extends BaseStream<Double, DoubleStream> {
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());
}
}

16
jdk/src/share/classes/java/util/stream/IntStream.java
View File

@ -674,7 +674,7 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
* @return an empty sequential stream
*/
public static IntStream empty() {
return StreamSupport.intStream(Spliterators.emptyIntSpliterator());
return StreamSupport.intStream(Spliterators.emptyIntSpliterator(), false);
}
/**
@ -684,7 +684,7 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
* @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 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
};
return StreamSupport.intStream(Spliterators.spliteratorUnknownSize(
iterator,
Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL));
Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
}
/**
@ -746,7 +746,7 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
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 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
return empty();
} else {
return StreamSupport.intStream(
new Streams.RangeIntSpliterator(startInclusive, endExclusive, false));
new Streams.RangeIntSpliterator(startInclusive, endExclusive, false), false);
}
}
@ -797,7 +797,7 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
return empty();
} else {
return StreamSupport.intStream(
new Streams.RangeIntSpliterator(startInclusive, endInclusive, true));
new Streams.RangeIntSpliterator(startInclusive, endInclusive, true), false);
}
}
@ -818,8 +818,6 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
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());
}
}

16
jdk/src/share/classes/java/util/stream/LongStream.java
View File

@ -665,7 +665,7 @@ public interface LongStream extends BaseStream<Long, LongStream> {
* @return an empty sequential stream
*/
public static LongStream empty() {
return StreamSupport.longStream(Spliterators.emptyLongSpliterator());
return StreamSupport.longStream(Spliterators.emptyLongSpliterator(), false);
}
/**
@ -675,7 +675,7 @@ public interface LongStream extends BaseStream<Long, LongStream> {
* @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 @@ public interface LongStream extends BaseStream<Long, LongStream> {
};
return StreamSupport.longStream(Spliterators.spliteratorUnknownSize(
iterator,
Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL));
Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL), false);
}
/**
@ -737,7 +737,7 @@ public interface LongStream extends BaseStream<Long, LongStream> {
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 @@ public interface LongStream extends BaseStream<Long, LongStream> {
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 @@ public interface LongStream extends BaseStream<Long, LongStream> {
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 @@ public interface LongStream extends BaseStream<Long, LongStream> {
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());
}
}

12
jdk/src/share/classes/java/util/stream/Stream.java
View File

@ -805,7 +805,7 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
* @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 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
* @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 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
};
return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
iterator,
Spliterator.ORDERED | Spliterator.IMMUTABLE));
Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
}
/**
@ -881,7 +881,7 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
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 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
@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());
}
}

456
jdk/src/share/classes/java/util/stream/StreamSupport.java
View File

@ -47,59 +47,38 @@ public final class StreamSupport {
private StreamSupport() {}
/**
* Creates a new sequential {@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 sequential {@code Stream}
*/
public static <T> Stream<T> stream(Spliterator<T> spliterator) {
Objects.requireNonNull(spliterator);
return new ReferencePipeline.Head<>(spliterator,
StreamOpFlag.fromCharacteristics(spliterator),
false);
}
/**
* 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
* 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.
*
* <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(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
* @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, boolean parallel) {
Objects.requireNonNull(spliterator);
return new ReferencePipeline.Head<>(spliterator,
StreamOpFlag.fromCharacteristics(spliterator),
parallel);
}
/**
* 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
* commences.
@ -107,7 +86,8 @@ public final class StreamSupport {
* <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,60 +96,28 @@ public final class StreamSupport {
* <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}.
*
* <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 #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}.
* 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.
@ -177,46 +125,26 @@ public final class StreamSupport {
* <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 #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
* @return a new sequential {@code IntStream}
* @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) {
public static IntStream intStream(Spliterator.OfInt spliterator, boolean parallel) {
return new IntPipeline.Head<>(spliterator,
StreamOpFlag.fromCharacteristics(spliterator),
false);
parallel);
}
/**
* 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}.
* 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
@ -225,7 +153,8 @@ public final class StreamSupport {
* <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,53 +166,24 @@ public final class StreamSupport {
* @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}.
*
* <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.
* 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}.
* 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.
@ -291,47 +191,27 @@ public final class StreamSupport {
* <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
* {@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
* @return a new parallel {@code LongStream}
* @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 longParallelStream(Spliterator.OfLong spliterator) {
public static LongStream longStream(Spliterator.OfLong spliterator,
boolean parallel) {
return new LongPipeline.Head<>(spliterator,
StreamOpFlag.fromCharacteristics(spliterator),
true);
parallel);
}
/**
* Creates a new sequential {@code LongStream} from a {@code Supplier} of
* {@code Spliterator.OfLong}.
* 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
@ -340,7 +220,8 @@ public final class StreamSupport {
* <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 @@ public final class StreamSupport {
* @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 @@ public final class StreamSupport {
* <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 @@ public final class StreamSupport {
* @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);
}
}

11
jdk/src/share/classes/java/util/stream/Streams.java
View File

@ -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 @@ final class Streams {
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 @@ final class Streams {
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 @@ final class Streams {
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 @@ final class Streams {
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();

2
jdk/src/share/classes/java/util/zip/ZipFile.java
View File

@ -551,7 +551,7 @@ class ZipFile implements ZipConstants, Closeable {
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) {

6
jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java
View File

@ -140,9 +140,9 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
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);
}

7
jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java
View File

@ -140,9 +140,10 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
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);
}

6
jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java
View File

@ -140,9 +140,9 @@ public enum LongStreamTestScenario implements OpTestCase.BaseStreamTestScenario
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);
}

6
jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java
View File

@ -151,9 +151,9 @@ public enum StreamTestScenario implements OpTestCase.BaseStreamTestScenario {
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);
}

32
jdk/test/java/util/stream/bootlib/java/util/stream/TestData.java
View File

@ -87,8 +87,8 @@ public interface TestData<T, S extends BaseStream<T, S>>
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 interface TestData<T, S extends BaseStream<T, S>>
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 interface TestData<T, S extends BaseStream<T, S>>
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 interface TestData<T, S extends BaseStream<T, S>>
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 interface TestData<T, S extends BaseStream<T, S>>
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 interface TestData<T, S extends BaseStream<T, S>>
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 interface TestData<T, S extends BaseStream<T, S>>
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 interface TestData<T, S extends BaseStream<T, S>>
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());
}

4
jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java
View File

@ -86,8 +86,8 @@ public class DistinctOpTest extends OpTestCase {
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);
}

2
jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest.java
View File

@ -306,7 +306,7 @@ public class InfiniteStreamWithLimitOpTest extends OpTestCase {
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")

8
jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java
View File

@ -155,7 +155,7 @@ public class MatchOpTest extends OpTestCase {
}
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 @@ public class MatchOpTest extends OpTestCase {
}
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 @@ public class MatchOpTest extends OpTestCase {
}
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 @@ public class MatchOpTest extends OpTestCase {
}
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));

2
jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java
View File

@ -237,7 +237,7 @@ public class SliceOpTest extends OpTestCase {
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);
}

8
jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java
View File

@ -78,7 +78,7 @@ public class SortedOpTest extends OpTestCase {
}
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 @@ public class SortedOpTest extends OpTestCase {
}
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 @@ public class SortedOpTest extends OpTestCase {
}
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 @@ public class SortedOpTest extends OpTestCase {
}
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)

24
jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java
View File

@ -266,7 +266,7 @@ public class StreamSpliteratorTest extends OpTestCase {
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 @@ public class StreamSpliteratorTest extends OpTestCase {
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 @@ public class StreamSpliteratorTest extends OpTestCase {
// @@@ 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 @@ public class StreamSpliteratorTest extends OpTestCase {
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 @@ public class StreamSpliteratorTest extends OpTestCase {
// @@@ 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 @@ public class StreamSpliteratorTest extends OpTestCase {
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 @@ public class StreamSpliteratorTest extends OpTestCase {
// @@@ 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 @@ public class StreamSpliteratorTest extends OpTestCase {
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();
}