Stream Head的構(gòu)建（一）
Stream 的中間操作（二）
Stream的終止操作（三）
本篇講述match操作娃闲，省略中間流操作,有以下三種方式骑晶，方法名已經(jīng)說明的其功能
List<String> names= Arrays.asList("one", "two", "three", "four");
boolean anyMatch = names.stream().anyMatch(s -> s.length()>2);
boolean allMatch = names.stream().allMatch(s -> s.length()<10);
boolean noneMatch = names.stream().noneMatch(s -> s.length()!=5);
從源碼看，調(diào)用的方法相同刺桃，只是參數(shù)不一樣步清，下文會分析其意義
ReferencePipeline.java
@Override
public final boolean anyMatch(Predicate<? super P_OUT> predicate) {
return evaluate(MatchOps.makeRef(predicate, MatchOps.MatchKind.ANY));
}
@Override
public final boolean allMatch(Predicate<? super P_OUT> predicate) {
return evaluate(MatchOps.makeRef(predicate, MatchOps.MatchKind.ALL));
}
@Override
public final boolean noneMatch(Predicate<? super P_OUT> predicate) {
return evaluate(MatchOps.makeRef(predicate, MatchOps.MatchKind.NONE));
}
終止操作構(gòu)建的套路差不多
MatchOps.java
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);
}
@Override
public void accept(T t) {
if (!stop && predicate.test(t) == matchKind.stopOnPredicateMatches) {
stop = true;
value = matchKind.shortCircuitResult;
}
}
}
return new MatchOp<>(StreamShape.REFERENCE, matchKind, MatchSink::new);
}
這里使用構(gòu)造函數(shù)的方法引用實例化Supplier<BooleanTerminalSink<T>>接口，sinkSupplier.get()的調(diào)用才會真正new對象虏肾。不熟悉可以參考這篇廓啊。
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;
}
@Override
public int getOpFlags() {
注意操作標(biāo)記是短路的，表示流元素可能發(fā)了一部分就被叫停了封豪。后面會用到
return StreamOpFlag.IS_SHORT_CIRCUIT | StreamOpFlag.NOT_ORDERED;
}
...
@Override
public <S> Boolean evaluateSequential(PipelineHelper<T> helper,
Spliterator<S> spliterator) {
return helper.wrapAndCopyInto(sinkSupplier.get(), spliterator).getAndClearState();
}
...
}
在wrapAndCopyInto之前谴轮，需要講一下MatchKind，有三個枚舉類型ANY吹埠、ALL第步、NONE，意義如下
enum MatchKind {
找一個符合條件的缘琅，短路返回true
ANY(true, true),
找到一個不合法條件的粘都，短路返回false
ALL(false, false),
找到一個符合條件的，短路返回false
NONE(true, false);
對判斷結(jié)果的期望刷袍，any期望true翩隧，all期望false，none期望true呻纹，一旦期望成真即短路
private final boolean stopOnPredicateMatches;
發(fā)生短路返回的值
private final boolean shortCircuitResult;
private MatchKind(boolean stopOnPredicateMatches,boolean shortCircuitResult) {
this.stopOnPredicateMatches = stopOnPredicateMatches;
this.shortCircuitResult = shortCircuitResult;
}
}
MatchSink使用MatchKind作為參數(shù)調(diào)用父類BooleanTerminalSink初始化返回值value堆生，對短路結(jié)果取反
private static abstract class BooleanTerminalSink<T> implements Sink<T> {
boolean stop;
boolean value;
BooleanTerminalSink(MatchKind matchKind) {
value = !matchKind.shortCircuitResult;
}
public boolean getAndClearState() {
return value;
}
@Override
public boolean cancellationRequested() {
return stop;
}
}
和以前一樣來到這里,不同的是這次標(biāo)記是SHORT_CIRCUIT
AbstractPipeline
@Override
final <P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
Objects.requireNonNull(wrappedSink);
if (!StreamOpFlag.SHORT_CIRCUIT.isKnown(getStreamAndOpFlags())) {
...
}
else {
//有短路操作
copyIntoWithCancel(wrappedSink, spliterator);
}
}
final <P_IN> void copyIntoWithCancel(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
@SuppressWarnings({"rawtypes","unchecked"})
AbstractPipeline p = AbstractPipeline.this;
//回到源頭
while (p.depth > 0) {
p = p.previousStage;
}
wrappedSink.begin(spliterator.getExactSizeIfKnown());
p.forEachWithCancel(spliterator, wrappedSink);
wrappedSink.end();
}
這里和以前略有不同，我們不需要遍歷整個數(shù)據(jù)源雷酪，只要下游達(dá)到目的就能提前收工淑仆。每發(fā)射一次都有問一下是否繼續(xù)
ReferencePipeline
@Override
final void forEachWithCancel(Spliterator<P_OUT> spliterator, Sink<P_OUT> sink) {
do { } while (!sink.cancellationRequested() && spliterator.tryAdvance(sink));
}
再看看MatchSink對元素的處理，這是整個功能的核心哥力。
@Override
public void accept(T t) {
開始stop=false蔗怠，判斷式是否符合期望，如前面所述
ANY-->期望predicate.test(t) 表達(dá)式返回true
ALL-->期望predicate.test(t) 表達(dá)式返回false
NONE-->期望predicate.test(t)表達(dá)式返回true
判斷短小精悍
if (!stop && predicate.test(t) == matchKind.stopOnPredicateMatches) {
stop = true;
value = matchKind.shortCircuitResult;
}
}
一旦達(dá)到期望，stop=true寞射，即請求取消最住；重新給value賦值，這是我們達(dá)到期望要返回的值怠惶。如果遍歷到結(jié)束涨缚，說明大失所望，value值就是之前的取反值
private static abstract class BooleanTerminalSink<T> implements Sink<T> {
boolean stop;
boolean value;
BooleanTerminalSink(MatchKind matchKind) {
value = !matchKind.shortCircuitResult;
}
public boolean getAndClearState() {
return value;
}
@Override
public boolean cancellationRequested() {
return stop;
}
}
