Múltiples cheques nulos en Java 8

java-8

Question

Tengo el siguiente código que es poco feo para múltiples cheques nulos.

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

Así que intenté usar Optional.ofNullable como abajo, pero aún es difícil de entender si alguien lee mi código. ¿Cuál es el mejor enfoque para hacer eso en Java 8?

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

En Java 9, podemos usar Optional.ofNullable con OR , pero en Java8, ¿hay algún otro enfoque?

Answer 1

¿Y el operador condicional ternario?

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

Answer 2

Las respuestas actuales son buenas, pero realmente deberías poner eso en un método de utilidad:

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

Ese método ha estado en mi clase de Util por años, hace que el código sea mucho más limpio:

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

Incluso puedes hacerlo genérico:

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

Answer 3

Método basado y simple.

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

Y utilízalo como:

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

Es simple de hacer con matrices y se ve bonita.

Answer 4

Puedes hacerlo así:

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

Answer 5

También puede agrupar todas las cadenas en una matriz de cadenas, luego hacer un ciclo for para verificar y romper el ciclo una vez que se haya asignado. Suponiendo que s1, s2, s3, s4 son todas las cadenas.

String[] arrayOfStrings = {s1, s2, s3};
s = s4;
for (String value : arrayOfStrings) {
if (value != null) {
s = value;
break;
}
}

Editado para lanzar en condición de predeterminado a s4 si no se asigna ninguno.

Answer 6

También puede utilizar un bucle:

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

Answer 7

Una solución que puede aplicarse a tantos elementos como desee puede ser:

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

Podría imaginar una solución como la que se muestra a continuación, pero la primera garantiza la non nullity de todos los elementos.

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

Answer 8

Yo uso una función de ayuda, algo así como

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

Entonces este tipo de código se puede escribir como

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