Cómo verificar si una cadena está en blanco en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena (string) está en blanco en Java. Explorarás el método isBlank(), introducido en Java 11, que determina de manera eficiente si una cadena está vacía o contiene solo caracteres de espacio en blanco.

A través de ejemplos prácticos, primero utilizarás isBlank() para verificar varios tipos de cadenas. Luego, aprenderás cómo combinar isBlank() con una comprobación de nulidad para una validación de cadenas sólida. Finalmente, compararás el comportamiento de isBlank() y isEmpty() para entender sus diferencias clave.

Usar isBlank() para verificar cadenas en blanco

En este paso, aprenderás cómo usar el método isBlank() en Java para verificar si una cadena (string) está en blanco. Una cadena en blanco es una cadena que contiene solo caracteres de espacio en blanco (espacios, tabulaciones, saltos de línea) o está vacía.

El método isBlank() se introdujo en Java 11 y es una forma conveniente de verificar cadenas en blanco. Devuelve true si la cadena está vacía o contiene solo espacios en blanco, y false en caso contrario.

Vamos a crear un simple programa en Java para demostrar el método isBlank().

Abre el archivo HelloJava.java en el editor del WebIDE si no está abierto.

Reemplaza todo el contenido del archivo con el siguiente código:

public class HelloJava {
    public static void main(String[] args) {
        String str1 = ""; // Cadena vacía
        String str2 = "   "; // Cadena con solo espacios
        String str3 = "Hello"; // Cadena no en blanco
        String str4 = " Hello "; // Cadena con espacios al inicio y al final

        System.out.println("¿Está str1 en blanco? " + str1.isBlank());
        System.out.println("¿Está str2 en blanco? " + str2.isBlank());
        System.out.println("¿Está str3 en blanco? " + str3.isBlank());
        System.out.println("¿Está str4 en blanco? " + str4.isBlank());
    }
}

En este código:

Declaramos cuatro cadenas diferentes: una cadena vacía, una cadena con solo espacios, una cadena no en blanco y una cadena con espacios al inicio y al final.
Usamos str.isBlank() para verificar si cada cadena está en blanco y mostramos el resultado.

Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, vamos a compilar el programa. Abre la Terminal en la parte inferior del WebIDE y asegúrate de estar en el directorio ~/project. Si no lo estás, usa el comando cd ~/project. Luego, compila el código usando el comando javac:
```
javac HelloJava.java
```
Si no hay errores, se creará un archivo HelloJava.class en el directorio ~/project.
Finalmente, ejecuta el programa compilado usando el comando java:
```
java HelloJava
```
Deberías ver la siguiente salida:
```
¿Está str1 en blanco? true
¿Está str2 en blanco? true
¿Está str3 en blanco? false
¿Está str4 en blanco? false
```
Como puedes ver, isBlank() identifica correctamente la cadena vacía (str1) y la cadena con solo espacios (str2) como cadenas en blanco, mientras que str3 y str4 se consideran no en blanco porque contienen caracteres que no son espacios en blanco.

Combinar isBlank() con una comprobación de nulidad

En el paso anterior, aprendiste cómo usar isBlank() para verificar cadenas (strings) vacías o que solo contengan espacios en blanco. Sin embargo, isBlank() lanzará una NullPointerException si la variable de cadena es null. En aplicaciones del mundo real, es común encontrar cadenas null, por lo que es importante manejarlas adecuadamente.

Para verificar de manera segura si una cadena es null o está en blanco, debes combinar una comprobación de nulidad con el método isBlank(). La forma más común de hacer esto es utilizando una declaración if:

if (str == null || str.isBlank()) {
    // La cadena es null o está en blanco
} else {
    // La cadena no es null y no está en blanco
}

Vamos a modificar nuestro programa para incluir una cadena null y demostrar cómo manejarla.

Abre el archivo HelloJava.java en el editor del WebIDE.

Reemplaza el código actual con el siguiente:

public class HelloJava {
    public static void main(String[] args) {
        String str1 = ""; // Cadena vacía
        String str2 = "   "; // Cadena con solo espacios
        String str3 = "Hello"; // Cadena no en blanco
        String str4 = null; // Cadena null

        System.out.println("¿Es str1 null o está en blanco? " + (str1 == null || str1.isBlank()));
        System.out.println("¿Es str2 null o está en blanco? " + (str2 == null || str2.isBlank()));
        System.out.println("¿Es str3 null o está en blanco? " + (str3 == null || str3.isBlank()));
        System.out.println("¿Es str4 null o está en blanco? " + (str4 == null || str4.isBlank()));
    }
}

En este código actualizado:

Agregamos una variable de cadena null llamada str4.
Usamos la condición str == null || str.isBlank() para verificar si cada cadena es null o está en blanco. El operador || significa "o". Si la primera parte (str == null) es verdadera, la segunda parte (str.isBlank()) ni siquiera se verifica, lo que evita la NullPointerException.

Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado en la Terminal:
```
javac HelloJava.java
```
Ejecuta el programa compilado:
```
java HelloJava
```
Deberías ver la siguiente salida:
```
¿Es str1 null o está en blanco? true
¿Es str2 null o está en blanco? true
¿Es str3 null o está en blanco? false
¿Es str4 null o está en blanco? true
```
Esta salida muestra que nuestra comprobación combinada identifica correctamente la cadena vacía, la cadena con espacios y la cadena null como "null o en blanco", mientras que la cadena no en blanco se identifica correctamente como "no null y no en blanco".

Combinar la comprobación de nulidad con isBlank() es una forma sólida de manejar varios estados de cadena en tus programas Java.

Comparar isBlank() e isEmpty()

En los pasos anteriores, has utilizado isBlank() para verificar cadenas (strings) que estén vacías o que solo contengan espacios en blanco. También es posible que hayas oído hablar del método isEmpty() en Java. En este paso, compararemos isBlank() e isEmpty() para entender la diferencia entre ellos.

El método isEmpty() ha estado disponible en Java desde la versión 1.0. Devuelve true solo si la cadena tiene una longitud de 0 (es decir, es una cadena vacía ""). Devuelve false para cualquier otra cadena, incluyendo las que contengan solo espacios en blanco.

Vamos a modificar nuestro programa por última vez para usar tanto isBlank() como isEmpty() y ver cómo se comportan con diferentes tipos de cadenas.

Abre el archivo HelloJava.java en el editor del WebIDE.

Reemplaza el código actual con el siguiente:

public class HelloJava {
    public static void main(String[] args) {
        String str1 = ""; // Cadena vacía
        String str2 = "   "; // Cadena con solo espacios
        String str3 = "Hello"; // Cadena no en blanco
        String str4 = null; // Cadena null

        System.out.println("--- Usando isBlank() ---");
        System.out.println("¿Está str1 en blanco? " + (str1 == null || str1.isBlank()));
        System.out.println("¿Está str2 en blanco? " + (str2 == null || str2.isBlank()));
        System.out.println("¿Está str3 en blanco? " + (str3 == null || str3.isBlank()));
        // Nota: Todavía necesitamos la comprobación de nulidad antes de llamar a isBlank()
        System.out.println("¿Está str4 en blanco? " + (str4 == null || str4.isBlank()));

        System.out.println("\n--- Usando isEmpty() ---");
        // Nota: También necesitamos una comprobación de nulidad antes de llamar a isEmpty()
        System.out.println("¿Está str1 vacía? " + (str1 == null || str1.isEmpty()));
        System.out.println("¿Está str2 vacía? " + (str2 == null || str2.isEmpty()));
        System.out.println("¿Está str3 vacía? " + (str3 == null || str3.isEmpty()));
        System.out.println("¿Está str4 vacía? " + (str4 == null || str4.isEmpty()));
    }
}

En este código:

Agregamos secciones para demostrar tanto isBlank() como isEmpty().
Usamos la comprobación de nulidad combinada (str == null || ...) antes de llamar tanto a isBlank() como a isEmpty() para evitar la NullPointerException.

Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa en la Terminal:
```
javac HelloJava.java
```
Ejecuta el programa compilado:
```
java HelloJava
```
Deberías ver la siguiente salida:
```
--- Usando isBlank() ---
¿Está str1 en blanco? true
¿Está str2 en blanco? true
¿Está str3 en blanco? false
¿Está str4 en blanco? true

--- Usando isEmpty() ---
¿Está str1 vacía? true
¿Está str2 vacía? false
¿Está str3 vacía? false
¿Está str4 vacía? true
```
A partir de la salida, puedes observar la diferencia clave:
- isBlank() devuelve true tanto para cadenas vacías ("") como para cadenas con solo espacios en blanco (" ").
- isEmpty() devuelve true solo para cadenas vacías (""). Devuelve false para cadenas con solo espacios en blanco (" ").
Ambos métodos requieren una comprobación de nulidad antes de ser llamados en una cadena potencialmente null.

En resumen:

Utiliza isEmpty() cuando solo quieras verificar si una cadena tiene longitud cero.
Utiliza isBlank() cuando quieras verificar si una cadena está vacía o contiene solo caracteres de espacio en blanco.

Comprender la diferencia entre estos dos métodos es crucial para escribir código de manejo de cadenas correcto y robusto en Java.

Resumen

En este laboratorio (lab), aprendiste cómo verificar si una cadena (string) está en blanco en Java utilizando el método isBlank(), que se introdujo en Java 11. Practicaste el uso de isBlank() en diferentes tipos de cadenas, incluyendo cadenas vacías, cadenas con solo espacios en blanco y cadenas con contenido. También compilaste y ejecutaste un programa simple de Java para demostrar la funcionalidad de isBlank().