Unterbrechen oder von Java 8 Stream für jeden zurückkehren?

Wenn Sie eine externe Iteration über eine verwenden, verwenden Iterablewir breakoder eine returnerweiterte für jede Schleife als:

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

Wie können breakoder returnverwenden wir die interne Iteration in einem Java 8-Lambda-Ausdruck wie:

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

Wenn Sie dies benötigen, sollten Sie nicht verwenden forEach eine der anderen in Streams verfügbaren Methoden verwenden. Welches, hängt davon ab, was Ihr Ziel ist.

Wenn das Ziel dieser Schleife beispielsweise darin besteht, das erste Element zu finden, das einem Prädikat entspricht:

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

(Hinweis: Dadurch wird nicht die gesamte Sammlung iteriert, da Streams träge ausgewertet werden. Es wird beim ersten Objekt angehalten, das der Bedingung entspricht.)

Wenn Sie nur wissen möchten, ob die Sammlung ein Element enthält, für das die Bedingung erfüllt ist, können Sie Folgendes verwenden anyMatch:

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

Dies ist möglich für Iterable.forEach()(aber nicht zuverlässig mit Stream.forEach()). Die Lösung ist nicht schön, aber es ist möglich.

WARNUNG : Sie sollten es nicht zur Steuerung der Geschäftslogik verwenden, sondern nur zur Behandlung einer Ausnahmesituation, die während der Ausführung der forEach(). Wenn eine Ressource plötzlich nicht mehr zugänglich ist, verstößt eines der verarbeiteten Objekte gegen einen Vertrag (z. B. besagt der Vertrag, dass nicht alle Elemente im Stream vorhanden sein dürfen, nullsondern plötzlich und unerwartet eines davonnull ) usw.

Gemäß der Dokumentation für Iterable.forEach():

Führt die angegebene Aktion für jedes Element von aus, Iterable bis alle Elemente verarbeitet wurden oder die Aktion eine Ausnahme auslöst ... Von der Aktion ausgelöste Ausnahmen werden an den Aufrufer weitergeleitet.

Sie lösen also eine Ausnahme aus, die die interne Schleife sofort unterbricht.

Der Code wird ungefähr so ​​sein - ich kann nicht sagen, dass er mir gefällt, aber er funktioniert. Sie erstellen Ihre eigene Klasse, BreakExceptiondie erweitert wird 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
}

Beachten Sie, dass try...catches sich nicht um den Lambda-Ausdruck handelt, sondern um die gesamte forEach()Methode. Um es besser sichtbar zu machen, lesen Sie die folgende Transkription des Codes, die es deutlicher zeigt:

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
}

Eine Rendite in einem Lambda entspricht einer Fortsetzung in einem For-Each, aber es gibt kein Äquivalent zu einer Pause. Sie können einfach zurückkehren, um fortzufahren:

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

Unten finden Sie die Lösung, die ich in einem Projekt verwendet habe. forEachVerwenden Sie stattdessen einfach allMatch:

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

Entweder müssen Sie eine Methode verwenden, die ein Prädikat verwendet, das angibt, ob Sie weitermachen möchten (also hat es stattdessen die Pause) oder Sie müssen eine Ausnahme auslösen - was natürlich ein sehr hässlicher Ansatz ist.

Sie könnten also eine forEachConditionalMethode wie diese schreiben :

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

Stattdessen Predicate<T>möchten Sie möglicherweise Ihre eigene funktionale Schnittstelle mit derselben allgemeinen Methode definieren (etwas, das a nimmt Tund a zurückgibt bool), aber mit Namen, die die Erwartung deutlicher anzeigen - Predicate<T>ist hier nicht ideal.

Sie können java8 + rxjava verwenden .

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

Verwenden Sie für maximale Leistung bei parallelen Operationen findAny (), ähnlich wie findFirst ().

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

Wenn jedoch ein stabiles Ergebnis gewünscht wird, verwenden Sie stattdessen findFirst ().

Beachten Sie auch, dass übereinstimmende Muster (anyMatch () / allMatch) nur boolesche Werte zurückgeben. Sie erhalten kein übereinstimmendes Objekt.

Update mit Java 9+ mit takeWhile:

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

Ich habe durch so etwas erreicht

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

Sie können dies mit einer Mischung aus Peek (..) und anyMatch (..) erreichen.

Anhand Ihres Beispiels:

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

Oder schreiben Sie einfach eine generische util-Methode:

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

Und dann benutze es so:

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

Was ist mit diesem:

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

Wo BooleanWrapperist eine Klasse, die Sie implementieren müssen, um den Fluss zu steuern?

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

Es wird nur dort ausgeführt, wo eine Übereinstimmung gefunden wird, und nach der Suche nach Übereinstimmung wird die Iteration gestoppt.

Ich würde vorschlagen, anyMatch zu verwenden. Beispiel:-

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

Sie können diesen Beitrag zum Verständnis von anyMatch lesen: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/