Przerwać lub powrócić ze strumienia Java 8 dla każdego?

Podczas korzystania z zewnętrznej iteracji w pętli Iterableużywamy breaklub returnz rozszerzonej dla każdej pętli jako:

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

Jak możemy breaklub returnużywając wewnętrznej iteracji w wyrażeniu lambda Java 8, takim jak:

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

Jeśli potrzebujesz tego, nie powinieneś używać forEach, ale jednej z innych metod dostępnych w strumieniach; który zależy od tego, jaki jest twój cel.

Na przykład, jeśli celem tej pętli jest znalezienie pierwszego elementu, który pasuje do jakiegoś predykatu:

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

(Uwaga: nie spowoduje to iteracji całej kolekcji, ponieważ strumienie są leniwie oceniane - zatrzyma się na pierwszym obiekcie spełniającym warunek).

Jeśli chcesz tylko wiedzieć, czy w kolekcji jest element, dla którego warunek jest spełniony, możesz użyć anyMatch:

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

Jest to możliwe Iterable.forEach()(ale nie w sposób niezawodny Stream.forEach()). Rozwiązanie nie jest miłe, ale jest możliwe.

OSTRZEŻENIE : Nie należy go używać do kontrolowania logiki biznesowej, lecz wyłącznie do obsługi wyjątkowej sytuacji, która występuje podczas wykonywania forEach(). Tak jak zasób nagle przestaje być dostępny, jeden z przetwarzanych obiektów narusza umowę (np. Umowa mówi, że wszystkie elementy w strumieniu nie mogą być, nullale nagle i nieoczekiwanie jednym z nich jest null) itp.

Zgodnie z dokumentacją dla Iterable.forEach():

Wykonuje podaną akcję dla każdego elementu, Iterable dopóki wszystkie elementy nie zostaną przetworzone lub akcja wygeneruje wyjątek ... Wyjątki zgłoszone przez akcję są przekazywane do osoby wywołującej.

Zgłaszasz wyjątek, który natychmiast przerwie wewnętrzną pętlę.

Kod będzie mniej więcej taki - nie mogę powiedzieć, że mi się podoba, ale działa. Tworzysz własną klasę, BreakExceptionktóra się rozszerza 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
}

Zauważ, że try...catchto nie wokół wyrażenie lambda, ale raczej po całym forEach()metoda. Aby uczynić go bardziej widocznym, zobacz następującą transkrypcję kodu, który pokazuje go wyraźniej:

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
}

Zwrot w lambda równa się kontynuacji w for-each, ale nie ma odpowiednika przerwy. Możesz po prostu wrócić, aby kontynuować:

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

Poniżej znajdziesz rozwiązanie, którego użyłem w projekcie. Zamiast tego forEachużyj allMatch:

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

Albo musisz użyć metody, która korzysta z predykatu wskazującego, czy kontynuować (więc zamiast tego ma przerwę), albo musisz zgłosić wyjątek - co jest bardzo brzydkim podejściem.

Więc możesz napisać taką forEachConditionalmetodę:

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

Zamiast tego Predicate<T>możesz zdefiniować własny interfejs funkcjonalny za pomocą tej samej ogólnej metody (coś biorąc Ti zwracając a bool), ale z nazwami, które wyraźniej wskazują na oczekiwania - Predicate<T>nie jest tutaj idealne.

Możesz użyć 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));

Aby uzyskać maksymalną wydajność w operacjach równoległych, użyj findAny (), który jest podobny do findFirst ().

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

Jeśli jednak pożądany jest stabilny wynik, zamiast tego użyj findFirst ().

Zauważ również, że pasujące wzorce (anyMatch () / allMatch) zwrócą tylko wartość logiczną, nie otrzymasz dopasowanego obiektu.

Zaktualizuj do wersji Java 9+ z takeWhile:

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

Osiągnąłem coś takiego

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

Możesz to osiągnąć, używając kombinacji peek (..) i anyMatch (..).

Na twoim przykładzie:

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

Lub po prostu napisz ogólną metodę util:

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

A następnie użyj go w następujący sposób:

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

A co z tym:

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

Gdzie BooleanWrapperjest klasa, którą należy wdrożyć, aby kontrolować przepływ.

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

Wykona operację tylko tam, gdzie znajdzie dopasowanie, a po znalezieniu dopasowania zatrzyma iterację.

Sugerowałbym użycie anyMatch. Przykład:-

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

Możesz odnieść się do tego postu, aby zrozumieć anyMatch: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/