Перерва або повернення з потоку Java 8 forEach?

При використанні зовнішньої ітерації над Iterableвикористанням ми breakабо returnчерез розширених для кожного циклу , як:

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
}

Повернення в лямбда дорівнює продовженню в кожному, але немає еквіваленту перерви. Ви можете просто зробити повернення для продовження:

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>, ви, можливо, захочете визначити власний функціональний інтерфейс тим же загальним методом (щось, що приймає 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>);

Або просто написати загальний метод утиліти:

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

Ви можете посилатися на цю публікацію, щоб зрозуміти будь-якийMatch: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/