Filtern Sie Werte nur, wenn nicht null, mit Lambda in Java8

Ich habe eine Liste von Objekten sagen car. Ich möchte diese Liste basierend auf einigen Parametern mit Java 8 filtern. Wenn der Parameter jedoch lautet null, wird er ausgelöst NullPointerException. Wie filtere ich Nullwerte heraus?

Der aktuelle Code lautet wie folgt

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

Dies wirft, NullPointerExceptionwenn getName()zurückgegeben wird null.

In diesem speziellen Beispiel denke ich, dass @Tagir 100% korrekt ist. Holen Sie es in einen Filter und führen Sie die beiden Überprüfungen durch. Ich würde Optional.ofNullabledas optionale Zeug nicht verwenden, damit Rückgabetypen keine Logik ausführen ... aber wirklich weder hier noch dort.

Ich wollte darauf hinweisen, dass java.util.Objectsdies in einem breiten Fall eine gute Methode dafür ist, also können Sie dies tun:

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

Dadurch werden Ihre Nullobjekte gelöscht. Für alle, die nicht vertraut sind, ist dies die Abkürzung für Folgendes:

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

Um die vorliegende Frage teilweise zu beantworten und die Liste der Fahrzeugnamen zurückzugeben, die mit "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());

Sobald Sie sich an die Kurzschrift Lambdas gewöhnt haben, können Sie auch Folgendes tun:

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

Sobald Sie dies tun, werden Sie leider .map(Car::getName)nur die Liste der Namen zurückgeben, nicht die Autos. Also weniger schön, aber vollständig beantwortet die Frage:

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

Sie müssen nur die Autos filtern, die einen nullNamen haben:

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

Die vorgeschlagenen Antworten sind großartig. Möchten einfach mal für eine Verbesserung vorzuschlagen , den Fall von null Liste mit zu handhaben Optional.ofNullable, neue Funktion in Java 8 :

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

Die vollständige Antwort lautet also:

 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

Sie können dies in einem einzelnen Filterschritt tun:

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

Wenn Sie nicht getName()mehrmals anrufen möchten (z. B. ein teurer Anruf), können Sie Folgendes tun:

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

Oder auf raffiniertere Weise:

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

Nutzen Sie die Kraft von 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())
;

Sie können dies verwenden

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