Bagaimana untuk Mengendalikan Pengecualian yang Diperiksa dalam Java 8 Lambda Streams?

Java 8: Aliran Lambda dan Pengendalian Pengecualian

Dalam Java 8, ungkapan lambda membawa banyak faedah kepada pemprosesan strim. Walau bagaimanapun, apabila berurusan dengan kaedah yang membuang pengecualian yang diperiksa, seperti IOException, pembangun mungkin menghadapi ralat kompilasi.

Pertimbangkan kod berikut:

<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());
    }
}</code>

Kod ini bertujuan untuk mendapatkan satu set yang diaktifkan nombor akaun. Walau bagaimanapun, ia gagal untuk menyusun kerana kaedah isActive dan getNumber membuang IOExceptions, yang mesti ditangkap atau diisytiharkan dalam tandatangan.

Menangkap Pengecualian yang Disemak dalam Ungkapan Lambda

Kepada menyelesaikan isu ini, pengecualian yang disemak mesti dikendalikan dalam ungkapan lambda itu sendiri. Walau bagaimanapun, hanya meletakkan blok cuba-tangkap dalam lambda tidak mencukupi. Pengecualian mesti ditangkap sebelum ia terlepas daripada skop lambda.

Menggunakan Pembungkus UncheckedIOException

Satu pendekatan ialah menggunakan kelas pembungkus tersuai, UncheckedIOException, yang menukar pengecualian yang ditandakan kepada yang tidak ditanda. Ini membolehkan lambda membuang pengecualian yang tidak ditanda dan dikendalikan oleh operasi strim seterusnya.

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

Menggunakan Pembalut Pengecualian Generik

Pilihan lain ialah menggunakan kaedah pembalut generik, nyahtandaPanggilan, yang menangkap sebarang jenis pengecualian dan melemparkannya semula sebagai pengecualian yang tidak ditanda.

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

Dalam kes ini, operasi strim seterusnya akan menerima pengecualian yang tidak ditanda dan boleh dikendalikan dengan sewajarnya.

Menelakkan Pemeriksaan Pengecualian Pengkompil

Pendekatan yang lebih maju melibatkan penggunaan kaedah yang melumpuhkan semakan pengecualian pengkompil dengan berkesan. Walau bagaimanapun, ini memerlukan berhati-hati dan pemahaman yang jelas tentang potensi risiko. Dalam pendekatan ini, kod berikut digunakan:

<code class="java">public static <T> T uncheckCall(Callable<T> callable) {
    try {
        return callable.call();
    } catch (Exception e) {
        sneakyThrow(e);
        return null; // Unreachable but needed to satisfy compiler
    }
}</code>

Dengan kaedah ini, pengecualian yang ditanda akan ditangkap dan dibaling semula sebagai pengecualian masa jalan. Walau bagaimanapun, adalah penting untuk ambil perhatian bahawa pendekatan ini boleh membawa kepada tingkah laku yang tidak dijangka jika pengecualian bertujuan untuk dikendalikan di tapak pelaksanaan lambda.

Atas ialah kandungan terperinci Bagaimana untuk Mengendalikan Pengecualian yang Diperiksa dalam Java 8 Lambda Streams?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!