Filtre valores apenas se não for nulo usando lambda no Java8

Eu tenho uma lista de objetos dizem car. Eu quero filtrar esta lista com base em algum parâmetro usando Java 8. Mas se o parâmetro for null, ele lança NullPointerException. Como filtrar valores nulos?

O código atual é o seguinte

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

Isso joga NullPointerExceptionse getName()retorna null.

Neste exemplo em particular, acho que o @Tagir está 100% correto, coloque-o em um filtro e faça as duas verificações. Eu não usaria Optional.ofNullableo material opcional é realmente para os tipos de retorno não estarem fazendo lógica ... mas realmente nem aqui nem ali.

Queria ressaltar que java.util.Objectsexiste um método legal para isso em um caso amplo, para que você possa fazer isso:

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

O que limpará seus objetos nulos. Para quem não conhece, essa é a abreviação para o seguinte:

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

Para responder parcialmente à pergunta em questão e retornar a lista de nomes de carros que começa com "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());

Depois de se acostumar com as lambdas de taquigrafia, você também pode fazer isso:

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

Infelizmente, uma vez que .map(Car::getName)você retornará apenas a lista de nomes, não os carros. Tão menos bonita, mas responde totalmente à pergunta:

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

Você só precisa filtrar os carros que têm um nullnome:

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

As respostas propostas são ótimas. Gostaria apenas de sugerir uma melhoria para lidar com o caso da lista nula usando Optional.ofNullable, novo recurso no Java 8 :

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

Portanto, a resposta 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

Você pode fazer isso na etapa de filtro único:

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

Se você não quiser ligar getName()várias vezes (por exemplo, é uma ligação cara), faça o seguinte:

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

Ou de maneira mais sofisticada:

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

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

você pode usar isso

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