Cómo comprobar si una cadena comienza con un prefijo específico en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena comienza con un prefijo específico en Java utilizando el método startsWith(). Este ejercicio práctico te guiará a través de la aplicación del método startsWith(), probar su comportamiento en diferentes casos y comprender cómo maneja prefijos nulos y vacíos. Al final de este laboratorio, serás proficiente en el uso de esta técnica fundamental de manipulación de cadenas.

Aplicar startsWith() para comprobar el prefijo

En este paso, aprenderás cómo usar el método startsWith() en Java para verificar si una cadena comienza con un prefijo específico. Esta es una operación común cuando necesitas procesar texto basado en cómo comienza.

El método startsWith() es parte de la clase String en Java. Toma un argumento de tipo String, que es el prefijo que deseas verificar. Devuelve true si la cadena comienza con el prefijo especificado y false en caso contrario.

Vamos a crear un nuevo archivo Java para practicar el uso de startsWith().

Abre el Explorador de archivos en el lado izquierdo del WebIDE.
Haz clic derecho en el directorio ~/project y selecciona "Nuevo archivo".
Nombra el nuevo archivo PrefixChecker.java.
Abre PrefixChecker.java en el editor y pega el siguiente código:
```
public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";
        String prefix = "Hello";

        boolean startsWithPrefix = text.startsWith(prefix);

        System.out.println("Does the text start with '" + prefix + "'? " + startsWithPrefix);
    }
}
```
En este código:
- Declaramos una variable String llamada text y la inicializamos con "Hello, Java!".
- Declaramos otra variable String llamada prefix y la inicializamos con "Hello".
- Llamamos al método startsWith() en la cadena text, pasando prefix como argumento. El resultado (true o false) se almacena en la variable boolean llamada startsWithPrefix.
- Finalmente, imprimimos el resultado en la consola.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, vamos a compilar y ejecutar este programa. Abre la Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project.
Compila el archivo Java utilizando el comando javac:
```
javac PrefixChecker.java
```
Si no hay errores, este comando creará un archivo PrefixChecker.class en el directorio ~/project.
Ejecuta el programa compilado utilizando el comando java:
```
java PrefixChecker
```
Deberías ver la siguiente salida:
```
Does the text start with 'Hello'? true
```

Esta salida confirma que la cadena "Hello, Java!" efectivamente comienza con el prefijo "Hello".

Probar prefijos en diferentes casos

En el paso anterior, utilizaste con éxito startsWith() para verificar un prefijo. Ahora, exploremos cómo startsWith() maneja diferentes casos (letras mayúsculas y minúsculas).

Por defecto, el método startsWith() distingue entre mayúsculas y minúsculas. Esto significa que "Hello" se considera diferente de "hello" o "HELLO". Vamos a modificar nuestro archivo PrefixChecker.java para ver esto en acción.

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

Modifica el método main para incluir comprobaciones con diferentes casos. Reemplaza el método main existente con el siguiente código:

public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";

        String prefix1 = "Hello";
        String prefix2 = "hello";
        String prefix3 = "HELLO";

        boolean startsWithPrefix1 = text.startsWith(prefix1);
        boolean startsWithPrefix2 = text.startsWith(prefix2);
        boolean startsWithPrefix3 = text.startsWith(prefix3);

        System.out.println("Does the text start with '" + prefix1 + "'? " + startsWithPrefix1);
        System.out.println("Does the text start with '" + prefix2 + "'? " + startsWithPrefix2);
        System.out.println("Does the text start with '" + prefix3 + "'? " + startsWithPrefix3);
    }
}

En este código actualizado, estamos comprobando si la cadena text comienza con "Hello", "hello" y "HELLO".

Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal y asegúrate de estar en el directorio ~/project.
Compila el archivo Java modificado:
```
javac PrefixChecker.java
```

Ejecuta el programa compilado:

java PrefixChecker

Deberías ver la siguiente salida:

Does the text start with 'Hello'? true
Does the text start with 'hello'? false
Does the text start with 'HELLO'? false

Esta salida muestra claramente que startsWith() devolvió true solo para el prefijo "Hello" (que coincide con el caso de la cadena original) y false para "hello" y "HELLO". Esto demuestra que startsWith() distingue entre mayúsculas y minúsculas.

Si necesitas realizar una comprobación de prefijo sin distinguir entre mayúsculas y minúsculas, normalmente convertirías tanto la cadena original como el prefijo al mismo caso (ya sea minúsculas o mayúsculas) antes de usar startsWith(). Por ejemplo, podrías usar text.toLowerCase().startsWith(prefix.toLowerCase()). No implementaremos eso aquí, pero es una técnica útil para tener en cuenta.

Comprobar prefijos nulos y vacíos

En este paso, investigaremos cómo se comporta el método startsWith() cuando el prefijo es null o una cadena vacía (""). Comprender estos casos extremos es importante para escribir código robusto.

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

Modifica el método main para probar con un prefijo null y un prefijo de cadena vacía. Reemplaza el método main existente con el siguiente código:

public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";

        String prefixNull = null;
        String prefixEmpty = "";

        // Check with a null prefix
        try {
            boolean startsWithPrefixNull = text.startsWith(prefixNull);
            System.out.println("Does the text start with null? " + startsWithPrefixNull);
        } catch (NullPointerException e) {
            System.out.println("Checking with null prefix resulted in: " + e);
        }

        // Check with an empty prefix
        boolean startsWithPrefixEmpty = text.startsWith(prefixEmpty);
        System.out.println("Does the text start with an empty string? " + startsWithPrefixEmpty);
    }
}

En este código actualizado:

Declaramos prefixNull y lo establecemos en null.
Declaramos prefixEmpty y lo establecemos en una cadena vacía "".
Usamos un bloque try-catch cuando verificamos con prefixNull. Esto se debe a que intentar llamar a un método en un objeto null en Java resulta en una NullPointerException. Capturamos esta excepción para ver qué sucede.
Verificamos con el prefijo de cadena vacía prefixEmpty.

Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal y asegúrate de estar en el directorio ~/project.
Compila el archivo Java modificado:
```
javac PrefixChecker.java
```

Ejecuta el programa compilado:

java PrefixChecker

Deberías ver la siguiente salida:

Checking with null prefix resulted in: java.lang.NullPointerException
Does the text start with an empty string? true

Esta salida demuestra dos puntos importantes:

Pasar null como prefijo a startsWith() resulta en una NullPointerException. Por eso es crucial manejar los posibles valores null antes de llamar a métodos en ellos.
Pasar una cadena vacía ("") como prefijo a startsWith() devuelve true. Esto se debe a que cualquier cadena se puede considerar que comienza con una cadena vacía.

Comprender cómo startsWith() maneja los valores null y las cadenas vacías es importante para prevenir errores y escribir una lógica correcta en tus programas Java.

Resumen

En este laboratorio (lab), aprendiste cómo usar el método startsWith() en Java para verificar si una cadena comienza con un prefijo específico. Practicaste aplicar este método creando un simple programa en Java, compilándolo y ejecutándolo para ver la salida. Esta habilidad fundamental es esencial para diversas tareas de manipulación de cadenas en la programación Java.