@Override public final <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super P_OUT> accumulator, BiConsumer<R, R> combiner) { return evaluate(ReduceOps.makeRef(supplier, accumulator, combiner)); }
@Override public Stream<P_OUT> unordered() { if (!isOrdered()) return this; return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE, StreamOpFlag.NOT_ORDERED) { @Override Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) { return sink; } }; }
@Override public final Optional<P_OUT> max(Comparator<? super P_OUT> comparator) { return reduce(BinaryOperators.maxBy(comparator)); }
@Override @SuppressWarnings("unchecked") public final <R, A> R collect(Collector<? super P_OUT, A, R> collector) { A container; if (isParallel() && (collector.characteristics().contains(Collector.Characteristics.CONCURRENT)) && (!isOrdered() || collector.characteristics().contains(Collector.Characteristics.UNORDERED))) { container = collector.supplier().get(); BiConsumer<A, ? super P_OUT> accumulator = collector.accumulator(); forEach(u -> accumulator.accept(container, u)); } else { container = evaluate(ReduceOps.makeRef(collector)); } return collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH) ? (R) container : collector.finisher().apply(container); }
@Override public void forEach(Consumer<? super E_OUT> action) { if (!isParallel()) { sourceStageSpliterator().forEachRemaining(action); } else { super.forEach(action); } }
@Override public void forEachOrdered(Consumer<? super E_OUT> action) { if (!isParallel()) { sourceStageSpliterator().forEachRemaining(action); } else { super.forEachOrdered(action); } } }
@Override public final Iterator<P_OUT> iterator() { return Spliterators.iterator(spliterator()); }
@Override public final Object[] toArray() { return toArray(Object[]::new); }
return (A[]) Nodes.flatten((Node<A>) evaluateToArrayNode(rawGenerator), generator) .asArray(rawGenerator);
@Override @SuppressWarnings("unchecked") public final <R, A> R collect(Collector<? super P_OUT, A, R> collector) { A container; if (isParallel() && (collector.characteristics().contains(Collector.Characteristics.CONCURRENT)) && (!isOrdered() || collector.characteristics().contains(Collector.Characteristics.UNORDERED))) { container = collector.supplier().get(); BiConsumer<A, ? super P_OUT> accumulator = collector.accumulator(); forEach(u -> accumulator.accept(container, u)); } else { container = evaluate(ReduceOps.makeRef(collector)); } return collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH) ? (R) container : collector.finisher().apply(container); }
@Override public void forEach(Consumer<? super E_OUT> action) { if (!isParallel()) { sourceStageSpliterator().forEachRemaining(action); } else { super.forEach(action); } }
@Override public void forEachOrdered(Consumer<? super E_OUT> action) { if (!isParallel()) { sourceStageSpliterator().forEachRemaining(action); } else { super.forEachOrdered(action); } } }
@Override public final Iterator<P_OUT> iterator() { return Spliterators.iterator(spliterator()); }
@Override public final Object[] toArray() { return toArray(Object[]::new); }
return (A[]) Nodes.flatten((Node<A>) evaluateToArrayNode(rawGenerator), generator) .asArray(rawGenerator);
@Override public final <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super P_OUT> accumulator, BiConsumer<R, R> combiner) { return evaluate(ReduceOps.makeRef(supplier, accumulator, combiner)); }
@Override public final Optional<P_OUT> min(Comparator<? super P_OUT> comparator) { return reduce(BinaryOperators.minBy(comparator)); }
@Override public Stream<P_OUT> unordered() { if (!isOrdered()) return this; return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE, StreamOpFlag.NOT_ORDERED) { @Override Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) { return sink; } }; }
@Override public void forEachOrdered(Consumer<? super P_OUT> action) { evaluate(ForEachOps.makeRef(action, true)); }
@Override public final Optional<P_OUT> max(Comparator<? super P_OUT> comparator) { return reduce(BinaryOperators.maxBy(comparator)); }