Cómo comprobar si una cadena tiene una longitud específica en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena (string) tiene una longitud específica en Java. Cubriremos los pasos fundamentales implicados, comenzando con el uso del método length() para obtener la longitud de la cadena. Luego, aprenderás cómo comparar esta longitud con un valor esperado y, lo que es importante, cómo manejar posibles cadenas nulas para evitar errores. Al final de este laboratorio, tendrás una comprensión sólida de cómo realizar verificaciones robustas de la longitud de cadenas en tus aplicaciones Java.

Utiliza length() para obtener la longitud de la cadena

En este paso, aprenderemos cómo encontrar la longitud de una cadena (string) en Java utilizando el método length(). El método length() es una función incorporada en Java que devuelve el número de caracteres en una cadena.

Primero, creemos un nuevo archivo Java llamado StringLength.java en tu directorio ~/project. Puedes hacer esto haciendo clic derecho en el Explorador de Archivos de la izquierda y seleccionando "Nuevo Archivo", luego escribiendo StringLength.java.
Abre el archivo StringLength.java en el editor y agrega el siguiente código:
```
public class StringLength {
    public static void main(String[] args) {
        String greeting = "Hello, LabEx!";
        int length = greeting.length();
        System.out.println("The length of the string is: " + length);
    }
}
```
Veamos las partes nuevas:
- String greeting = "Hello, LabEx!";: Esta línea declara una variable llamada greeting de tipo String y le asigna el valor "Hello, LabEx!".
- int length = greeting.length();: Aquí es donde usamos el método length(). Llamamos a length() en la cadena greeting, y devuelve el número de caracteres (incluyendo espacios y signos de puntuación). Este número se almacena luego en una variable entera llamada length.
- System.out.println("The length of the string is: " + length);: Esta línea imprime el texto "The length of the string is: " seguido del valor almacenado en la variable length.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, abre la Terminal en la parte inferior del WebIDE y asegúrate de que estás en el directorio ~/project. Puedes usar cd ~/project si es necesario.
Compila el programa Java utilizando el comando javac:
```
javac StringLength.java
```
Si no hay errores, no deberías ver salida alguna.
Ejecuta el programa Java compilado utilizando el comando java:
```
java StringLength
```
Deberías ver la siguiente salida:
```
The length of the string is: 13
```
Esta salida confirma que el método length() calculó correctamente el número de caracteres en la cadena "Hello, LabEx!", que es 13.

¡Has utilizado con éxito el método length() para encontrar la longitud de una cadena en Java!

Comparar la longitud con el valor esperado

En el paso anterior, aprendimos cómo obtener la longitud de una cadena (string). Ahora, usemos este conocimiento para comparar la longitud de una cadena con un valor esperado. Esta es una tarea común en la programación, por ejemplo, para verificar si una contraseña cumple con un requisito de longitud mínima.

Modificaremos el archivo StringLength.java que creamos en el paso anterior.

Abre el archivo StringLength.java en el editor del WebIDE.
Modifica el método main para incluir una comparación. Reemplaza el método main existente con el siguiente código:
```
public class StringLength {
    public static void main(String[] args) {
        String password = "mysecretpassword";
        int minLength = 8; // Longitud mínima requerida

        int passwordLength = password.length();

        System.out.println("Password: " + password);
        System.out.println("Password length: " + passwordLength);
        System.out.println("Minimum required length: " + minLength);

        if (passwordLength >= minLength) {
            System.out.println("Password meets the minimum length requirement.");
        } else {
            System.out.println("Password does NOT meet the minimum length requirement.");
        }
    }
}
```
Veamos los cambios:
- Hemos cambiado el nombre de la variable de cadena a password y le hemos asignado un valor diferente.
- Hemos introducido una nueva variable entera minLength para almacenar la longitud mínima requerida.
- Calculamos la passwordLength utilizando el método length() como antes.
- Hemos agregado una declaración if. La declaración if verifica si la passwordLength es mayor o igual a minLength.
- Si la condición (passwordLength >= minLength) es verdadera, se ejecuta el código dentro del bloque if, imprimiendo un mensaje de éxito.
- Si la condición es falsa, se ejecuta el código dentro del bloque else, imprimiendo un mensaje de fracaso.
Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal y asegúrate de que estás en el directorio ~/project.
Compila el programa Java modificado:
```
javac StringLength.java
```
Nuevamente, la ausencia de salida significa que la compilación fue exitosa.
Ejecuta el programa:
```
java StringLength
```
Basado en la password y la minLength actuales, deberías ver una salida similar a esta:
```
Password: mysecretpassword
Password length: 16
Minimum required length: 8
Password meets the minimum length requirement.
```
Intenta cambiar la cadena password en el código a algo más corto que 8 caracteres (por ejemplo, "short"), guarda el archivo, recompila y ejecútalo de nuevo para ver cómo se ejecuta el bloque else.

¡Ahora has aprendido cómo comparar la longitud de una cadena con un valor específico utilizando una declaración if!

Manejar cadenas nulas en la comprobación de longitud

En los pasos anteriores, trabajamos con cadenas (strings) que tenían valores de caracteres reales. Sin embargo, en la programación, una variable de cadena a veces puede tener un valor especial llamado null. Un valor null significa que la variable no se refiere a ningún objeto. Si intentas llamar a un método como length() en una cadena null, tu programa se bloqueará con una NullPointerException.

En este paso, aprenderemos cómo manejar de forma segura las cadenas null antes de intentar obtener su longitud.

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

Modifica el método main para incluir una comprobación de null. Reemplaza el método main existente con el siguiente código:

public class StringLength {
    public static void main(String[] args) {
        String potentialString = null; // Esta cadena es null
        int minLength = 5; // Longitud mínima requerida

        System.out.println("String to check: " + potentialString);
        System.out.println("Minimum required length: " + minLength);

        if (potentialString != null) {
            int stringLength = potentialString.length();
            System.out.println("String length: " + stringLength);

            if (stringLength >= minLength) {
                System.out.println("String meets the minimum length requirement.");
            } else {
                System.out.println("String does NOT meet the minimum length requirement.");
            }
        } else {
            System.out.println("Cannot check length: The string is null.");
        }
    }
}

Veamos los cambios:

Hemos cambiado el nombre de la variable a potentialString y, inicialmente, le hemos dado el valor null.
Hemos agregado una declaración if externa: if (potentialString != null). Esto comprueba si la variable potentialString NO es null.
El código para obtener la longitud (potentialString.length()) y la posterior comparación de longitud ahora están dentro de este bloque if. Esto asegura que length() solo se llame si la cadena no es null.
El bloque else de la declaración if externa maneja el caso en el que la cadena SÍ es null, imprimiendo un mensaje que indica que no se puede comprobar la longitud.

Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal y asegúrate de que estás en el directorio ~/project.
Compila el programa Java modificado:
```
javac StringLength.java
```
La ausencia de salida significa que la compilación fue exitosa.
Ejecuta el programa:
```
java StringLength
```
Dado que potentialString es null, deberías ver la siguiente salida:
```
String to check: null
Minimum required length: 5
Cannot check length: The string is null.
```
Ahora, intenta cambiar el valor de potentialString a una cadena no nula, como "Java", guarda, recompila y ejecuta de nuevo. Deberías ver que se realiza la comprobación de longitud.
```
String potentialString = "Java"; // Esta cadena no es null
```
Después de recompilar y ejecutar:
```
String to check: Java
Minimum required length: 5
String length: 4
String does NOT meet the minimum length requirement.
```
Esto demuestra cómo manejar de forma segura las cadenas null antes de intentar llamar a métodos en ellas, evitando que tu programa se bloquee.

Resumen

En este laboratorio (lab), aprendimos cómo determinar la longitud de una cadena (string) en Java utilizando el método incorporado length(). Practicamos la creación de un programa Java, el uso del método length() para obtener la cantidad de caracteres de una cadena y, luego, la compilación y ejecución del programa para ver la salida. Esta habilidad fundamental es esencial para diversas manipulaciones y validaciones de cadenas en la programación Java.