Cómo comprobar si una cadena es nula en Java

Introducción

En este laboratorio, aprenderás técnicas esenciales para manejar cadenas nulas en Java. Comenzaremos explorando el método fundamental de comprobar si una cadena es nula utilizando el operador de igualdad (==), y entenderemos por qué es crucial hacer esto para prevenir la excepción NullPointerException.

A partir de esto, aprenderás cómo combinar las comprobaciones de nulidad con las comprobaciones de cadenas vacías para manejar eficazmente varios estados de cadena. Finalmente, introduciremos la clase Optional como un enfoque moderno y más seguro para manejar valores potencialmente nulos, demostrando cómo puede mejorar la legibilidad del código y prevenir errores comunes.

Skills Graph

Prueba de nulidad utilizando el operador de igualdad

En este paso, aprenderemos cómo comprobar si una variable de tipo cadena en Java es null utilizando el operador de igualdad (==). Entender cómo manejar null es crucial en la programación Java para prevenir errores.

En Java, una variable de tipo referencia (como String) puede contener un valor especial llamado null. Esto significa que la variable no se refiere a ningún objeto en memoria. Intentar usar una variable null como si fuera un objeto válido resultará en una NullPointerException, que es un error común y frustrante para los principiantes.

La forma más sencilla de comprobar si una cadena es null es utilizando el operador de igualdad (==).

Vamos a crear un simple programa Java para demostrar esto.

1. Abre el WebIDE y asegúrate de estar en el directorio ~/project. Puedes confirmar esto mirando el indicador del terminal o escribiendo pwd y presionando Enter.

2. Crea un nuevo archivo Java llamado NullCheck.java en el directorio ~/project. Puedes hacer esto haciendo clic derecho en el Explorador de archivos de la izquierda, seleccionando "Nuevo archivo" y escribiendo NullCheck.java.

3. Abre el archivo NullCheck.java en el editor y pega el siguiente código:

   public class NullCheck {
   
       public static void main(String[] args) {
   
           String myString1 = "Hello";
           String myString2 = null;
           String myString3 = ""; // Esta es una cadena vacía, no null
   
           System.out.println("Checking myString1:");
           if (myString1 == null) {
               System.out.println("myString1 is null");
           } else {
               System.out.println("myString1 is not null");
           }
   
           System.out.println("\nChecking myString2:");
           if (myString2 == null) {
               System.out.println("myString2 is null");
           } else {
               System.out.println("myString2 is not null");
           }
   
           System.out.println("\nChecking myString3:");
           if (myString3 == null) {
               System.out.println("myString3 is null");
           } else {
               System.out.println("myString3 is not null");
           }
       }
   }

   En este código:

   • Declaramos tres variables de tipo String: myString1 se le asigna una cadena normal, myString2 se le asigna explícitamente null, y myString3 se le asigna una cadena vacía ("").
   • Usamos una instrucción if con el operador de igualdad (==) para comprobar si cada cadena es null.
   • Imprimimos un mensaje que indica si la cadena es null o no.

4. Guarda el archivo NullCheck.java (Ctrl+S o Cmd+S).

5. Abre el Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project.

6. Compila el programa Java utilizando el comando javac:

   javac NullCheck.java

   Si no hay errores, este comando creará un archivo NullCheck.class en el mismo directorio.

7. Ejecuta el programa Java compilado utilizando el comando java:

   java NullCheck

   Deberías ver una salida similar a esta:

   Checking myString1:
   myString1 is not null
   
   Checking myString2:
   myString2 is null
   
   Checking myString3:
   myString3 is not null

Esta salida confirma que myString1 y myString3 no son null, mientras que myString2 sí lo es. Es importante tener en cuenta la diferencia entre una cadena null y una cadena vacía (""). Una cadena vacía es un objeto String válido con cero caracteres, mientras que una variable de cadena null no apunta a ningún objeto.

Usar == null es la forma estándar y correcta de comprobar si una variable de referencia es null en Java.

Combinar comprobaciones de nulidad y cadenas vacías

En el paso anterior, aprendimos cómo comprobar si una cadena es null. Sin embargo, en muchos escenarios del mundo real, es posible que también necesites comprobar si una cadena está vacía (tiene cero caracteres) o contiene solo espacios en blanco. Una cadena que es null, está vacía o contiene solo espacios en blanco a menudo se considera "en blanco" o "efectivamente vacía".

Comprobar tanto si una cadena es null como si está vacía es un requisito común. Puedes combinar estas comprobaciones utilizando el operador lógico OR (||).

Vamos a modificar nuestro programa anterior para incluir comprobaciones tanto de null como de cadenas vacías.

1. Abre el archivo NullCheck.java en el editor del WebIDE.

2. Modifica el método main para incluir una cadena vacía y combinar las comprobaciones. Reemplaza el método main existente con el siguiente código:

   public class NullCheck {
   
       public static void main(String[] args) {
   
           String myString1 = "Hello";
           String myString2 = null;
           String myString3 = ""; // Esta es una cadena vacía
           String myString4 = "   "; // Esta cadena contiene solo espacios en blanco
   
           System.out.println("Checking myString1:");
           if (myString1 == null || myString1.isEmpty()) {
               System.out.println("myString1 is null or empty");
           } else {
               System.out.println("myString1 is not null and not empty");
           }
   
           System.out.println("\nChecking myString2:");
           if (myString2 == null || myString2.isEmpty()) {
               System.out.println("myString2 is null or empty");
           } else {
               System.out.println("myString2 is not null and not empty");
           }
   
           System.out.println("\nChecking myString3:");
           if (myString3 == null || myString3.isEmpty()) {
               System.out.println("myString3 is null or empty");
           } else {
               System.out.println("myString3 is not null and not empty");
           }
   
           System.out.println("\nChecking myString4:");
           // Nota: isEmpty() no comprueba espacios en blanco
           if (myString4 == null || myString4.isEmpty()) {
               System.out.println("myString4 is null or empty");
           } else {
               System.out.println("myString4 is not null and not empty");
           }
       }
   }

   En este código actualizado:

   • Agregamos myString4 que contiene solo espacios en blanco.
   • Usamos la condición myString == null || myString.isEmpty() para comprobar si una cadena es null o está vacía. El método isEmpty() es un método incorporado de la clase String que devuelve true si la cadena tiene una longitud de 0.
   • Importante: El método isEmpty() solo se puede llamar en una cadena no nula. Si intentas llamar a isEmpty() en una cadena null, obtendrás una NullPointerException. Por lo tanto, es crucial comprobar si la cadena es null primero utilizando myString == null antes de llamar a myString.isEmpty(). El operador lógico OR (||) es "de cortocircuito", lo que significa que si la primera condición (myString == null) es verdadera, la segunda condición (myString.isEmpty()) no se evalúa, evitando la NullPointerException.

3. Guarda el archivo NullCheck.java.

4. Compila el programa modificado en el Terminal:

   javac NullCheck.java

5. Ejecuta el programa compilado:

   java NullCheck

   Deberías ver una salida similar a esta:

   Checking myString1:
   myString1 is not null and not empty
   
   Checking myString2:
   myString2 is null or empty
   
   Checking myString3:
   myString3 is null or empty
   
   Checking myString4:
   myString4 is not null and not empty

Observa que myString4 (que contiene solo espacios en blanco) se considera "no nula y no vacía" por esta comprobación. Si también necesitas considerar cadenas con solo espacios en blanco como "en blanco", puedes usar el método isBlank() (disponible desde Java 11).

Vamos a actualizar rápidamente el código para usar isBlank() para myString4:

1. Modifica la comprobación para myString4 en NullCheck.java:

   // ... (código anterior) ...
   
           System.out.println("\nChecking myString4 with isBlank():");
           if (myString4 == null || myString4.isBlank()) {
               System.out.println("myString4 is null or blank");
           } else {
               System.out.println("myString4 is not null and not blank");
           }
       }
   }

2. Guarda el archivo, compila y ejecuta de nuevo:

   javac NullCheck.java
   java NullCheck

   La salida para myString4 ahora debería ser:

   Checking myString4 with isBlank():
   myString4 is null or blank

Esto demuestra cómo combinar comprobaciones de null y cadenas vacías/en blanco, que es un patrón muy común en la programación Java.

Utilizar Optional para manejar cadenas nulas de forma segura

En los pasos anteriores, utilizamos el operador de igualdad (==) y los métodos isEmpty() o isBlank() para comprobar si una cadena era null o estaba vacía/en blanco. Si bien estos métodos son efectivos, Java 8 introdujo la clase Optional como una forma de manejar valores potencialmente null de manera más explícita y funcional. Utilizar Optional puede ayudar a hacer tu código más legible y menos propenso a NullPointerException.

Optional es un objeto contenedor que puede o no contener un valor no nulo. Si un valor está presente, isPresent() devolverá true y get() devolverá el valor. Si no hay ningún valor presente, el objeto se considera vacío y isPresent() devolverá false. Llamar a get() en un Optional vacío lanzará una NoSuchElementException.

Exploremos cómo utilizar Optional con cadenas.

1. Abre el archivo NullCheck.java en el editor del WebIDE.

2. Reemplaza todo el contenido del archivo con el siguiente código que utiliza Optional:

   import java.util.Optional;
   
   public class NullCheck {
   
       public static void main(String[] args) {
   
           String myString1 = "Hello";
           String myString2 = null;
           String myString3 = "";
           String myString4 = "   ";
   
           // Creando objetos Optional a partir de cadenas
           Optional<String> optionalString1 = Optional.ofNullable(myString1);
           Optional<String> optionalString2 = Optional.ofNullable(myString2);
           Optional<String> optionalString3 = Optional.ofNullable(myString3);
           Optional<String> optionalString4 = Optional.ofNullable(myString4);
   
           System.out.println("Checking optionalString1:");
           if (optionalString1.isPresent()) {
               System.out.println("optionalString1 has a value: " + optionalString1.get());
           } else {
               System.out.println("optionalString1 is empty (contains null)");
           }
   
           System.out.println("\nChecking optionalString2:");
           if (optionalString2.isPresent()) {
               System.out.println("optionalString2 has a value: " + optionalString2.get());
           } else {
               System.out.println("optionalString2 is empty (contains null)");
           }
   
           System.out.println("\nChecking optionalString3:");
           // Optional.ofNullable("") crea un Optional que contiene una cadena vacía
           if (optionalString3.isPresent()) {
               System.out.println("optionalString3 has a value: " + optionalString3.get());
           } else {
               System.out.println("optionalString3 is empty (contains null)");
           }
   
           System.out.println("\nChecking optionalString4:");
            if (optionalString4.isPresent()) {
               System.out.println("optionalString4 has a value: " + optionalString4.get());
           } else {
               System.out.println("optionalString4 is empty (contains null)");
           }
   
           // Utilizando métodos de Optional para un manejo más seguro
           System.out.println("\nUsing Optional methods:");
   
           // orElse: proporciona un valor predeterminado si el Optional está vacío
           String value1 = optionalString1.orElse("Default Value");
           String value2 = optionalString2.orElse("Default Value");
           System.out.println("Value from optionalString1 (orElse): " + value1);
           System.out.println("Value from optionalString2 (orElse): " + value2);
   
           // ifPresent: realiza una acción si un valor está presente
           System.out.print("If optionalString1 is present: ");
           optionalString1.ifPresent(s -> System.out.println("Value is " + s));
   
           System.out.print("If optionalString2 is present: ");
           optionalString2.ifPresent(s -> System.out.println("Value is " + s));
   
           // filter: filtra el valor si está presente
           System.out.print("Filtered optionalString1 (length > 3): ");
           optionalString1.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));
   
           System.out.print("Filtered optionalString3 (length > 3): ");
           optionalString3.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));
       }
   }

   En este código:

   • Importamos la clase Optional.
   • Utilizamos Optional.ofNullable(string) para crear un Optional<String> a partir de una String normal. Este método es seguro de usar incluso si la cadena de entrada es null. Si la entrada es null, devuelve un Optional vacío; de lo contrario, devuelve un Optional que contiene la cadena.
   • Utilizamos optionalString.isPresent() para comprobar si el Optional contiene un valor.
   • Utilizamos optionalString.get() para recuperar el valor si está presente. Ten cuidado: llamar a get() en un Optional vacío lanzará una excepción, así que siempre comprueba isPresent() primero o utiliza otros métodos más seguros.
   • Demostramos orElse(defaultValue) que devuelve el valor contenido si está presente, de lo contrario devuelve el valor predeterminado especificado.
   • Demostramos ifPresent(consumer) que ejecuta el consumidor dado (una función que toma un argumento y no devuelve ningún resultado) si un valor está presente.
   • Demostramos filter(predicate) que devuelve un Optional que contiene el valor si está presente y coincide con el predicado dado (una función que devuelve un booleano), de lo contrario devuelve un Optional vacío.

3. Guarda el archivo NullCheck.java.

4. Compila el programa en el Terminal:

   javac NullCheck.java

5. Ejecuta el programa:

   java NullCheck

   Deberías ver una salida similar a esta:

   Checking optionalString1:
   optionalString1 has a value: Hello
   
   Checking optionalString2:
   optionalString2 is empty (contains null)
   
   Checking optionalString3:
   optionalString3 has a value:
   
   Checking optionalString4:
   optionalString4 has a value:
   
   Using Optional methods:
   Value from optionalString1 (orElse): Hello
   Value from optionalString2 (orElse): Default Value
   If optionalString1 is present: Value is Hello
   If optionalString2 is present:
   Filtered optionalString1 (length > 3): Value is Hello
   Filtered optionalString3 (length > 3):

Utilizar Optional puede hacer que tu código sea más expresivo sobre si un valor puede estar ausente y proporciona métodos útiles para manejar la presencia o ausencia de un valor sin comprobaciones explícitas de null en todos lados. Si bien Optional es una herramienta poderosa, no es un reemplazo para todas las comprobaciones de null, pero es especialmente útil cuando se trata de valores de retorno que pueden ser null.

Resumen

En este laboratorio, aprendimos cómo comprobar si una cadena en Java es null. Comenzamos utilizando el operador de igualdad (==) para comparar directamente una variable de cadena con null, entendiendo que null significa la ausencia de una referencia a un objeto y que no comprobar null puede provocar una NullPointerException.

Luego exploramos cómo combinar la comprobación de nulidad con una comprobación de cadena vacía, reconociendo que una cadena vacía ("") es un objeto válido, a diferencia de null. Finalmente, aprendimos cómo utilizar la clase Optional, introducida en Java 8, como una forma más moderna y segura de manejar valores potencialmente nulos, promoviendo un código más robusto y legible al indicar explícitamente la posibilidad de un valor ausente.