¿Romper o regresar de la secuencia Java 8 para cada uno?

Cuando usamos iteración externa sobre una Iterable, usamos breako returndesde un ciclo for-each mejorado como:

for (SomeObject obj : someObjects) {
   if (some_condition_met) {
      break; // or return obj
   }
}

¿Cómo podemos breako returnusar la iteración interna en una expresión lambda de Java 8 como:

someObjects.forEach(obj -> {
   //what to do here?
})

Si necesita esto, no debe usar forEach, sino uno de los otros métodos disponibles en las transmisiones; cuál depende de cuál sea su objetivo.

Por ejemplo, si el objetivo de este ciclo es encontrar el primer elemento que coincida con algún predicado:

Optional<SomeObject> result =
    someObjects.stream().filter(obj -> some_condition_met).findFirst();

(Nota: Esto no repetirá toda la colección, porque las secuencias se evalúan de forma perezosa; se detendrá en el primer objeto que coincida con la condición).

Si solo desea saber si hay un elemento en la colección para el cual la condición es verdadera, puede usar anyMatch:

boolean result = someObjects.stream().anyMatch(obj -> some_condition_met);

Esto es posible para Iterable.forEach()(pero no confiablemente con Stream.forEach()). La solución no es agradable, pero es posible.

ADVERTENCIA : No debe usarlo para controlar la lógica de negocios, sino únicamente para manejar una situación excepcional que ocurre durante la ejecución de forEach(). Tal como un recurso deja de ser accesible de repente, uno de los objetos procesados ​​está violando un contrato (por ejemplo, el contrato dice que todos los elementos en la secuencia no deben ser, nullpero de repente e inesperadamente uno de ellos es null), etc.

De acuerdo con la documentación para Iterable.forEach():

Realiza la acción dada para cada elemento del Iterable hasta que todos los elementos hayan sido procesados ​​o la acción arroje una excepción ... Las excepciones lanzadas por la acción se transmiten a la persona que llama.

Entonces lanzas una excepción que inmediatamente romperá el ciclo interno.

El código será algo así: no puedo decir que me guste, pero funciona. Creas tu propia clase BreakExceptionque se extiende RuntimeException.

try {
    someObjects.forEach(obj -> {
        // some useful code here
        if(some_exceptional_condition_met) {
            throw new BreakException();
       }
    }
}
catch (BreakException e) {
    // here you know that your condition has been met at least once
}

Observe que notry...catch está alrededor de la expresión lambda, sino alrededor del método completo . Para hacerlo más visible, vea la siguiente transcripción del código que lo muestra más claramente:forEach()

Consumer<? super SomeObject> action = obj -> {
    // some useful code here
    if(some_exceptional_condition_met) {
        throw new BreakException();
    }
});

try {
    someObjects.forEach(action);
}
catch (BreakException e) {
    // here you know that your condition has been met at least once
}

Un retorno en una lambda es igual a continuar en un para cada uno, pero no hay equivalente a un descanso. Solo puede hacer un regreso para continuar:

someObjects.forEach(obj -> {
   if (some_condition_met) {
      return;
   }
})

A continuación encontrará la solución que utilicé en un proyecto. En su lugar, forEachsolo use allMatch:

someObjects.allMatch(obj -> {
    return !some_condition_met;
});

O necesita usar un método que usa un predicado que indica si debe continuar (por lo que tiene el descanso) o necesita lanzar una excepción, que es un enfoque muy feo, por supuesto.

Entonces podrías escribir un forEachConditionalmétodo como este:

public static <T> void forEachConditional(Iterable<T> source,
                                          Predicate<T> action) {
    for (T item : source) {
        if (!action.test(item)) {
            break;
        }
    }
}

En lugar de Predicate<T>eso, es posible que desee definir su propia interfaz funcional con el mismo método general (algo que toma un Ty devuelve un bool) pero con nombres que indican la expectativa más claramente, Predicate<T>no es ideal aquí.

Puede usar java8 + rxjava .

//import java.util.stream.IntStream;
//import rx.Observable;

    IntStream intStream  = IntStream.range(1,10000000);
    Observable.from(() -> intStream.iterator())
            .takeWhile(n -> n < 10)
            .forEach(n-> System.out.println(n));

Para obtener el máximo rendimiento en operaciones paralelas, use findAny (), que es similar a findFirst ().

Optional<SomeObject> result =
    someObjects.stream().filter(obj -> some_condition_met).findAny();

Sin embargo, si se desea un resultado estable, use findFirst () en su lugar.

También tenga en cuenta que los patrones coincidentes (anyMatch () / allMatch) devolverán solo booleanos, no obtendrá objetos coincidentes.

Actualice con Java 9+ con takeWhile:

MutableBoolean ongoing = MutableBoolean.of(true);
someobjects.stream()...takeWhile(t -> ongoing.value()).forEach(t -> {
    // doing something.
    if (...) { // want to break;
        ongoing.setFalse();
    }
});

He logrado algo como esto

  private void doSomething() {
            List<Action> actions = actionRepository.findAll();
            boolean actionHasFormFields = actions.stream().anyMatch(actionHasMyFieldsPredicate());
            if (actionHasFormFields){
                context.addError(someError);
            }
        }
    }

    private Predicate<Action> actionHasMyFieldsPredicate(){
        return action -> action.getMyField1() != null;
    }

Puede lograrlo usando una mezcla de peek (..) y anyMatch (..).

Usando tu ejemplo:

someObjects.stream().peek(obj -> {
   <your code here>
}).anyMatch(obj -> !<some_condition_met>);

O simplemente escriba un método de utilidad genérico:

public static <T> void streamWhile(Stream<T> stream, Predicate<? super T> predicate, Consumer<? super T> consumer) {
    stream.peek(consumer).anyMatch(predicate.negate());
}

Y luego úsalo, así:

streamWhile(someObjects.stream(), obj -> <some_condition_met>, obj -> {
   <your code here>
});

¿Qué hay de este?

final BooleanWrapper condition = new BooleanWrapper();
someObjects.forEach(obj -> {
   if (condition.ok()) {
     // YOUR CODE to control
     condition.stop();
   }
});

¿Dónde BooleanWrapperhay una clase que debe implementar para controlar el flujo?

int valueToMatch = 7;
Stream.of(1,2,3,4,5,6,7,8).anyMatch(val->{
   boolean isMatch = val == valueToMatch;
   if(isMatch) {
      /*Do whatever you want...*/
       System.out.println(val);
   }
   return isMatch;
});

Solo realizará operaciones donde encuentre coincidencia, y después de encontrar coincidencia, detendrá su iteración.

Sugeriría usar anyMatch. Ejemplo:-

return someObjects.stream().anyMatch(obj -> 
    some_condition_met;
);

Puede consultar esta publicación para comprender anyMatch: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/