Perché findFirst () genera un'eccezione NullPointerException se il primo elemento che trova è nullo?

Perché questo genera un 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

Il primo elemento stringsè null, che è un valore perfettamente accettabile. Inoltre, findFirst()restituisce un Optional , che ha ancora più senso per findFirst()poter gestire nulls.

EDIT: aggiornato il orElse()per essere meno ambiguo.

La ragione di ciò è l'uso di Optional<T>nel ritorno. Facoltativo non è consentito contenere null. In sostanza, non offre alcun modo per distinguere le situazioni "non è lì" e "è lì, ma è impostato su null".

Ecco perché la documentazione vieta esplicitamente la situazione in cui nullè selezionato in findFirst():

Lanci:

NullPointerException - se l'elemento selezionato è null

Come già discusso , i progettisti dell'API non presumono che lo sviluppatore voglia trattare nullvalori e valori assenti allo stesso modo.

Se vuoi ancora farlo, puoi farlo esplicitamente applicando la sequenza

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

al flusso. Il risultato sarà un optional vuoto in entrambi i casi, se non c'è il primo elemento o se il primo elemento lo è null. Quindi nel tuo caso, puoi usare

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

per ottenere un nullvalore se il primo elemento è assente o null.

Se vuoi distinguere tra questi casi, puoi semplicemente omettere il flatMappassaggio:

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

Questo non è molto diverso dalla tua domanda aggiornata. Devi solo sostituire "no such element"con "StringWhenListIsEmpty"e "first element is null"con null. Ma se non ti piacciono i condizionali, puoi ottenerlo anche come:

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

Ora, firstStringsarà nullse un elemento esiste ma è nulle sarà "StringWhenListIsEmpty"quando non esiste alcun elemento.

È possibile utilizzare java.util.Objects.nonNullper filtrare l'elenco prima di trovare

qualcosa di simile a

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

Il seguente testo sostituisce il codice findFirst()con limit(1)e sostituisce orElse()con reduce():

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

limit()consente di raggiungere solo 1 elemento reduce. Il BinaryOperatorpassato a reducerestituisce quell'elemento 1 oppure "StringWhenListIsEmpty"se nessun elemento raggiunge il reduce.

La bellezza di questa soluzione è che Optionalnon viene allocata e BinaryOperatorlambda non assegnerà nulla.

Facoltativo dovrebbe essere un tipo "valore". (leggi le scritte in piccolo in javadoc :) JVM potrebbe persino sostituire tutto Optional<Foo>con solo Foo, rimuovendo tutti i costi di boxe e unboxing. Un nullFoo significa un vuoto Optional<Foo>.

È possibile che consenta l'Opzionale con un valore nullo, senza aggiungere un flag booleano: basta aggiungere un oggetto sentinel. (potrebbe anche essere usato thiscome sentinella; vedere Throwable.cause)

La decisione che Optional non può eseguire il wrapping di null non è basata sul costo di runtime. Questo è stato un problema molto dibattuto e devi scavare nelle mailing list. La decisione non convince tutti.

In ogni caso, poiché Opzionale non può racchiudere un valore nullo, ci spinge in un angolo in casi come findFirst. Devono aver ragionato sul fatto che i valori null sono molto rari (è stato persino considerato che Stream dovrebbe bloccare i valori null), quindi è più conveniente lanciare un'eccezione sui valori null invece che sui flussi vuoti.

Una soluzione alternativa è inscatolare null, ad es

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

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

(Dicono che la soluzione a ogni problema OOP sia introdurre un altro tipo :)