Cómo comprobar si una cadena termina con un sufijo específico en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena termina con un sufijo específico en Java. Esta es una habilidad fundamental para tareas como validar tipos de archivos o analizar datos basados en su final. Explorarás el método endsWith(), entenderás su sensibilidad a mayúsculas y minúsculas y aprenderás cómo combinarlo con startsWith() para realizar comprobaciones más complejas. A través de ejemplos prácticos, adquirirás experiencia práctica en el uso de estas técnicas de manipulación de cadenas en tus programas Java.

Usar endsWith() para verificar el sufijo

En este paso, exploraremos cómo usar el método endsWith() en Java para comprobar si una cadena termina con un sufijo específico. Esta es una tarea común cuando necesitas validar extensiones de archivos, buscar patrones específicos o procesar datos basados en su final.

El método endsWith() es parte de la clase String en Java. Toma un solo argumento, que es el sufijo que deseas comprobar, y devuelve un valor booleano: true si la cadena termina con el sufijo especificado y false en caso contrario.

Vamos a crear un simple programa Java para demostrar cómo funciona endsWith().

Abre el archivo HelloJava.java en el editor del WebIDE. Si no lo tienes abierto, puedes encontrarlo en el Explorador de archivos a la izquierda, dentro de la carpeta project.

Reemplaza el código existente en HelloJava.java con lo siguiente:

public class HelloJava {
    public static void main(String[] args) {
        String fileName = "document.txt";
        boolean endsWithTxt = fileName.endsWith(".txt");

        System.out.println("Does '" + fileName + "' end with '.txt'? " + endsWithTxt);

        String imageUrl = "photo.jpg";
        boolean endsWithJpg = imageUrl.endsWith(".jpg");

        System.out.println("Does '" + imageUrl + "' end with '.jpg'? " + endsWithJpg);

        String documentName = "report.pdf";
        boolean endsWithDoc = documentName.endsWith(".doc");

        System.out.println("Does '" + documentName + "' end with '.doc'? " + endsWithDoc);
    }
}

En este código:

Declaramos tres variables de tipo String: fileName, imageUrl y documentName.
Usamos el método endsWith() en cada cadena para comprobar si termina con un sufijo específico (.txt, .jpg, .doc).
Los resultados (true o false) se almacenan en variables booleanas (endsWithTxt, endsWithJpg, endsWithDoc).
Finalmente, imprimimos los resultados en la consola usando System.out.println().

Guarda el archivo HelloJava.java (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. Luego, ejecuta el siguiente comando:
```
javac HelloJava.java
```
Si no hay errores, la compilación se completará sin mensajes y se creará un archivo HelloJava.class en el directorio ~/project.
Finalmente, ejecuta el programa compilado usando el comando java:
```
java HelloJava
```
Deberías ver una salida similar a esta:
```
Does 'document.txt' end with '.txt'? true
Does 'photo.jpg' end with '.jpg'? true
Does 'report.pdf' end with '.doc'? false
```
Esta salida muestra los resultados de nuestras comprobaciones con endsWith(), confirmando que document.txt termina con .txt, photo.jpg termina con .jpg y report.pdf no termina con .doc.

Has utilizado con éxito el método endsWith() para comprobar sufijos de cadenas. Esta es una operación fundamental que utilizarás con frecuencia en la programación Java.

Probar el sufijo con sensibilidad a mayúsculas y minúsculas

En el paso anterior, aprendimos cómo usar el método endsWith(). Es importante entender que el método endsWith() en Java realiza una comparación sensible a mayúsculas y minúsculas. Esto significa que "file.txt" termina con ".txt", pero no termina con ".TXT".

Vamos a modificar nuestro programa para ver esta sensibilidad a mayúsculas y minúsculas en acción.

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

Reemplaza el código existente con lo siguiente:

public class HelloJava {
    public static void main(String[] args) {
        String fileName = "document.txt";

        // Comprobación sensible a mayúsculas y minúsculas
        boolean endsWithLowercaseTxt = fileName.endsWith(".txt");
        System.out.println("Does '" + fileName + "' end with '.txt' (lowercase)? " + endsWithLowercaseTxt);

        // Comprobación sensible a mayúsculas y minúsculas con sufijo en mayúsculas
        boolean endsWithUppercaseTxt = fileName.endsWith(".TXT");
        System.out.println("Does '" + fileName + "' end with '.TXT' (uppercase)? " + endsWithUppercaseTxt);

        String anotherFile = "IMAGE.JPG";

        // Comprobación sensible a mayúsculas y minúsculas con sufijo en minúsculas
        boolean endsWithLowercaseJpg = anotherFile.endsWith(".jpg");
        System.out.println("Does '" + anotherFile + "' end with '.jpg' (lowercase)? " + endsWithLowercaseJpg);

        // Comprobación sensible a mayúsculas y minúsculas con sufijo en mayúsculas
        boolean endsWithUppercaseJpg = anotherFile.endsWith(".JPG");
        System.out.println("Does '" + anotherFile + "' end with '.JPG' (uppercase)? " + endsWithUppercaseJpg);
    }
}

En este código actualizado, estamos probando explícitamente endsWith() con sufijos en minúsculas y mayúsculas para resaltar la naturaleza sensible a mayúsculas y minúsculas del método.

Guarda el archivo HelloJava.java.
Compila el programa modificado en la Terminal:
```
javac HelloJava.java
```

Ejecuta el programa compilado:

java HelloJava

Deberías ver una salida similar a esta:

Does 'document.txt' end with '.txt' (lowercase)? true
Does 'document.txt' end with '.TXT' (uppercase)? false
Does 'IMAGE.JPG' end with '.jpg' (lowercase)? false
Does 'IMAGE.JPG' end with '.JPG' (uppercase)? true

Como puedes ver, el método endsWith() devolvió false cuando la capitalización del sufijo no coincidía exactamente con la capitalización de la cadena.

Si necesitas realizar una comprobación insensible a mayúsculas y minúsculas, normalmente convertirías tanto la cadena como el sufijo a la misma capitalización (ya sea minúsculas o mayúsculas) antes de usar endsWith(). No cubriremos eso en este paso específico, pero es una técnica útil para tener en cuenta.

Comprender la sensibilidad a mayúsculas y minúsculas es crucial cuando se trabaja con cadenas en Java, ya que muchos métodos de cadena son sensibles a mayúsculas y minúsculas por defecto.

Combinar comprobaciones de startsWith() y endsWith()

Además de comprobar el final de una cadena con endsWith(), también puedes comprobar el inicio de una cadena utilizando el método startsWith(). Este método funciona de manera similar a endsWith(), tomando un prefijo como argumento y devolviendo true si la cadena comienza con ese prefijo, y false en caso contrario. Al igual que endsWith(), startsWith() también es sensible a mayúsculas y minúsculas.

Combinar startsWith() y endsWith() te permite realizar comprobaciones más específicas en las cadenas. Por ejemplo, es posible que desees comprobar si un nombre de archivo comienza con "temp_" y termina con ".log".

Vamos a actualizar nuestro programa para usar tanto startsWith() como endsWith().

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

Reemplaza el código existente con lo siguiente:

public class HelloJava {
    public static void main(String[] args) {
        String logFileName = "temp_application_error.log";

        boolean startsWithTemp = logFileName.startsWith("temp_");
        boolean endsWithLog = logFileName.endsWith(".log");

        System.out.println("Does '" + logFileName + "' start with 'temp_'? " + startsWithTemp);
        System.out.println("Does '" + logFileName + "' end with '.log'? " + endsWithLog);

        // Combine checks using the logical AND operator (&&)
        boolean isTempLogFile = startsWithTemp && endsWithLog;
        System.out.println("Is '" + logFileName + "' a temporary log file? " + isTempLogFile);

        String anotherFile = "data_report.txt";

        boolean startsWithData = anotherFile.startsWith("data_");
        boolean endsWithTxt = anotherFile.endsWith(".txt");

        System.out.println("Does '" + anotherFile + "' start with 'data_'? " + startsWithData);
        System.out.println("Does '" + anotherFile + "' end with '.txt'? " + endsWithTxt);

        boolean isDataTxtFile = startsWithData && endsWithTxt;
        System.out.println("Is '" + anotherFile + "' a data text file? " + isDataTxtFile);
    }
}

En este código:

Introducimos el método startsWith() para comprobar el inicio de las cadenas.
Usamos el operador lógico AND (&&) para combinar los resultados de startsWith() y endsWith(). El operador && devuelve true solo si ambas condiciones son true.

Guarda el archivo HelloJava.java.
Compila el programa en la Terminal:
```
javac HelloJava.java
```

Ejecuta el programa compilado:

java HelloJava

Deberías ver una salida similar a esta:

Does 'temp_application_error.log' start with 'temp_'? true
Does 'temp_application_error.log' end with '.log'? true
Is 'temp_application_error.log' a temporary log file? true
Does 'data_report.txt' start with 'data_'? true
Does 'data_report.txt' end with '.txt'? true
Is 'data_report.txt' a data text file? true

Esta salida demuestra cómo se pueden usar startsWith() y endsWith() junto con operadores lógicos para realizar comprobaciones de cadenas más complejas.

Ahora has aprendido cómo usar tanto startsWith() como endsWith() y combinarlos para verificar tanto el inicio como el final de una cadena. Estos métodos son herramientas fundamentales para la manipulación y validación de cadenas en Java.

Resumen

En este laboratorio (lab), aprendimos cómo comprobar si una cadena termina con un sufijo específico en Java utilizando el método endsWith(). Exploramos su uso básico para verificar sufijos como extensiones de archivos y observamos cómo devuelve un valor booleano que indica si la cadena termina con el sufijo especificado.

También investigamos la sensibilidad a mayúsculas y minúsculas del método endsWith() y aprendimos cómo realizar comprobaciones insensibles a mayúsculas y minúsculas convirtiendo la cadena y el sufijo a la misma capitalización antes de la comparación. Finalmente, combinamos los métodos startsWith() y endsWith() para comprobar si una cadena comienza y termina con prefijos y sufijos específicos, demostrando cómo se pueden usar estos métodos juntos para una validación de cadenas más compleja.