Les valeurs de filtre à condition de ne pas null à l'aide de lambda dans Java8

J'ai une liste d'objets de dire car. Je veux filtrer cette liste en fonction de certains paramètres à l'aide de Java 8. Mais si le paramètre est null, il jette NullPointerException. Comment filtrer les valeurs null?

Actuel code est comme suit

requiredCars = cars.stream().filter(c -> c.getName().startsWith("M"));

Ce lève NullPointerException si getName() retourne null.

Voulez-vous “des valeurs de filtre à condition de ne pas null” ou “filtrer les valeurs null”? Que les sons se contredire pour moi.
Pourrais-je suggérer que vous acceptez Tunaki réponse comme il semble être le seul qui, de fait, les réponses à votre question.

InformationsquelleAutor vaibhavvc1092 | 2015-10-01

275

Dans cet exemple particulier, je pense que @Tagir est correct à 100% de l'obtenir dans un filtre et de faire les deux contrôles. Je ne voudrais pas utiliser Optional.ofNullable l'Option stuff est vraiment pour les types de retour de ne pas faire de la logique... mais vraiment ni ici, ni là.

Je tenais à préciser que java.util.Objects a une belle méthode pour cela dans une vaste affaire, de sorte que vous pouvez le faire:
```
cars.stream()
    .filter(Objects::nonNull)
```
Qui va effacer vos objets nuls. Pour quiconque n'est pas familier, c'est le court-main pour les éléments suivants:
```
cars.stream()
    .filter(car -> Objects.nonNull(car))
```
Pour répondre partiellement à la question à portée de main pour retourner la liste des noms de voiture qui démarre avec "M":
```
cars.stream()
    .filter(car -> Objects.nonNull(car))
    .map(car -> car.getName())
    .filter(carName -> Objects.nonNull(carName))
    .filter(carName -> carName.startsWith("M"))
    .collect(Collectors.toList());
```
Une fois que vous vous habituez à l'abréviation lambdas vous pourriez aussi le faire:
```
cars.stream()
    .filter(Objects::nonNull)
    .map(Car::getName)        //Assume the class name for car is Car
    .filter(Objects::nonNull)
    .filter(carName -> carName.startsWith("M"))
    .collect(Collectors.toList());
```
Malheureusement, une fois que vous .map(Car::getName) vous n'aurez qu'à retourner à la liste des noms, pas les voitures. Donc, moins beau mais répond pleinement à la question:
```
cars.stream()
    .filter(car -> Objects.nonNull(car))
    .filter(car -> Objects.nonNull(car.getName()))
    .filter(car -> car.getName().startsWith("M"))
    .collect(Collectors.toList());
```
- notez que la valeur null voiture n'est pas la question. Dans ce cas, c'est le nom de la propriété à l'origine des problèmes. Donc Objects::nonNull ne peut pas être utilisé ici, et dans les derniers conseils, il devrait être cars.stream() .filter(car -> Objects.nonNull(car.getName())) je crois
- BTW, je pense que cars.stream() .filter(car -> Objects.nonNull(car.getName()) && car.getName().startsWith("M")) serait le résumé de vos conseils dans cette question de contexte
- C'est un bon point que l'appel .startWith pourrait aussi provoquer un pointeur null. Le point que j'essayais de faire, c'est que Java fournit une méthode spécialement pour filtrer les objets nuls à partir de votre flux.
- Stand oui, évidemment Objects.nonNull est équivalent à != null, votre option est plus courte
- N'êtes-vous pas de la création d'une liste de noms de voiture (String) au lieu des voitures (Car)?
- Vraiment le droit, une fois que vous avez la carte de getName c'est juste une liste de Chaînes de caractères. Je vais mettre à jour la réponse. Merci!!!!
- Il est plus efficace d'utiliser la méthode de référence d'Objets:non null (première option) que l'aide de la flèche de l'opérateur qu'une instance d'un objet.
InformationsquelleAutor xbakesx
46

Vous avez juste besoin de filtrer les voitures qui ont une null nom:
```
requiredCars = cars.stream()
                   .filter(c -> c.getName() != null)
                   .filter(c -> c.getName().startsWith("M"));
```
- C'est une véritable honte que cette réponse n'est pas plus fortement voté comme il semble être la seule réponse qui répond vraiment à la question.
- À la question "Comment filtrer les valeurs null?" semble être répondu par xbakesx.
- En regardant les dates que vous corriger. Mon erreur.
- Performance sage est-il bon pour filtrer le flux de deux fois Ou de mieux utiliser le prédicat pour le filtrage? Je veux juste savoir.
InformationsquelleAutor Tunaki
37

Les réponses proposées sont grands. Juste aimerais suggérer une amélioration à gérer le cas de null liste à l'aide de Optional.ofNullable, nouvelle fonctionnalité de Java 8:
```
 List<String> carsFiltered = Optional.ofNullable(cars)
                .orElseGet(Collections::emptyList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
```
Donc, la réponse sera:
```
 List<String> carsFiltered = Optional.ofNullable(cars)
                .orElseGet(Collections::emptyList)
                .stream()
                .filter(Objects::nonNull) //filtering car object that are null
                .map(Car::getName) //now it's a stream of Strings
                .filter(Objects::nonNull) //filtering null in Strings
                .filter(name -> name.startsWith("M"))
                .collect(Collectors.toList()); //back to List of Strings
```
- Mauvaise utilisation de l'Option. nul ne devrait jamais être utilisé comme un synonyme pour un regroupement vide en premier lieu.
- Bien sûr, mais ce n'est pas ce qui se passe dans la pratique. Parfois (la plupart du temps) vous avez besoin de travailler avec le code que beaucoup de personnes ont travaillé sur. Parfois, vous recevez vos données à partir d'interfaces externes. Pour tous ces cas, Facultatif, est d'une grande utilité.
- notez que la valeur null voiture n'est pas la question. Dans ce cas, c'est le nom de la propriété à l'origine des problèmes. Donc Objects::nonNull ne résout pas le problème puisque les non-nulle de la voiture peut avoir nom==null
- Bien sûr @kiedysktos, mais ce n'est pas ce que je voulais montrer dans la réponse. Mais, je suis d'accepter ce que vous dites et la modification de la réponse 🙂
InformationsquelleAutor Stas

Vous pouvez le faire en une seul étape de filtre:

requiredCars = cars.stream().filter(c -> c.getName() != null && c.getName().startsWith("M"));

Si vous ne souhaitez pas appeler getName() plusieurs fois (par exemple, il est cher à l'appel), vous pouvez le faire:

requiredCars = cars.stream().filter(c -> {
    String name = c.getName();
    return name != null && name.startsWith("M");
});

Ou plus complexes:

requiredCars = cars.stream().filter(c -> 
    Optional.ofNullable(c.getName()).filter(name -> name.startsWith("M")).isPresent());

InformationsquelleAutor Tagir Valeev

Vous devez vous connecter pour publier un commentaire.