Mehrere Nullprüfungen in Java 8

Ich habe den folgenden Code, der für mehrere Nullprüfungen etwas hässlich ist.

String s = null;

if (str1 != null) {
    s = str1;
} else if (str2 != null) {
    s = str2;
} else if (str3 != null) {
    s = str3;
} else {
    s = str4;
}

Also habe ich versucht, Optional.ofNullablewie unten zu verwenden, aber es ist immer noch schwer zu verstehen, wenn jemand meinen Code liest. Was ist der beste Ansatz, um dies in Java 8 zu tun?

String s = Optional.ofNullable(str1)
                   .orElse(Optional.ofNullable(str2)
                                   .orElse(Optional.ofNullable(str3)
                                                   .orElse(str4)));

In Java 9 können wir Optional.ofNullablemit verwenden OR, aber in Java8 gibt es einen anderen Ansatz?

Sie können es so machen:

String s = Stream.of(str1, str2, str3)
    .filter(Objects::nonNull)
    .findFirst()
    .orElse(str4);

Wie wäre es mit einem ternären bedingten Operator?

String s = 
    str1 != null ? str1 : 
    str2 != null ? str2 : 
    str3 != null ? str3 : str4
;

Sie können auch eine Schleife verwenden:

String[] strings = {str1, str2, str3, str4};
for(String str : strings) {
    s = str;
    if(s != null) break;
}

Aktuelle Antworten sind nett, aber Sie sollten das wirklich in eine Utility-Methode einfügen:

public static Optional<String> firstNonNull(String... strings) {
    return Arrays.stream(strings)
            .filter(Objects::nonNull)
            .findFirst();
}

Diese Methode ist seit Jahren in meiner UtilKlasse und macht Code viel sauberer:

String s = firstNonNull(str1, str2, str3).orElse(str4);

Sie können es sogar generisch machen:

@SafeVarargs
public static <T> Optional<T> firstNonNull(T... objects) {
    return Arrays.stream(objects)
            .filter(Objects::nonNull)
            .findFirst();
}

// Use
Student student = firstNonNull(student1, student2, student3).orElseGet(Student::new);

Ich benutze eine Hilfsfunktion, so etwas wie

T firstNonNull<T>(T v0, T... vs) {
  if(v0 != null)
    return v0;
  for(T x : vs) {
    if (x != null) 
      return x;
  }
  return null;
}

Dann kann diese Art von Code geschrieben werden als

String s = firstNonNull(str1, str2, str3, str4);

Eine Lösung, die auf so viele Elemente angewendet werden kann, wie Sie möchten, kann sein:

Stream.of(str1, str2, str3, str4)
      .filter(Object::nonNull)
      .findFirst()
      .orElseThrow(IllegalArgumentException::new)

Sie können sich eine Lösung wie die folgende vorstellen, aber die erste sorgt non nullityfür alle Elemente

Stream.of(str1, str2, str3).....orElse(str4)

Sie können auch alle Strings in einem Array von Strings zusammenfassen und dann eine for-Schleife ausführen, um die Schleife zu überprüfen und zu verlassen, sobald sie zugewiesen ist. Angenommen, s1, s2, s3, s4 sind alle Strings.

String[] arrayOfStrings = {s1, s2, s3};


s = s4;

for (String value : arrayOfStrings) {
    if (value != null) { 
        s = value;
        break;
    }
}

Bearbeitet, um die Bedingung für die Standardeinstellung auf s4 zu setzen, wenn keine zugewiesen ist.

Methodenbasiert und einfach.

String getNonNull(String def, String ...strings) {
    for(int i=0; i<strings.length; i++)
        if(strings[i] != null)
             return s[i];
    return def;
}

Und benutze es als:

String s = getNonNull(str4, str1, str2, str3);

Es ist einfach mit Arrays zu tun und sieht hübsch aus.

Wenn Sie Apache Commons Lang 3 verwenden, kann es folgendermaßen geschrieben werden:

String s = ObjectUtils.firstNonNull(str1, str2, str3, str4);

Die Nutzung ObjectUtils.firstNonNull(T...)wurde aus dieser entnommen Antwort . In verwandten Fragen wurden auch verschiedene Ansätze vorgestellt .