Filtrer les valeurs uniquement si elles ne sont pas nulles à l'aide de lambda dans Java8

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

Le code actuel est le suivant

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

Cela jette NullPointerExceptionsi getName()revient null.

Dans cet exemple particulier, je pense que @Tagir est correct à 100%, mettez-le dans un filtre et effectuez les deux vérifications. Je n'utiliserais pas Optional.ofNullablele truc optionnel, c'est vraiment pour les types de retour de ne pas faire de logique ... mais vraiment ni ici ni là-bas.

Je voulais souligner qu'il java.util.Objectsexiste une méthode intéressante pour cela dans un cas large, vous pouvez donc le faire:

cars.stream()
    .filter(Objects::nonNull)

Ce qui effacera vos objets nuls. Pour ceux qui ne sont pas familiers, c'est le raccourci pour ce qui suit:

cars.stream()
    .filter(car -> Objects.nonNull(car))

Pour répondre partiellement à la question posée, renvoyez la liste des noms de voitures commençant par "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 êtes habitué aux lambdas abrégés, vous pouvez également 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)êtes, vous ne retournerez que 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());

Il vous suffit de filtrer les voitures qui ont un nullnom:

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

Les réponses proposées sont excellentes. Voudrais simplement suggérer une amélioration de traiter le cas de la liste null en utilisant Optional.ofNullable, nouvelle fonctionnalité en Java 8 :

 List<String> carsFiltered = Optional.ofNullable(cars)
                .orElseGet(Collections::emptyList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList());

Donc, la réponse complète 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

Vous pouvez le faire en une seule étape de filtrage:

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

Si vous ne souhaitez pas appeler getName()plusieurs fois (par exemple, c'est un appel coûteux), vous pouvez le faire:

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

Ou de manière plus sophistiquée:

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

Tirer parti de la puissance de java.util.Optional#map():

List<Car> requiredCars = cars.stream()
  .filter (car -> 
    Optional.ofNullable(car)
      .map(Car::getName)
      .map(name -> name.startsWith("M"))
      .orElse(false) // what to do if either car or getName() yields null? false will filter out the element
    )
  .collect(Collectors.toList())
;

vous pouvez utiliser ceci

List<Car> requiredCars = cars.stream()
    .filter (t->  t!= null && StringUtils.startsWith(t.getName(),"M"))
    .collect(Collectors.toList());