中断するか、Java 8ストリームから戻るか？

使用する場合は、外部反復を介してIterable我々の使用breakまたはreturnのために、各ループのように強化さから：

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

どのように、breakまたは次のようなJava 8ラムダ式で内部反復returnを使用できますか？

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

これが必要な場合は、を使用するべきではありませんがforEach、ストリームで使用可能な他のメソッドの1つです。どれがあなたの目標が何であるかに依存します。

たとえば、このループの目的が、いくつかの述語に一致する最初の要素を見つけることである場合：

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()。リソースへのアクセスが突然停止するなど、処理されたオブジェクトの1つがコントラクトに違反しています（たとえば、コントラクトでは、ストリーム内のすべての要素nullが突然ではなく予期せず1つである必要があります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));

並列操作で最大のパフォーマンスを得るには、findFirst（）と同様のfindAny（）を使用します。

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/