@Override final boolean forEachWithCancel(Spliterator<Double> spliterator, Sink<Double> sink) { Spliterator.OfDouble spl = adapt(spliterator); DoubleConsumer adaptedSink = adapt(sink); boolean cancelled; do { } while (!(cancelled = sink.cancellationRequested()) && spl.tryAdvance(adaptedSink)); return cancelled; }
@Override public final DoubleSummaryStatistics summaryStatistics() { return collect(Collectors.DBL_SUM_STATS, DoubleSummaryStatistics::accept, DoubleSummaryStatistics::combine); }
@Override public DoubleStream unordered() { if (!isOrdered()) return this; return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE, StreamOpFlag.NOT_ORDERED) { @Override Sink<Double> opWrapSink(int flags, Sink<Double> sink) { return sink; } }; }
@Override public final boolean allMatch(DoublePredicate predicate) { return evaluate(MatchOps.makeDouble(predicate, MatchOps.MatchKind.ALL)); }
@Override public final Stream<Double> boxed() { return mapToObj(Double::valueOf, 0); }
@Override public final OptionalDouble max() { return reduce(Math::max); }
@Override public final double[] toArray() { return Nodes.flattenDouble((Node.OfDouble) evaluateToArrayNode(WhileOps.DOUBLE_ARR_GEN)) .asPrimitiveArray(); }
@Override public void forEachOrdered(DoubleConsumer consumer) { if (!isParallel()) { adapt(sourceStageSpliterator()).forEachRemaining(consumer); } else { super.forEachOrdered(consumer); } }
@Override public void forEach(DoubleConsumer consumer) { if (!isParallel()) { adapt(sourceStageSpliterator()).forEachRemaining(consumer); } else { super.forEach(consumer); } }
@Override public final DoubleStream distinct() { // While functional and quick to implement, this approach is not very efficient. // An efficient version requires a double-specific map/set implementation. return boxed().distinct().mapToDouble(i -> (double) i); }
@Override public final OptionalDouble findAny() { return evaluate(FindOps.makeDouble(false)); }
@Override public final Stream<Double> boxed() { return mapToObj(Double::valueOf, 0); }
@Override public final OptionalDouble max() { return reduce(Math::max); }
@Override public final double[] toArray() { return Nodes.flattenDouble((Node.OfDouble) evaluateToArrayNode(WhileOps.DOUBLE_ARR_GEN)) .asPrimitiveArray(); }
@Override public void forEachOrdered(DoubleConsumer consumer) { if (!isParallel()) { adapt(sourceStageSpliterator()).forEachRemaining(consumer); } else { super.forEachOrdered(consumer); } }
@Override public void forEach(DoubleConsumer consumer) { if (!isParallel()) { adapt(sourceStageSpliterator()).forEachRemaining(consumer); } else { super.forEach(consumer); } }
@Override public final DoubleStream distinct() { // While functional and quick to implement, this approach is not very efficient. // An efficient version requires a double-specific map/set implementation. return boxed().distinct().mapToDouble(i -> (double) i); }
@Override public final boolean anyMatch(DoublePredicate predicate) { return evaluate(MatchOps.makeDouble(predicate, MatchOps.MatchKind.ANY)); }
@Override public final DoubleSummaryStatistics summaryStatistics() { return collect(Collectors.DBL_SUM_STATS, DoubleSummaryStatistics::accept, DoubleSummaryStatistics::combine); }
@Override final boolean forEachWithCancel(Spliterator<Double> spliterator, Sink<Double> sink) { Spliterator.OfDouble spl = adapt(spliterator); DoubleConsumer adaptedSink = adapt(sink); boolean cancelled; do { } while (!(cancelled = sink.cancellationRequested()) && spl.tryAdvance(adaptedSink)); return cancelled; }