Interrompere o tornare dal flusso Java 8 per ogni?

Quando si utilizza l' iterazione esterna su un Iterableche utilizziamo breako returnda un ciclo avanzato per ogni come:

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

Come possiamo breako returnusare l' iterazione interna in un'espressione lambda di Java 8 come:

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

Se ne hai bisogno, non dovresti usare forEach, ma uno degli altri metodi disponibili sugli stream; quale, dipende da quale sia il tuo obiettivo.

Ad esempio, se l'obiettivo di questo ciclo è trovare il primo elemento che corrisponde a un predicato:

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

(Nota: questo non ripeterà l'intera raccolta, poiché i flussi vengono valutati pigramente - si fermerà al primo oggetto che corrisponde alla condizione).

Se vuoi solo sapere se c'è un elemento nella raccolta per cui la condizione è vera, puoi usare anyMatch:

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

Questo è possibile per Iterable.forEach()(ma non in modo affidabile con Stream.forEach()). La soluzione non è bella, ma è possibile.

AVVERTENZA : non è necessario utilizzarlo per controllare la logica aziendale, ma esclusivamente per gestire una situazione eccezionale che si verifica durante l'esecuzione di forEach(). Ad esempio, quando una risorsa smette improvvisamente di essere accessibile, uno degli oggetti elaborati viola un contratto (ad esempio, il contratto afferma che tutti gli elementi nel flusso non devono essere nullma improvvisamente e inaspettatamente uno di essi è null) ecc.

Secondo la documentazione per Iterable.forEach():

Esegue l'azione specificata per ciascun elemento di Iterable fino a quando tutti gli elementi non sono stati elaborati o l'azione genera un'eccezione ... Le eccezioni generate dall'azione vengono inoltrate al chiamante.

Quindi si genera un'eccezione che interromperà immediatamente il ciclo interno.

Il codice sarà qualcosa del genere - non posso dire che mi piace ma funziona. Crea la tua classe BreakExceptionche si estende 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
}

Si noti che il nontry...catch è attorno all'espressione lambda, ma piuttosto attorno all'intero metodo. Per renderlo più visibile, vedere la seguente trascrizione del codice che lo mostra più chiaramente: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 ritorno in un lambda equivale a un proseguimento in un for-each, ma non c'è equivalente a una pausa. Puoi semplicemente fare un ritorno per continuare:

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

Di seguito trovi la soluzione che ho usato in un progetto. Invece forEachusa solo allMatch:

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

O è necessario utilizzare un metodo che utilizza un predicato che indica se continuare (quindi ha invece l'interruzione) o è necessario lanciare un'eccezione, che è ovviamente un approccio molto brutto.

Quindi potresti scrivere un forEachConditionalmetodo come questo:

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

Piuttosto che Predicate<T>, potresti voler definire la tua interfaccia funzionale con lo stesso metodo generale (qualcosa che prende a Te restituisce a bool) ma con nomi che indicano più chiaramente le aspettative - Predicate<T>qui non è l'ideale.

Puoi usare 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));

Per prestazioni massime in operazioni parallele utilizzare findAny () che è simile a findFirst ().

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

Tuttavia, se si desidera un risultato stabile, utilizzare invece findFirst ().

Si noti inoltre che i pattern corrispondenti (anyMatch () / allMatch) restituiranno solo booleani, non si otterrà l'oggetto corrispondente.

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

Ho raggiunto qualcosa di simile

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

Puoi farlo usando un mix di peek (..) e anyMatch (..).

Usando il tuo esempio:

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

O semplicemente scrivi un metodo util generico:

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

E poi usalo, in questo modo:

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

Che dire di questo:

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

Dov'è BooleanWrapperuna classe che devi implementare per controllare il flusso.

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

Farà solo operazioni dove trova match, e dopo find match si ferma è iterazione.

Suggerirei di utilizzare anyMatch. Esempio:-

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

Puoi fare riferimento a questo post per capire anyMatch: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/