Filtre los valores solo si no son nulos usando lambda en Java8

Tengo una lista de objetos que decir car. Quiero filtrar esta lista basada en algún parámetro usando Java 8. Pero si el parámetro es null, arroja NullPointerException. ¿Cómo filtrar valores nulos?

El código actual es el siguiente

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

Esto arroja NullPointerExceptionsi getName()regresa null.

En este ejemplo en particular, creo que @Tagir es 100% correcto, mételo en un filtro y realiza las dos comprobaciones. No usariaOptional.ofNullable las cosas opcionales para que los tipos de retorno no estén haciendo lógica ... pero realmente ni aquí ni allá.

Quería señalar que java.util.Objectstiene un buen método para esto en un caso amplio, por lo que puede hacer esto:

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

Lo que limpiará tus objetos nulos. Para cualquiera que no esté familiarizado, esa es la abreviatura de lo siguiente:

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

Para responder parcialmente la pregunta en cuestión y devolver la lista de nombres de automóviles que comienza con "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());

Una vez que te acostumbres a las taquillas lambdas, también puedes hacer esto:

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

Desafortunadamente, una vez .map(Car::getName)que solo regreses la lista de nombres, no los autos. Por lo tanto, menos hermoso pero responde completamente la pregunta:

cars.stream()
    .filter(car -> Objects.nonNull(car))
    .filter(car -> Objects.nonNull(car.getName()))
    .filter(car -> car.getName().startsWith("M"))
    .collect(Collectors.toList());

Solo necesita filtrar los autos que tienen un nullnombre:

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

Las respuestas propuestas son geniales. Sólo quisiera sugerir una mejora para manejar el caso de la lista nula usando Optional.ofNullable, nueva característica en Java 8 :

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

Entonces, la respuesta completa será:

 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

Puede hacer esto en un solo paso de filtro:

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

Si no desea llamar getName()varias veces (por ejemplo, es una llamada costosa), puede hacer esto:

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

O de manera más sofisticada:

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

Aprovechando el poder 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())
;

puedes usar esto

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