Mengapa findFirst () melontarkan NullPointerException jika elemen pertama yang ditemukannya adalah null?

Mengapa lemparan ini java.lang.NullPointerException?

List<String> strings = new ArrayList<>();
        strings.add(null);
        strings.add("test");

        String firstString = strings.stream()
                .findFirst()      // Exception thrown here
                .orElse("StringWhenListIsEmpty");
                //.orElse(null);  // Changing the `orElse()` to avoid ambiguity

Item pertama masuk stringsadalah null, yang merupakan nilai yang dapat diterima dengan sempurna. Selanjutnya, findFirst()mengembalikan sebuah Opsional , yang lebih masuk akal untuk findFirst()dapat menangani nulls.

EDIT: memperbarui orElse()menjadi kurang ambigu.

Alasan untuk ini adalah penggunaan Optional<T>dalam pengembalian. Opsional tidak boleh mengandung null. Pada dasarnya, ia tidak menawarkan cara untuk membedakan situasi "itu tidak ada" dan "itu ada di sana, tetapi sudah diatur ke null".

Itulah mengapa dokumentasi secara eksplisit melarang situasi saat nulldipilih di findFirst():

Melempar:

NullPointerException - jika elemen yang dipilih adalah null

Seperti yang telah dibahas , perancang API tidak berasumsi bahwa pengembang ingin memperlakukan nullnilai dan nilai yang tidak ada dengan cara yang sama.

Jika Anda masih ingin melakukannya, Anda dapat melakukannya secara eksplisit dengan menerapkan urutan

.map(Optional::ofNullable).findFirst().flatMap(Function.identity())

ke sungai. Hasilnya akan menjadi opsional kosong dalam kedua kasus, jika tidak ada elemen pertama atau jika elemen pertama adalah null. Jadi dalam kasus Anda, Anda dapat menggunakan

String firstString = strings.stream()
    .map(Optional::ofNullable).findFirst().flatMap(Function.identity())
    .orElse(null);

untuk mendapatkan nullnilai jika elemen pertama tidak ada atau null.

Jika Anda ingin membedakan kasus-kasus ini, Anda dapat mengabaikan flatMaplangkah berikut:

Optional<String> firstString = strings.stream()
    .map(Optional::ofNullable).findFirst().orElse(null);
System.out.println(firstString==null? "no such element":
                   firstString.orElse("first element is null"));

Ini tidak jauh berbeda dengan pertanyaan Anda yang diperbarui. Anda hanya perlu mengganti "no such element"dengan "StringWhenListIsEmpty"dan "first element is null"dengan null. Tetapi jika Anda tidak menyukai persyaratan, Anda dapat mencapainya juga seperti:

String firstString = strings.stream().skip(0)
    .map(Optional::ofNullable).findFirst()
    .orElseGet(()->Optional.of("StringWhenListIsEmpty"))
    .orElse(null);

Sekarang, firstStringakan menjadi nulljika elemen ada tetapi ada nulldan akan terjadi "StringWhenListIsEmpty"ketika tidak ada elemen.

Anda dapat menggunakan java.util.Objects.nonNulluntuk memfilter daftar sebelum menemukan

sesuatu seperti

list.stream().filter(Objects::nonNull).findFirst();

Kode berikut menggantikan findFirst()dengan limit(1)dan menggantikan orElse()dengan reduce():

String firstString = strings.
   stream().
   limit(1).
   reduce("StringWhenListIsEmpty", (first, second) -> second);

limit()memungkinkan hanya 1 elemen untuk dijangkau reduce. The BinaryOperatorpassing to reducemengembalikan 1 elemen itu atau "StringWhenListIsEmpty"jika tidak ada elemen yang mencapai reduce.

Keunggulan dari solusi ini Optionaladalah tidak dialokasikan dan BinaryOperatorlambda tidak akan mengalokasikan apa pun.

Opsional seharusnya menjadi tipe "nilai". (baca cetakan kecilnya di javadoc :) JVM bahkan dapat menggantikan semua Optional<Foo>hanya dengan Foo, menghapus semua biaya tinju dan unboxing. A nullFoo artinya kosong Optional<Foo>.

Ini adalah desain yang memungkinkan untuk mengizinkan Opsional dengan nilai null, tanpa menambahkan tanda boolean - cukup tambahkan objek sentinel. (bahkan bisa digunakan thissebagai sentinel; lihat Throwable.cause)

Keputusan bahwa Opsional tidak dapat membungkus null tidak didasarkan pada biaya runtime. Ini adalah masalah yang sangat diperdebatkan dan Anda perlu menggali milis. Keputusan tidak meyakinkan semua orang.

Dalam kasus apa pun, karena Opsional tidak dapat membungkus nilai null, itu mendorong kita ke sudut dalam kasus seperti findFirst. Mereka pasti beralasan bahwa nilai null sangat jarang (bahkan dianggap bahwa Stream harus melarang nilai null), oleh karena itu akan lebih mudah untuk melemparkan pengecualian pada nilai null daripada di streaming kosong.

Solusinya adalah dengan kotak null, misalnya

class Box<T>
    static Box<T> of(T value){ .. }

Optional<Box<String>> first = stream.map(Box::of).findFirst();

(Mereka mengatakan solusi untuk setiap masalah OOP adalah dengan memperkenalkan tipe lain :)