Quebrar ou retornar do Java 8 stream forEach?

Ao usar a iteração externa sobre um Iterablenós usamos breakou returndo aprimorado para cada loop como:

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

Como podemos breakou returnusando a iteração interna em uma expressão lambda do Java 8 como:

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

Se você precisar disso, não deve usar forEach, mas um dos outros métodos disponíveis nos fluxos; qual deles depende de qual é seu objetivo.

Por exemplo, se o objetivo desse loop for encontrar o primeiro elemento que corresponda a algum predicado:

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

(Nota: Isso não irá iterar a coleção inteira, porque os fluxos são avaliados preguiçosamente - ele pára no primeiro objeto que corresponde à condição).

Se você quiser apenas saber se há um elemento na coleção para o qual a condição é verdadeira, você pode usar anyMatch:

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

Isso é possível para Iterable.forEach()(mas não de maneira confiável Stream.forEach()). A solução não é boa, mas é possível.

AVISO : Você não deve usá-lo para controlar a lógica de negócios, mas apenas para lidar com uma situação excepcional que ocorre durante a execução do forEach(). Como um recurso repentinamente deixa de ser acessível, um dos objetos processados ​​está violando um contrato (por exemplo, o contrato diz que todos os elementos no fluxo não devem ser, de maneira nullrepentina e inesperada, um deles é null) etc.

De acordo com a documentação para Iterable.forEach():

Executa a ação especificada para cada elemento do Iterable até que todos os elementos tenham sido processados ​​ou a ação lança uma exceção ... As exceções lançadas pela ação são retransmitidas para o chamador.

Então você lança uma exceção que interrompe imediatamente o loop interno.

O código será algo assim - não posso dizer que gosto, mas funciona. Você cria sua própria classe BreakExceptionque se 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
}

Observe que o nãotry...catch está relacionado à expressão lambda, mas ao redor de todo o método. Para torná-lo mais visível, consulte a seguinte transcrição do código que mostra mais 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
}

Um retorno em um lambda é igual a um continuar em um para cada, mas não há equivalente a uma interrupção. Você pode simplesmente fazer um retorno para continuar:

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

Abaixo você encontra a solução que usei em um projeto. Em vez disso, forEachbasta usar allMatch:

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

Ou você precisa usar um método que use um predicado indicando se deve continuar (para que ele ocorra) ou você deve lançar uma exceção - que é uma abordagem muito feia, é claro.

Então você pode escrever um forEachConditionalmétodo como este:

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

Em vez disso Predicate<T>, convém definir sua própria interface funcional com o mesmo método geral (algo usando Tae retornando a bool), mas com nomes que indiquem a expectativa mais claramente - Predicate<T>não é o ideal aqui.

Você pode usar o 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 obter o desempenho máximo em operações paralelas, use findAny (), que é semelhante ao findFirst ().

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

No entanto, se um resultado estável for desejado, use findFirst ().

Observe também que os padrões correspondentes (anyMatch () / allMatch) retornarão apenas booleanos; você não obterá o objeto correspondente.

Atualize com Java 9+ com takeWhile:

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

Eu consegui por algo assim

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

Você pode conseguir isso usando uma mistura de peek (..) e anyMatch (..).

Usando seu exemplo:

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

Ou apenas escreva um 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());
}

E então use-o, assim:

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

Que tal este:

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

Onde BooleanWrapperestá uma classe que você deve implementar para controlar o fluxo.

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

Ele fará apenas a operação onde encontrar correspondência e, depois de encontrar correspondência, interrompa sua iteração.

Eu sugeriria o uso de anyMatch. Exemplo:-

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

Você pode consultar esta publicação para entender o anyMatch: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/