我用this 很好的答案写了以下课程：
public class SplitStream<T> implements Stream<T> {
private final Supplier<Stream<T>> streamSupplier;
public SplitStream(Supplier<Stream<T>> t) {
this.streamSupplier = t;
}
@Override
public Stream<T> filter(Predicate<? super T> predicate) {
return streamSupplier.get().filter(predicate);
}
@Override
public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
return streamSupplier.get().map(mapper);
}
@Override
public IntStream mapToInt(ToIntFunction<? super T> mapper) {
return streamSupplier.get().mapToInt(mapper);
}
@Override
public LongStream mapToLong(ToLongFunction<? super T> mapper) {
return streamSupplier.get().mapToLong(mapper);
}
@Override
public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
return streamSupplier.get().mapToDouble(mapper);
}
@Override
public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
return streamSupplier.get().flatMap(mapper);
}
@Override
public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
return streamSupplier.get().flatMapToInt(mapper);
}
@Override
public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
return streamSupplier.get().flatMapToLong(mapper);
}
@Override
public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
return streamSupplier.get().flatMapToDouble(mapper);
}
@Override
public Stream<T> distinct() {
return streamSupplier.get().distinct();
}
@Override
public Stream<T> sorted() {
return streamSupplier.get().sorted();
}
@Override
public Stream<T> sorted(Comparator<? super T> comparator) {
return streamSupplier.get().sorted(comparator);
}
@Override
public Stream<T> peek(Consumer<? super T> action) {
return streamSupplier.get().peek(action);
}
@Override
public Stream<T> limit(long maxSize) {
return streamSupplier.get().limit(maxSize);
}
@Override
public Stream<T> skip(long n) {
return streamSupplier.get().skip(n);
}
@Override
public void forEach(Consumer<? super T> action) {
streamSupplier.get().forEach(action);
}
@Override
public void forEachOrdered(Consumer<? super T> action) {
streamSupplier.get().forEachOrdered(action);
}
@Override
public Object[] toArray() {
return streamSupplier.get().toArray();
}
@Override
public <A> A[] toArray(IntFunction<A[]> generator) {
return streamSupplier.get().toArray(generator);
}
@Override
public T reduce(T identity, BinaryOperator<T> accumulator) {
return streamSupplier.get().reduce(identity, accumulator);
}
@Override
public Optional<T> reduce(BinaryOperator<T> accumulator) {
return streamSupplier.get().reduce(accumulator);
}
@Override
public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
return streamSupplier.get().reduce(identity, accumulator, combiner);
}
@Override
public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
return streamSupplier.get().collect(supplier, accumulator, combiner);
}
@Override
public <R, A> R collect(Collector<? super T, A, R> collector) {
return streamSupplier.get().collect(collector);
}
@Override
public Optional<T> min(Comparator<? super T> comparator) {
return streamSupplier.get().min(comparator);
}
@Override
public Optional<T> max(Comparator<? super T> comparator) {
return streamSupplier.get().max(comparator);
}
@Override
public long count() {
return streamSupplier.get().count();
}
@Override
public boolean anyMatch(Predicate<? super T> predicate) {
return streamSupplier.get().anyMatch(predicate);
}
@Override
public boolean allMatch(Predicate<? super T> predicate) {
return streamSupplier.get().allMatch(predicate);
}
@Override
public boolean noneMatch(Predicate<? super T> predicate) {
return streamSupplier.get().noneMatch(predicate);
}
@Override
public Optional<T> findFirst() {
return streamSupplier.get().findFirst();
}
@Override
public Optional<T> findAny() {
return streamSupplier.get().findAny();
}
@Override
public Iterator<T> iterator() {
return streamSupplier.get().iterator();
}
@Override
public Spliterator<T> spliterator() {
return streamSupplier.get().spliterator();
}
@Override
public boolean isParallel() {
return streamSupplier.get().isParallel();
}
@Override
public Stream<T> sequential() {
return streamSupplier.get().sequential();
}
@Override
public Stream<T> parallel() {
return streamSupplier.get().parallel();
}
@Override
public Stream<T> unordered() {
return streamSupplier.get().unordered();
}
@Override
public Stream<T> onClose(Runnable closeHandler) {
return streamSupplier.get().onClose(closeHandler);
}
@Override
public void close() {
streamSupplier.get().close();
}
}
当你调用它的类的任何方法时，它会将调用委托给
streamSupplier.get()
所以，而不是：
Supplier<IntStream> supplier = () ->
IntStream.range(1, 100).filter(n -> n % 2 == 0);
supplier.get().filter(...);
supplier.get().filter(...);
你可以这样做：
SplitStream<Integer> stream =
new SplitStream<>(() -> IntStream.range(1, 100).filter(n -> n % 2 == 0).boxed());
stream.filter(...);
stream.filter(...);
您可以将其扩展为与 IntStream、DoubleStream 等一起使用...