Перерыв или возврат из потока Java 8 forEach?

При использовании внешней итерации над циклом Iterableмы используем breakили returnиз расширенного цикла for-each как:

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

Как мы можем breakили с returnпомощью внутренней итерации в лямбда - выражения Java 8 , как:

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

Если вам это нужно, вы не должны использовать forEach, но один из других методов, доступных в потоках; какой, зависит от вашей цели.

Например, если целью этого цикла является поиск первого элемента, который соответствует некоторому предикату:

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

(Примечание: это не будет повторять всю коллекцию, потому что потоки лениво оцениваются - это остановится на первом объекте, который соответствует условию).

Если вы просто хотите узнать, есть ли в коллекции элемент, для которого выполняется условие, вы можете использовать anyMatch:

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

Это является возможным Iterable.forEach()(но не надежно с Stream.forEach()). Решение не хорошо, но это возможно.

ВНИМАНИЕ : Вы не должны использовать его для управления бизнес-логикой, а исключительно для обработки исключительной ситуации, возникающей во время выполнения forEach(). Например, если ресурс внезапно перестает быть доступным, один из обработанных объектов нарушает контракт (например, контракт говорит, что все элементы в потоке не должны быть, nullно внезапно и неожиданно одним из них является null) и т. Д.

Согласно документации для Iterable.forEach():

Выполняет данное действие для каждого элемента до тех Iterable пор, пока все элементы не будут обработаны или действие не вызовет исключение ... Исключения, сгенерированные действием, передаются вызывающей стороне.

Таким образом, вы бросаете исключение, которое немедленно прервет внутренний цикл.

Код будет примерно таким - я не могу сказать, что мне это нравится, но он работает. Вы создаете свой собственный класс, BreakExceptionкоторый расширяется 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
}

Обратите внимание , что try...catchэто не вокруг лямбда - выражения, а вокруг весь 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
}

Возврат в лямбде равен продолжению в for-each, но нет эквивалента перерыву. Вы можете просто сделать возврат, чтобы продолжить:

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

Ниже вы найдете решение, которое я использовал в проекте. Вместо этого forEachпросто используйте allMatch:

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

Либо вам нужно использовать метод, который использует предикат, указывающий, следует ли продолжать (то есть вместо этого есть перерыв), либо вам нужно сгенерировать исключение - что, конечно, очень уродливый подход.

Таким образом, вы можете написать такой forEachConditionalметод:

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

Вместо Predicate<T>этого вы можете захотеть определить свой собственный функциональный интерфейс с помощью того же общего метода (что-то, принимающего a Tи возвращающего a bool), но с именами, которые более четко обозначают ожидание - Predicate<T>здесь не идеально.

Вы можете использовать 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));

Для максимальной производительности в параллельных операциях используйте findAny (), который похож на findFirst ().

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

Однако, если требуется стабильный результат, используйте вместо него findFirst ().

Также обратите внимание, что соответствующие шаблоны (anyMatch () / allMatch) будут возвращать только логическое значение, вы не получите соответствующий объект.

Обновление с помощью Java 9+ takeWhile:

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

Я достиг чего-то вроде этого

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

Вы можете добиться этого, используя сочетание peek (..) и anyMatch (..).

Используя ваш пример:

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

Или просто напишите универсальный метод util:

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

И затем используйте это, как это:

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

Что насчет этого:

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

Где BooleanWrapperкласс, который вы должны реализовать для управления потоком.

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

Он будет выполнять только ту операцию, в которой он находит совпадение, а после поиска совпадения останавливает свою итерацию.

Я бы предложил использовать anyMatch. Пример:-

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

Вы можете сослаться на этот пост для понимания любого соответствия: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/