Pourquoi findFirst () lance-t-il une NullPointerException si le premier élément qu'il trouve est nul?

Pourquoi cela jette- java.lang.NullPointerExceptiont-il un ?

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

Le premier élément stringsest null, qui est une valeur parfaitement acceptable. De plus, findFirst()retourne une option , ce qui est encore plus logique pour findFirst()pouvoir gérer nulls.

EDIT: mis orElse()à jour le pour être moins ambigu.

La raison en est l'utilisation de Optional<T>dans le retour. Facultatif n'est pas autorisé à contenir null. Essentiellement, il n'offre aucun moyen de distinguer les situations «ce n'est pas là» et «c'est là, mais c'est réglé null».

C'est pourquoi la documentation interdit explicitement la situation lorsque nullest sélectionné dans findFirst():

Jette:

NullPointerException - si l'élément sélectionné est null

Comme indiqué précédemment , les concepteurs d'API ne supposent pas que le développeur souhaite traiter les nullvaleurs et les valeurs absentes de la même manière.

Si vous souhaitez toujours le faire, vous pouvez le faire explicitement en appliquant la séquence

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

au flux. Le résultat sera une option vide dans les deux cas, s'il n'y a pas de premier élément ou si le premier élément l'est null. Donc, dans votre cas, vous pouvez utiliser

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

pour obtenir une nullvaleur si le premier élément est absent ou null.

Si vous souhaitez faire la distinction entre ces cas, vous pouvez simplement omettre l' flatMapétape:

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

Ce n'est pas très différent de votre question mise à jour. Il suffit de remplacer "no such element"par "StringWhenListIsEmpty"et "first element is null"par null. Mais si vous n'aimez pas les conditions, vous pouvez également y parvenir comme:

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

Maintenant, ce firstStringsera nullsi un élément existe mais est nullet ce sera "StringWhenListIsEmpty"quand aucun élément n'existe.

Vous pouvez utiliser java.util.Objects.nonNullpour filtrer la liste avant de trouver

quelque chose comme

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

Le code suivant remplace findFirst()par limit(1)et remplace orElse()par reduce():

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

limit()ne permet d'atteindre qu'un seul élément reduce. Le BinaryOperatorpassé à reducerenvoie cet élément 1 ou bien "StringWhenListIsEmpty"si aucun élément n'atteint le reduce.

La beauté de cette solution est qu'elle Optionaln'est pas allouée et que le BinaryOperatorlambda n'allouera rien.

Facultatif est censé être un type "valeur". (lisez les petits caractères en javadoc :) JVM pourrait même tout remplacer Optional<Foo>par juste Foo, en supprimant tous les coûts de boxe et de déballage. Un nullFoo signifie un vide Optional<Foo>.

Il est possible d'autoriser l'option facultative avec une valeur nulle, sans ajouter un indicateur booléen - ajoutez simplement un objet sentinelle. (pourrait même utiliserthis comme sentinelle; voir Throwable.cause)

La décision selon laquelle Facultatif ne peut pas encapsuler null n'est pas basée sur le coût d'exécution. C'était un problème très controversé et vous devez creuser les listes de diffusion. La décision n'est pas convaincante pour tout le monde.

Dans tous les cas, comme Optional ne peut pas envelopper la valeur nulle, cela nous pousse dans un coin dans des cas comme findFirst . Ils ont dû penser que les valeurs nulles sont très rares (il a même été considéré que Stream devrait interdire les valeurs nulles), il est donc plus pratique de lever une exception sur des valeurs nulles plutôt que sur des flux vides.

Une solution de contournement consiste à encadrer null, par exemple

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

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

(Ils disent que la solution à chaque problème de POO est d'introduire un autre type :)