Tại sao findFirst () ném NullPointerException nếu phần tử đầu tiên nó tìm thấy là null?

Tại sao điều này ném một 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

Mục đầu tiên stringslà null, đó là một giá trị hoàn toàn chấp nhận được. Hơn nữa, findFirst()trả về một Tùy chọn , điều này thậm chí còn có ý nghĩa hơn findFirst()để có thể xử lý nulls.

EDIT: đã cập nhật orElse()để bớt mơ hồ hơn.

Lý do cho điều này là việc sử dụng Optional<T>trong trở lại. Tùy chọn không được phép chứa null. Về cơ bản, nó không có cách nào để phân biệt các tình huống "nó không ở đó" và "nó ở đó, nhưng nó được đặt thành null".

Đó là lý do tại sao tài liệu cấm hoàn toàn tình huống nullđược chọn trong findFirst():

Ném:

NullPointerException - nếu phần tử được chọn là null

Như đã thảo luận , các nhà thiết kế API không cho rằng nhà phát triển muốn xử lý nullcác giá trị và giá trị vắng mặt theo cùng một cách.

Nếu bạn vẫn muốn làm điều đó, bạn có thể làm điều đó một cách rõ ràng bằng cách áp dụng trình tự

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

đến suối. Kết quả sẽ là một tùy chọn trống trong cả hai trường hợp, nếu không có phần tử đầu tiên hoặc nếu phần tử đầu tiên là null. Vì vậy, trong trường hợp của bạn, bạn có thể sử dụng

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

để nhận nullgiá trị nếu phần tử đầu tiên vắng mặt hoặc null.

Nếu bạn muốn phân biệt giữa các trường hợp này, bạn có thể chỉ cần bỏ qua flatMapbước:

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

Điều này không khác nhiều với câu hỏi cập nhật của bạn. Bạn chỉ cần thay thế "no such element"bằng "StringWhenListIsEmpty"và "first element is null"bằng null. Nhưng nếu bạn không thích điều kiện, bạn có thể đạt được nó cũng như:

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

Bây giờ, firstStringsẽ là nullnếu một phần tử tồn tại nhưng tồn tại nullvà nó sẽ là "StringWhenListIsEmpty"khi không có phần tử nào tồn tại.

Bạn có thể sử dụng java.util.Objects.nonNullđể lọc danh sách trước khi tìm

cái gì đó như

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

Đoạn mã sau thay thế findFirst()bằng limit(1)và thay thế orElse()bằng reduce():

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

limit()chỉ cho phép 1 phần tử tiếp cận reduce. Giá trị BinaryOperatorđược truyền để reducetrả về 1 phần tử đó hoặc "StringWhenListIsEmpty"nếu không có phần tử nào đạt đến reduce.

Cái hay của giải pháp này là nó Optionalkhông được phân bổ và BinaryOperatorlambda sẽ không phân bổ bất cứ thứ gì.

Tùy chọn được cho là một loại "giá trị". (đọc bản in đẹp trong javadoc :) JVM thậm chí có thể thay thế tất cả Optional<Foo>bằng chỉ Foo, loại bỏ tất cả chi phí quyền anh và mở hộp. Một nullFoo nghĩa là trống rỗng Optional<Foo>.

Đây là một thiết kế khả thi để cho phép Tùy chọn với giá trị null mà không cần thêm cờ boolean - chỉ cần thêm một đối tượng sentinel. (thậm chí có thể sử dụng thislàm lính canh; xem Throwable.cause)

Quyết định rằng Tùy chọn không thể bọc null không dựa trên chi phí thời gian chạy. Đây là một vấn đề vô cùng gay gắt và bạn cần phải tìm hiểu danh sách gửi thư. Quyết định này không thuyết phục tất cả mọi người.

Trong mọi trường hợp, vì Tùy chọn không thể bọc giá trị null, nên nó đẩy chúng ta vào một góc trong các trường hợp như findFirst. Họ phải lý giải rằng giá trị null là rất hiếm (thậm chí còn được coi là Stream phải chặn các giá trị null), do đó sẽ thuận tiện hơn nếu ném ngoại lệ trên các giá trị null thay vì trên các luồng trống.

Một cách giải quyết là đóng hộp null, ví dụ:

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

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

(Họ nói rằng giải pháp cho mọi vấn đề OOP là giới thiệu một loại khác :)