从Java 8流中断还是返回forEach？

当在上使用外部迭代时，Iterable我们使用break或return通过增强的for-each循环进行以下操作：

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

我们如何break或在Java 8 lambda表达式中return使用内部迭代，例如：

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是不是周围的lambda表达式，而是围绕整个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
}

lambda的返回等于for-for的继续，但没有中断。您可以返回以继续：

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

你可以参考这篇文章的理解anyMatch： - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/