Pause ou retour du flux Java 8 pour chacun?

Lorsque vous utilisez une itération externe sur une boucle que Iterablenous utilisons breakou à returnpartir de pour chaque boucle améliorée comme:

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

Comment pouvons-nous breakou returnutiliser l' itération interne dans une expression lambda Java 8 comme:

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

Si vous en avez besoin, vous ne devriez pas utiliser forEach, mais l'une des autres méthodes disponibles sur les flux; lequel dépend de votre objectif.

Par exemple, si le but de cette boucle est de trouver le premier élément qui correspond à un prédicat:

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

(Remarque: cela n'itérera pas toute la collection, car les flux sont évalués paresseusement - cela s'arrêtera au premier objet qui correspond à la condition).

Si vous voulez simplement savoir s'il y a un élément dans la collection pour lequel la condition est vraie, vous pouvez utiliser anyMatch:

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

Ceci est possible pour Iterable.forEach()(mais pas de manière fiable avec Stream.forEach()). La solution est pas agréable, mais il est possible.

AVERTISSEMENT : vous ne devez pas l'utiliser pour contrôler la logique métier, mais uniquement pour gérer une situation exceptionnelle qui se produit pendant l'exécution de la forEach(). Comme une ressource cesse soudainement d'être accessible, l'un des objets traités viole un contrat (par exemple, le contrat dit que tous les éléments du flux ne doivent pas l'être nullmais que soudainement et de manière inattendue l'un d'entre eux l'est null), etc.

Selon la documentation de Iterable.forEach():

Exécute l'action donnée pour chaque élément du Iterable jusqu'à ce que tous les éléments aient été traités ou que l'action lève une exception ... Les exceptions levées par l'action sont relayées à l'appelant.

Vous lancez donc une exception qui rompra immédiatement la boucle interne.

Le code sera quelque chose comme ça - je ne peux pas dire que je l'aime mais ça marche. Vous créez votre propre classe BreakExceptionqui s'étend 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
}

Notez que le try...catchn'est pas autour de l'expression lambda, mais plutôt autour de la forEach()méthode entière . Pour le rendre plus visible, consultez la transcription suivante du code qui le montre plus clairement:

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 retour dans un lambda équivaut à une poursuite dans un pour chacun, mais il n'y a pas d'équivalent à une pause. Vous pouvez simplement faire un retour pour continuer:

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

Vous trouverez ci-dessous la solution que j'ai utilisée dans un projet. forEachUtilisez plutôt allMatch:

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

Soit vous devez utiliser une méthode qui utilise un prédicat indiquant s'il faut continuer (donc il a la pause à la place) ou vous devez lever une exception - ce qui est une approche très laide, bien sûr.

Vous pouvez donc écrire une forEachConditionalméthode comme celle-ci:

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

Au lieu de cela Predicate<T>, vous voudrez peut-être définir votre propre interface fonctionnelle avec la même méthode générale (quelque chose prenant un Tet retournant un bool) mais avec des noms qui indiquent l'attente plus clairement - Predicate<T>n'est pas idéal ici.

Vous pouvez utiliser 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));

Pour des performances maximales dans les opérations parallèles, utilisez findAny () qui est similaire à findFirst ().

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

Cependant, si un résultat stable est souhaité, utilisez plutôt findFirst ().

Notez également que les modèles correspondants (anyMatch () / allMatch) renverront uniquement des booléens, vous n'obtiendrez pas d'objet correspondant.

Mettre à jour avec Java 9+ avec takeWhile:

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

J'ai réalisé quelque chose comme ça

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

Vous pouvez y parvenir en utilisant un mélange de coup d'oeil (..) et anyMatch (..).

En utilisant votre exemple:

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

Ou écrivez simplement une méthode d'utilisation générique:

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

Et puis utilisez-le, comme ceci:

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

Et celui-ci:

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

Où BooleanWrapperest une classe que vous devez implémenter pour contrôler le flux.

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

Il ne fera que l'opération où il trouvera la correspondance, et après la recherche de correspondance, il arrêtera son itération.

Je suggère d'utiliser anyMatch. Exemple:-

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

Vous pouvez consulter cet article pour comprendre anyMatch: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/