java 8 findFirst vs carte sur option

Question

Compte tenu de ce code:

class Foo { 
    Integer attr; 
    public Integer getAttr() {return attr;} 
} 

List<Foo> list = new ArrayList<>(); 
list.add(new Foo()); 

list.stream().map(Foo::getAttr).findAny().orElse(null); //A 
list.stream().findAny().map(Foo::getAttr).orElse(null); //B 

ligne A lance

java.lang.NullPointerException: null

tandis que la ligne B renvoie null.

Quelle est la cause de ce problème? Les deux findAny() et map() renvoient Optional<T>.

Answer 1

list.stream().map(Foo::getAttr).findAny().orElse(null); 

Java doc for streams dit que Stream « renvoie un flux constitué par les résultats de l'application de la fonction donnée aux éléments de ce courant », et findAny() « pourrait revenir aNullPointerException - si l'élément sélectionné est nul ». Dans votre classe Foo, Integer (pas int) par défaut est défini sur null car il est déclaré mais pas initialisé. voir Primitives see default values et Object initialization in Java

Initialisation est différent pour: A) classe Membres (objets et primitives) B) Variables locales

Answer 2

list.stream().map(Foo::getAttr) 

... retourne un flux avec un élément, avec une valeur de null .

Le JavaDoc pour findAny() (et findFirst()) dit:

Retours:

une option décrivant un élément de ce flux, ou un vide en option si le flux est vide

Jets:

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

Alors findAny() fait exactement comme documenté: il est la sélection d'un nul, et en conséquence, jetant NullPointerException.

Cela est logique car Optional est (toujours selon JavaDoc, mais non souligné):

Un objet conteneur qui peut ou non contenir une valeur non nulle

. .. ce qui signifie que vous pouvez garantir que Optional.ifPresent(x -> x.method()) ne lancera jamais NullPointerException en raison de x étant nulle.

Donc, findAny() n'a pas pu renvoyer Optional.of(null). Et Optional.empty() signifie que le flux était vide, pas qu'il ait trouvé une valeur nulle.

De nombreuses parties de l'infrastructure Stream/Optional découragent l'utilisation de valeurs nulles.

Vous pouvez contourner ce problème en mappant les valeurs NULL à Optionals, pour donner un Optional<Optional<Foo>> - ce qui semble un peu compliqué, mais est une représentation précise de votre domaine. Optional.empty() signifie que le flux était vide. Optional.of(Optional.empty()) signifie qu'il a trouvé un élément nul:

list.stream().map(Foo::getAttr).map(Optional::ofNullable).findAny() 

Answer 3

Eh bien, il est évidemment à cause de l'ordre dans lequel vous effectuez ces opérations et aussi parce que findAny dit explicitement: throws NullPointerException if the element selected is null

Lorsque vous map(Foo::getAttr) vous avez effectivement mappé à null, votre flux contient maintenant un null; ainsi findAny rompt avec une exception (depuis findAny est appliquée sur cette null)

L'autre opération première trouve l'objet Foo, il cartes à Foo::getAttr (il mappage ainsi Optional.empty()), ainsi orElse est appelée.

En outre, ce serait plus logique (pour moi au moins):

list.stream() 
    .findAny() 
    .flatMap(f -> Optional.ofNullable(f.getAttr())) 
    .orElse(null); 

flatMap tracerait à Optional<Integer> (attributs), dans le cas où celui-ci est empty obtenir le résultat orElse.

Answer 4

Tout d'abord, vos deux extrait de code map sont différentes opérations:

//   v--- stream intermediate operation 
list.stream().map(Foo::getAttr).findAny().orElse(null); //A 
//      v---- a Optional utility method 
list.stream().findAny().map(Foo::getAttr).orElse(null); //B 

et le NullPointerException se produit dans Stream#findAny opération, car elle ne peut pas accepter une valeur null. en raison de cela utilise Optional.of plutôt que Optional.ofNullable. et la documentation de Stream#findAny est déjà affirme:

Lancers:

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

donc si vous voulez que votre A extrait de code fonctionne bien vous doit filtrer toutes les valeurs null avant d'appeler le Stream#findAny, par exemple:

//when no elements in stream, `findAny` will be return a empty by Optional.empty() 
//              v 
list.stream().map(Foo::getAttr).filter(Objects::nonNull).findAny().orElse(null);//A