Romper o volver de Java 8 stream forEach?

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

ADVERTENCIA: No debe usarlo para controlar la lógica de negocio, sino puramente para manejar una situación excepcional que ocurre durante la ejecución del forEach(). 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 el flujo no deben ser null pero 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 de la Iterable hasta que todos los elementos hayan sido procesados o la acción lanza 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 bucle interno.

El código será algo como esto - No puedo decir que me guste pero funciona. Usted crea su propia clase BreakException que 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 el try...catch es no alrededor de la expresión lambda, sino alrededor de todo el método forEach(). Para hacerlo más visible, vea la siguiente transcripción del código que lo muestra más claramente:

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 un continuar en una para-cada uno, pero no hay equivalente a un break. Solo puede hacer una vuelta 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 {[1] } solo use allMatch:

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

Ya sea necesitas usar un método que use un predicado que indique si debes seguir adelante (por lo que tiene el break en su lugar) o necesitas lanzar una excepción, lo cual es un enfoque muy feo, por supuesto.

Así que podrías escribir un método forEachConditional 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>, es posible que desee definir su propia interfaz funcional con el mismo método general (algo que toma un T y devuelve un bool) pero con nombres que indican la expectativa más claramente - Predicate<T> no es ideal aquí.

Puedes 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 utilice 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á objeto coincidente.

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

Puedes lograr eso usando una mezcla de peek(..) y anyMatch(..).

Usando su ejemplo:

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

O simplemente escriba un método util 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 usarlo, así:

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

No es fácil hacerlo con las API proporcionadas en JDK. Pero podemos hacerlo por AbacusUtil . Aquí está el código de ejemplo:

Stream.of("a", "b", "c", "d", "e").peek(N::println) //
        .forEach("", (r, e) -> r + e, (e, r) -> e.equals("c"));
// print: a b c

Divulgación： Soy el desarrollador de AbacusUtil.

¿Qué hay de este:

Final BooleanWrapper condition = new BooleanWrapper ();

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

Donde BooleanWrapper es una clase que debe implementar para controlar el flujo.