終止操作類

?

短路操作

match操作

match操作，生成MatchOp，封裝成MatchSink

public static <T> TerminalOp<T, Boolean> makeRef(Predicate<? super T> predicate,MatchKind matchKind) {Objects.requireNonNull(predicate);Objects.requireNonNull(matchKind);class MatchSink extends BooleanTerminalSink<T> {MatchSink() {super(matchKind);}@Overridepublic void accept(T t) {//predicate結果==matchKind.stopOnPredicateMatches，并且未終止。if (!stop && predicate.test(t) == matchKind.stopOnPredicateMatches) {stop = true;value = matchKind.shortCircuitResult;}}}return new MatchOp<>(StreamShape.REFERENCE, matchKind, MatchSink::new);}

?主要有3種match：

enum MatchKind {/** Do all elements match the predicate? *///true即終止，返回trueANY(true, true),//false即終止，返回false/** Do any elements match the predicate? */ALL(false, false), //true即終止。返回false/** Do no elements match the predicate? */NONE(true, false);//stop的判斷值。。private final boolean stopOnPredicateMatches;//短路返回結果。private final boolean shortCircuitResult;private MatchKind(boolean stopOnPredicateMatches,boolean shortCircuitResult) {this.stopOnPredicateMatches = stopOnPredicateMatches;this.shortCircuitResult = shortCircuitResult;}}

?

private static final class MatchOp<T> implements TerminalOp<T, Boolean> {private final StreamShape inputShape;final MatchKind matchKind;final Supplier<BooleanTerminalSink<T>> sinkSupplier;MatchOp(StreamShape shape,MatchKind matchKind,Supplier<BooleanTerminalSink<T>> sinkSupplier) {this.inputShape = shape;this.matchKind = matchKind;this.sinkSupplier = sinkSupplier;}@Overridepublic int getOpFlags() {return StreamOpFlag.IS_SHORT_CIRCUIT | StreamOpFlag.NOT_ORDERED;}@Overridepublic StreamShape inputShape() {return inputShape;}@Overridepublic <S> Boolean evaluateSequential(PipelineHelper<T> helper,Spliterator<S> spliterator) {return helper.wrapAndCopyInto(sinkSupplier.get(), spliterator).getAndClearState();}@Overridepublic <S> Boolean evaluateParallel(PipelineHelper<T> helper,Spliterator<S> spliterator) {return new MatchTask<>(this, helper, spliterator).invoke();}} private static abstract class BooleanTerminalSink<T> implements Sink<T> {boolean stop;boolean value;BooleanTerminalSink(MatchKind matchKind) {value = !matchKind.shortCircuitResult;}public boolean getAndClearState() {return value;}@Overridepublic boolean cancellationRequested() {return stop;}}

anyMatch()

public final boolean anyMatch(Predicate<? super P_OUT> predicate) {return evaluate(MatchOps.makeRef(predicate, MatchOps.MatchKind.ANY));}

allMatch()

public final boolean allMatch(Predicate<? super P_OUT> predicate) {return evaluate(MatchOps.makeRef(predicate, MatchOps.MatchKind.ALL));}

noneMatch()

public final boolean noneMatch(Predicate<? super P_OUT> predicate) {return evaluate(MatchOps.makeRef(predicate, MatchOps.MatchKind.NONE));}

find操作

find操作，生成FindOp，封裝成FindSink

public static <T> TerminalOp<T, Optional<T>> makeRef(boolean mustFindFirst) {return new FindOp<>(mustFindFirst, StreamShape.REFERENCE, Optional.empty(),Optional::isPresent, FindSink.OfRef::new);} private static final class FindOp<T, O> implements TerminalOp<T, O> {private final StreamShape shape;final boolean mustFindFirst;final O emptyValue;final Predicate<O> presentPredicate;final Supplier<TerminalSink<T, O>> sinkSupplier;FindOp(boolean mustFindFirst,StreamShape shape,O emptyValue,Predicate<O> presentPredicate,Supplier<TerminalSink<T, O>> sinkSupplier) {this.mustFindFirst = mustFindFirst;this.shape = shape;this.emptyValue = emptyValue;this.presentPredicate = presentPredicate;this.sinkSupplier = sinkSupplier;} } private static abstract class FindSink<T, O> implements TerminalSink<T, O> {boolean hasValue;T value;FindSink() {} // Avoid creation of special accessor@Override //設置為第一個值public void accept(T value) {if (!hasValue) {hasValue = true;this.value = value;}}@Override //有值時就終止public boolean cancellationRequested() {return hasValue;}

?

findFirst()

public final Optional<P_OUT> findFirst() {return evaluate(FindOps.makeRef(true));}

findAny()

public final Optional<P_OUT> findAny() {return evaluate(FindOps.makeRef(false));}

非短路操作

forEach

forEach操作，生成ForEachOp，同時也是個Sink

public static <T> TerminalOp<T, Void> makeRef(Consumer<? super T> action,boolean ordered) {Objects.requireNonNull(action);return new ForEachOp.OfRef<>(action, ordered);} static abstract class ForEachOp<T>implements TerminalOp<T, Void>, TerminalSink<T, Void> {private final boolean ordered;protected ForEachOp(boolean ordered) {this.ordered = ordered;}// TerminalOp@Overridepublic int getOpFlags() {return ordered ? 0 : StreamOpFlag.NOT_ORDERED;}@Overridepublic <S> Void evaluateSequential(PipelineHelper<T> helper,Spliterator<S> spliterator) {return helper.wrapAndCopyInto(this, spliterator).get();}@Overridepublic <S> Void evaluateParallel(PipelineHelper<T> helper,Spliterator<S> spliterator) {if (ordered)new ForEachOrderedTask<>(helper, spliterator, this).invoke();elsenew ForEachTask<>(helper, spliterator, helper.wrapSink(this)).invoke();return null;}// TerminalSink@Overridepublic Void get() {return null;}static final class OfRef<T> extends ForEachOp<T> {final Consumer<? super T> consumer;OfRef(Consumer<? super T> consumer, boolean ordered) {super(ordered);this.consumer = consumer;}@Overridepublic void accept(T t) {consumer.accept(t);}} }

forEach()

public void forEach(Consumer<? super P_OUT> action) {evaluate(ForEachOps.makeRef(action, false));}

forEachOrdered()

public void forEachOrdered(Consumer<? super P_OUT> action) {evaluate(ForEachOps.makeRef(action, true));}

toArray()

?

reduce()

?

collect()

?

max()

public final Optional<P_OUT> max(Comparator<? super P_OUT> comparator) {return reduce(BinaryOperator.maxBy(comparator));}

min()

public final Optional<P_OUT> min(Comparator<? super P_OUT> comparator) {return reduce(BinaryOperator.minBy(comparator));}

count()

public final long count() {return mapToLong(e -> 1L).sum();}

?

總結

以上是生活随笔為你收集整理的Java8函数式编程（4）--终止操作（源码）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。