Hentikan atau kembali dari aliran Java 8 forEach?

Saat menggunakan iterasi eksternal di atas Iterablekami menggunakan breakatau returndari peningkatan untuk-setiap loop sebagai:

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

Bagaimana kita bisa breakatau returnmenggunakan iterasi internal dalam ekspresi Java 8 lambda seperti:

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

Jika Anda membutuhkan ini, Anda tidak boleh menggunakan forEach, tetapi salah satu metode lain yang tersedia di stream; yang mana, tergantung pada apa tujuan Anda.

Misalnya, jika tujuan dari loop ini adalah untuk menemukan elemen pertama yang cocok dengan beberapa predikat:

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

(Catatan: Ini tidak akan mengulangi seluruh koleksi, karena aliran dievaluasi malas - itu akan berhenti di objek pertama yang cocok dengan kondisi).

Jika Anda hanya ingin tahu apakah ada elemen dalam koleksi yang kondisinya benar, Anda bisa menggunakan anyMatch:

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

Ini adalah mungkin bagi Iterable.forEach()(tetapi tidak andal dengan Stream.forEach()). Solusinya adalah tidak baik, tetapi adalah mungkin.

PERINGATAN : Anda tidak boleh menggunakannya untuk mengendalikan logika bisnis, tetapi murni untuk menangani situasi luar biasa yang terjadi selama eksekusi forEach(). Seperti sumber daya tiba-tiba berhenti diakses, salah satu objek yang diproses melanggar kontrak (mis. Kontrak mengatakan bahwa semua elemen dalam aliran tidak boleh nulltiba-tiba dan tidak terduga salah satunya null) dll.

Menurut dokumentasi untuk Iterable.forEach():

Lakukan tindakan yang diberikan untuk setiap elemen Iterable hingga semua elemen diproses atau tindakan melempar pengecualian ... Pengecualian yang dilemparkan oleh tindakan diteruskan ke pemanggil.

Jadi Anda melempar pengecualian yang akan segera memecah loop internal.

Kode akan menjadi seperti ini - saya tidak bisa mengatakan saya menyukainya tetapi berfungsi. Anda membuat kelas Anda sendiri BreakExceptionyang memanjang 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
}

Perhatikan bahwa try...catchadalah tidak sekitar ekspresi lambda, melainkan sekitar seluruh forEach()metode. Untuk membuatnya lebih terlihat, lihat transkripsi kode berikut yang menunjukkan lebih jelas:

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
}

Pengembalian dalam lambda sama dengan melanjutkan di masing-masing, tetapi tidak ada yang setara dengan istirahat. Anda bisa melakukan pengembalian untuk melanjutkan:

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

Di bawah ini Anda menemukan solusi yang saya gunakan dalam sebuah proyek. Sebaliknya forEachgunakan saja allMatch:

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

Entah Anda perlu menggunakan metode yang menggunakan predikat yang menunjukkan apakah akan terus berjalan (jadi malah ada istirahat) atau Anda perlu melempar pengecualian - yang tentu saja merupakan pendekatan yang sangat jelek.

Jadi Anda bisa menulis forEachConditionalmetode seperti ini:

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

Daripada Predicate<T>, Anda mungkin ingin mendefinisikan antarmuka fungsional Anda sendiri dengan metode umum yang sama (sesuatu mengambil Tdan mengembalikan a bool) tetapi dengan nama yang menunjukkan harapan lebih jelas - Predicate<T>tidak ideal di sini.

Anda dapat menggunakan 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));

Untuk kinerja maksimal dalam operasi paralel gunakan findAny () yang mirip dengan findFirst ().

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

Namun Jika hasil yang stabil diinginkan, gunakan findFirst () sebagai gantinya.

Perhatikan juga bahwa pola yang cocok (anyMatch () / allMatch) hanya akan mengembalikan boolean, Anda tidak akan mendapatkan objek yang cocok.

Perbarui dengan Java 9+ dengan takeWhile:

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

Saya telah mencapai sesuatu seperti ini

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

Anda dapat mencapainya menggunakan campuran peek (..) dan anyMatch (..).

Menggunakan contoh Anda:

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

Atau cukup tulis metode util generik:

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

Dan kemudian gunakan, seperti ini:

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

Bagaimana dengan yang ini:

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

Di mana BooleanWrapperkelas Anda harus menerapkan untuk mengontrol aliran.

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

Ini hanya akan melakukan operasi di mana ia menemukan kecocokan, dan setelah menemukan kecocokan itu menghentikan iterasi.

Saya sarankan menggunakan anyMatch. Contoh:-

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

Anda dapat merujuk posting ini untuk memahami anyMatch: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/