Bagaimana Mengendalikan Pengecualian dalam Ungkapan Lambda Java 8 Semasa Menapis Strim?

Java 8: Lambda-Streams - Penapisan mengikut Kaedah yang Melemparkan Pengecualian

Ekspresi lambda Java 8 menawarkan cara yang berkesan untuk memanipulasi dan memproses data. Walau bagaimanapun, apabila berurusan dengan kaedah yang boleh mengeluarkan pengecualian, adalah penting untuk menavigasi had ungkapan lambda dan meneroka penyelesaian yang berkesan.

Masalahnya:

Pertimbangkan kod berikut serpihan:

<code class="java">class Bank {
    public Set<String> getActiveAccountNumbers() throws IOException {
        Stream<Account> s = accounts.values().stream();
        s = s.filter(a -> a.isActive());
        Stream<String> ss = s.map(a -> a.getNumber());
        return ss.collect(Collectors.toSet());
    }
}

interface Account {
    boolean isActive() throws IOException;
    String getNumber() throws IOException;
}</code>

Kod ini gagal dihimpun disebabkan oleh pengecualian yang diperiksa yang dilemparkan oleh kaedah isActive dan getNumber. Hanya menangkap pengecualian dalam blok cuba-tangkap di sekeliling tidak mencukupi, kerana pengecualian tidak dikendalikan dengan betul dalam ungkapan lambda.

Penyelesaian:

Untuk mengatasi isu ini, kita perlu menangkap pengecualian sebelum mereka melarikan diri daripada ungkapan lambda. Satu pendekatan ialah menggunakan pengecualian yang tidak disemak, seperti yang dilihat dalam serpihan kod yang diubah suai berikut:

<code class="java">s = s.filter(a -> {
    try {
        return a.isActive();
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
});</code>

Di sini, kami menangkap IOException dalam lambda dan membuang pengecualian yang tidak disemak, memastikan ia dikendalikan dengan betul dalam lambda ungkapan.

Sebagai alternatif, kita boleh menggunakan kaedah pembalut yang menterjemahkan pengecualian yang ditandakan kepada yang tidak ditanda:

<code class="java">return s.filter(a -> uncheckCall(a::isActive))
        .map(Account::getNumber)
        .collect(toSet());

public static <T> T uncheckCall(Callable<T> callable) {
    try {
        return callable.call();
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}</code>

Ini membolehkan kami membungkus ungkapan lambda dalam panggilan untuk nyahtandaPanggilan, yang mengendalikan memeriksa pengecualian secara dalaman, meninggalkan ungkapan lambda bebas daripada pengisytiharan pengecualian yang diperiksa.

Pertimbangan Lain:

Adalah penting untuk mengambil kira hakikat bahawa pengecualian tertentu masih boleh terlepas daripada ungkapan lambda, walaupun dengan penyelesaian yang dicadangkan. Sebagai contoh, pengecualian yang dilemparkan semasa penilaian operasi pengumpulan masih akan disebarkan keluar dari lambda.

Atas ialah kandungan terperinci Bagaimana Mengendalikan Pengecualian dalam Ungkapan Lambda Java 8 Semasa Menapis Strim?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!