Para cada uno en la lista, hacer la operación hasta que se cumple la condición

asco :

Considere el siguiente código:

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);
}

Recibo una lista de posibles "combinaciones" (entero) por una caja fuerte Quiero abrir. Sólo una combinación es la correcta, por supuesto.

Con mi enfoque actual, getCorrectSafeCombination()entregará la primera combinación correcta se encontró; pero va a probar todas las combinaciones no obstante.

Esto está en aunque eficiente: tan pronto como se encuentre la combinación correcta, no hay necesidad de probar los otros.

¿Cómo se puede hacer esto con Rx?

Dmitry:

Esto sucede porque flatMapse utiliza para el procesamiento simultáneo de observables, mientras que necesita secuencial. Para corregir esto sólo tiene que cambiar su flatMapa concatMappara asegurar un flujo secuencial de los observables en su getCorrectSafeCombinationmétodo:

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();

}