Combinar comprobaciones de nulidad y vacío
En el paso anterior, aprendimos cómo verificar si una variable es null utilizando el operador ==. Sin embargo, en Java, especialmente cuando se trabaja con objetos String, a menudo es necesario verificar no solo si una variable es null, sino también si está "vacía". Una cadena vacía es un objeto String que existe pero no contiene caracteres (por ejemplo, ""). Una cadena null, por otro lado, significa que la variable no se refiere a ningún objeto String en absoluto.
Intentar llamar a métodos como isEmpty() o length() en una cadena null resultará en una NullPointerException. Por lo tanto, cuando se desea tratar tanto las cadenas null como las vacías de manera similar (por ejemplo, considerarlas como "en blanco" o "faltantes"), se deben verificar ambas condiciones.
La forma más común de hacer esto es primero verificar si la cadena es null y luego, si no es null, verificar si está vacía utilizando el método isEmpty().
Modifiquemos nuestro programa HelloJava.java para demostrar cómo combinar estas comprobaciones.
-
Abra el archivo HelloJava.java en el editor WebIDE.
-
Reemplace el código actual con el siguiente:
public class HelloJava {
public static void main(String[] args) {
String text1 = null;
String text2 = ""; // Una cadena vacía
String text3 = "Hello"; // Una cadena no vacía
System.out.println("Checking text1 (null):");
if (text1 == null || text1.isEmpty()) {
System.out.println("text1 is null or empty.");
} else {
System.out.println("text1 is not null and not empty: " + text1);
}
System.out.println("\nChecking text2 (empty):");
// ¡Es crucial verificar la nulidad primero!
if (text2 == null || text2.isEmpty()) {
System.out.println("text2 is null or empty.");
} else {
System.out.println("text2 is not null and not empty: " + text2);
}
System.out.println("\nChecking text3 (not empty):");
if (text3 == null || text3.isEmpty()) {
System.out.println("text3 is null or empty.");
} else {
System.out.println("text3 is not null and not empty: " + text3);
}
}
}
En este código actualizado:
- Introducimos tres variables
String: text1 (null), text2 (vacía) y text3 (no vacía).
- Utilizamos el operador lógico OR (
||) para combinar la comprobación de null (text == null) y la comprobación de vacío (text.isEmpty()).
- La condición
text == null || text.isEmpty() será verdadera si text es null O si text no es null Y text.isEmpty() es verdadero.
- Importante: La comprobación de
null (text == null) debe ir primero en la condición ||. Si text es null, la primera parte de la condición || (text == null) es verdadera, y Java utiliza la "evaluación de cortocircuito" para omitir la segunda parte (text.isEmpty()), evitando así una NullPointerException. Si la comprobación isEmpty() fuera la primera y text fuera null, causaría un error.
-
Guarde el archivo (Ctrl+S o Cmd+S).
-
Compile el programa en la Terminal:
javac HelloJava.java
-
Ejecute el programa:
java HelloJava
Debería ver la siguiente salida:
Checking text1 (null):
text1 is null or empty.
Checking text2 (empty):
text2 is null or empty.
Checking text3 (not empty):
text3 is not null and not empty: Hello
Esta salida muestra que nuestra comprobación combinada identificó correctamente tanto la cadena null (text1) como la cadena vacía (text2) como "null o vacía", mientras que identificó correctamente la cadena no vacía (text3).
Esta comprobación combinada (string == null || string.isEmpty()) es un patrón muy común en Java cuando se necesita manejar tanto cadenas null como vacías. Muchas bibliotecas también proporcionan métodos de utilidad para esto, como StringUtils.isEmpty() o StringUtils.isBlank() (que también verifica espacios en blanco) en Apache Commons Lang, pero entender la comprobación combinada básica es fundamental.
