Java 对于列表中的每一项，执行操作直到满足条件

考虑以下代码：

void tryToOpenSafe() {
    getCorrectSafeCombination().subscribe(combination -> System.out.println("Correct combination is " + combination));
}

Maybe<Integer> getCorrectSafeCombination() {
    return getPossibleCombinations()
            .toObservable()
            .flatMapIterable(combinations -> combinations)
            .flatMap(combination -> tryToOpenSafeWithCombination(combination).toObservable()
                    .map(isCorrect -> new CombinationCheckResult(combination, isCorrect)))
            .filter(result -> result.isCorrect)
            .map(result -> result.combination)
            .firstElement();

}

Single<List<Integer>> getPossibleCombinations() {
    final List<Integer> combinations = Arrays.asList(123, 456, 789, 321);
    return Single.just(combinations);
}

// this is expensive
final Single<Boolean> tryToOpenSafeWithCombination(int combination) {
    System.out.println("Trying to open safe with " + combination);
    final boolean isCorrectCombination = combination == 789;
    return Single.just(isCorrectCombination);
}

void tryToOpenSafe（）{
getCorrectSafeCombination（）.subscribe（组合->系统.out.println（“正确的组合是”+组合））；
}
也许是{
返回getPossibleCombinations（）
.TooObservable（）文件
.flatMapIterable（组合->组合）
.flatMap（组合->尝试打开安全带组合（组合）.toObservable（）
.map（isCorrect->new compositionCheckResult（composition，isCorrect）））
.filter（结果->结果.isCorrect）
.map（结果->结果组合）
.firstElement（）；
}
单个getPossibleCombinations（）{
最终列表组合=Arrays.asList（123456789321）；
返回单个。仅（组合）；
}
//这个很贵
最终单次尝试打开安全带组合（int组合）{
System.out.println（“尝试用“+组合”打开保险柜）；
最终布尔值isCorrectCombination=组合==789；
返回Single.just（正确的组合）；
}

我收到一个可能的“组合”（整数）列表，用于我想要打开的保险箱。当然，只有一种组合是正确的

按照我目前的方法，

getCorrectSafeCombination（）

将提供它找到的第一个正确的组合；但它将尝试所有的组合

这是有效的：只要找到正确的组合，就没有必要尝试其他组合

---

如何使用Rx实现这一点？

之所以会出现这种情况，是因为

flatMap

用于并发处理观测值，而您需要顺序处理。要解决这一问题，您只需将

flatMap

更改为

concatMap

，以确保

getCorrectSafeCombination

方法中可观察到的顺序流：

Maybe<Integer> getCorrectSafeCombination() {
    return getPossibleCombinations()
            .toObservable()
            .flatMapIterable(combinations -> combinations)
            //this one
            .concatMap(combination -> tryToOpenSafeWithCombination(combination).toObservable()
                    .map(isCorrect -> new CombinationCheckResult(combination, isCorrect)))
            .filter(result -> result.isCorrect)
            .map(result -> result.combination)
            .firstElement();

}

可能是getCorrectSafeCombination（）{
返回getPossibleCombinations（）
.TooObservable（）文件
.flatMapIterable（组合->组合）
//这个
.concatMap（组合->尝试打开安全带组合（组合）.toObservable（）
.map（isCorrect->new compositionCheckResult（composition，isCorrect）））
.filter（结果->结果.isCorrect）
.map（结果->结果组合）
.firstElement（）；
}

您使用的是什么java版本？据我所记得的，在Java10之前，flatMap是一个急切的操作。@使用Java8毫无价值。flatMap操作符属于RxJava，不应该在Java版本之间更改，对吗？您不能使用plain for and

break

？我看不出使用rxjs有什么真正的好处（在这里我几乎看不到流）。它应该让生活更轻松，而不是更艰难。这当然是一个例子。我的现实世界是这样的，需要使用Rx，并从中获利。谢谢！很简单，但看不见。