Cómo comprobar si una cadena contiene una subcadena específica en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena contiene una subcadena específica en Java. Exploraremos diferentes métodos para esta tarea común, comenzando con el sencillo método contains(). Aprenderás cómo usar contains() para determinar si una cadena incluye una secuencia determinada de caracteres y practicarás implementarlo en un sencillo programa de Java.

Después de la introducción al método contains(), el laboratorio te guiará en el uso del método indexOf() no solo para verificar la presencia de una subcadena, sino también para encontrar su posición dentro de la cadena. Finalmente, aprenderás técnicas para realizar comprobaciones de subcadenas sin distinguir mayúsculas y minúsculas, asegurando que tu código pueda manejar variaciones en la capitalización. Al final de este laboratorio, tendrás una sólida comprensión de varios enfoques para la comprobación de subcadenas en Java.

Utiliza contains() para buscar una subcadena

En este paso, aprenderemos cómo verificar si una cadena contiene una subcadena específica en Java utilizando el método contains(). Esta es una tarea común en la programación, por ejemplo, cuando se busca una palabra clave en una frase o se verifica si un nombre de archivo contiene una determinada extensión.

El método contains() es parte de la clase String en Java. Devuelve true si la cadena contiene la secuencia especificada de caracteres y false en caso contrario.

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

Abre el Explorador de archivos en el lado izquierdo del WebIDE.
Asegúrate de estar en el directorio ~/project.
Haz clic derecho en el espacio vacío y selecciona "Nuevo archivo".
Nombrar el nuevo archivo StringContains.java.
Abre el archivo StringContains.java en el editor.

Copia y pega el siguiente código en el editor:

public class StringContains {
    public static void main(String[] args) {
        String sentence = "Java programming is fun and powerful.";
        String keyword = "programming";

        // Check if the sentence contains the keyword
        boolean containsKeyword = sentence.contains(keyword);

        System.out.println("Sentence: \"" + sentence + "\"");
        System.out.println("Keyword: \"" + keyword + "\"");
        System.out.println("Does the sentence contain the keyword? " + containsKeyword);

        String anotherKeyword = "Python";
        boolean containsAnotherKeyword = sentence.contains(anotherKeyword);

        System.out.println("\nAnother keyword: \"" + anotherKeyword + "\"");
        System.out.println("Does the sentence contain the another keyword? " + containsAnotherKeyword);
    }
}

En este código:

Declaramos una variable String llamada sentence y una variable String llamada keyword.
Usamos sentence.contains(keyword) para verificar si sentence contiene la secuencia de caracteres en keyword. El resultado se almacena en una variable boolean llamada containsKeyword.
Imprimimos la frase original, la palabra clave y el resultado de la comprobación con contains().
Repetimos el proceso con una palabra clave diferente, "Python", para ver el resultado cuando la subcadena no se encuentra.

Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal en la parte inferior del WebIDE.
Asegúrate de estar en el directorio ~/project utilizando el siguiente comando:
```
cd ~/project
```
Compila el programa Java utilizando el comando javac:
```
javac StringContains.java
```
Si no hay errores, no verás ninguna salida. Se creará un archivo StringContains.class en el directorio ~/project.

Ejecuta el programa Java compilado utilizando el comando java:

java StringContains

Deberías ver una salida similar a esta:

Sentence: "Java programming is fun and powerful."
Keyword: "programming"
Does the sentence contain the keyword? true

Another keyword: "Python"
Does the sentence contain the another keyword? false

Esta salida muestra que el método contains() identificó correctamente que la frase contiene "programming" pero no "Python".

Explora indexOf() para la posición de la subcadena

En el paso anterior, aprendimos cómo verificar si una cadena contiene una subcadena utilizando contains(). Ahora, exploremos otro método útil, indexOf(), que no solo nos dice si una subcadena existe, sino que también nos da su posición inicial dentro de la cadena.

El método indexOf() de la clase String en Java devuelve el índice dentro de la cadena de la primera aparición de la subcadena especificada. El índice es la posición del primer carácter de la subcadena. Recuerda que en la programación, la indexación generalmente comienza desde 0. Si la subcadena no se encuentra, indexOf() devuelve -1.

Modifiquemos nuestro archivo Java anterior, StringContains.java, para utilizar el método indexOf().

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

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

public class StringContains {
    public static void main(String[] args) {
        String sentence = "Java programming is fun and powerful.";
        String keyword = "programming";

        // Find the index of the keyword
        int index = sentence.indexOf(keyword);

        System.out.println("Sentence: \"" + sentence + "\"");
        System.out.println("Keyword: \"" + keyword + "\"");

        if (index != -1) {
            System.out.println("The keyword \"" + keyword + "\" was found at index: " + index);
        } else {
            System.out.println("The keyword \"" + keyword + "\" was not found.");
        }

        String anotherKeyword = "Python";
        int anotherIndex = sentence.indexOf(anotherKeyword);

        System.out.println("\nAnother keyword: \"" + anotherKeyword + "\"");

        if (anotherIndex != -1) {
            System.out.println("The keyword \"" + anotherKeyword + "\" was found at index: " + anotherIndex);
        } else {
            System.out.println("The keyword \"" + anotherKeyword + "\" was not found.");
        }
    }
}

En este código actualizado:

Usamos sentence.indexOf(keyword) para encontrar el índice inicial de la keyword dentro de la sentence. El resultado se almacena en una variable int llamada index.
Usamos una declaración if para verificar si el index devuelto es -1. Si no es -1, significa que se encontró la palabra clave, y se imprime su índice. De lo contrario, se imprime un mensaje que indica que la palabra clave no se encontró.
Repetimos el proceso para "Python" para demostrar el caso en el que la subcadena no está presente.

Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal en la parte inferior del WebIDE.
Asegúrate de estar en el directorio ~/project.
Compila el programa Java modificado:
```
javac StringContains.java
```

Ejecuta el programa Java compilado:

java StringContains

Deberías ver una salida similar a esta:

Sentence: "Java programming is fun and powerful."
Keyword: "programming"
The keyword "programming" was found at index: 5

Another keyword: "Python"
The keyword "Python" was not found.

La salida muestra que "programming" comienza en el índice 5 en la frase (recuerda que 'J' está en el índice 0, 'a' está en el índice 1, y así sucesivamente, incluyendo el espacio). También indica correctamente que "Python" no se encontró.

Usar indexOf() es una forma poderosa no solo de verificar la presencia de una subcadena, sino también de determinar su ubicación exacta, lo cual puede ser útil para diversas tareas de manipulación de cadenas.

Hacer la comprobación de subcadenas insensible a mayúsculas y minúsculas

En los pasos anteriores, utilizamos contains() e indexOf() para buscar subcadenas. Sin embargo, estos métodos distinguen entre mayúsculas y minúsculas. Esto significa que "Java" se considera diferente de "java" o "JAVA". En muchas situaciones, es posible que desees realizar una búsqueda sin distinción de mayúsculas y minúsculas.

La clase String de Java no tiene un método incorporado como containsIgnoreCase() o indexOfIgnoreCase(). Sin embargo, podemos lograr la insensibilidad a mayúsculas y minúsculas convirtiendo tanto la cadena original como la subcadena al mismo caso (ya sea minúsculas o mayúsculas) antes de realizar la búsqueda. El enfoque más común es convertir ambas a minúsculas utilizando el método toLowerCase().

Modifiquemos nuevamente nuestro archivo StringContains.java para realizar una búsqueda sin distinción de mayúsculas y minúsculas.

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

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

public class StringContains {
    public static void main(String[] args) {
        String sentence = "Java programming is fun and powerful.";
        String keyword = "JAVA"; // Using uppercase for demonstration

        // Convert both strings to lowercase for case-insensitive comparison
        String lowerSentence = sentence.toLowerCase();
        String lowerKeyword = keyword.toLowerCase();

        // Use contains() on the lowercase strings
        boolean containsKeyword = lowerSentence.contains(lowerKeyword);

        System.out.println("Original Sentence: \"" + sentence + "\"");
        System.out.println("Original Keyword: \"" + keyword + "\"");
        System.out.println("Does the sentence contain the keyword (case-insensitive)? " + containsKeyword);

        // You can also use indexOf() in a case-insensitive way
        int index = lowerSentence.indexOf(lowerKeyword);

        if (index != -1) {
            System.out.println("The keyword \"" + keyword + "\" was found at index (case-insensitive): " + index);
        } else {
            System.out.println("The keyword \"" + keyword + "\" was not found (case-insensitive).");
        }
    }
}

En este código:

Definimos la keyword como "JAVA" (en mayúsculas).
Creamos nuevas cadenas lowerSentence y lowerKeyword convirtiendo las cadenas originales a minúsculas utilizando toLowerCase().
Luego, utilizamos el método contains() en las cadenas en minúsculas para realizar una comprobación sin distinción de mayúsculas y minúsculas.
También demostramos cómo usar indexOf() de manera insensible a mayúsculas y minúsculas aplicándolo a las cadenas en minúsculas.

Guarda el archivo (Ctrl+S o Cmd+S).
Abre la Terminal en la parte inferior del WebIDE.
Asegúrate de estar en el directorio ~/project.
Compila el programa Java modificado:
```
javac StringContains.java
```

Ejecuta el programa Java compilado:

java StringContains

Deberías ver una salida similar a esta:

Original Sentence: "Java programming is fun and powerful."
Original Keyword: "JAVA"
Does the sentence contain the keyword (case-insensitive)? true
The keyword "JAVA" was found at index (case-insensitive): 0

Esta salida muestra que, aunque la palabra clave original era "JAVA" (en mayúsculas), la búsqueda sin distinción de mayúsculas y minúsculas la encontró correctamente en la frase y reportó su índice (que es 0 para "Java" en minúsculas).

Al convertir las cadenas a un caso consistente antes de buscar, puedes realizar fácilmente comprobaciones de subcadenas sin distinción de mayúsculas y minúsculas en Java.

Resumen

En este laboratorio (lab), aprendimos cómo verificar si una cadena contiene una subcadena específica en Java. Comenzamos utilizando el método contains(), que proporciona una simple comprobación booleana para la presencia de una subcadena. Este método es sencillo y útil para comprobaciones básicas de existencia de subcadenas.

Luego exploramos el método indexOf(), que no solo comprueba la presencia de una subcadena, sino que también devuelve el índice inicial de la primera aparición. Esto permite un análisis más detallado de la posición de la subcadena dentro de la cadena. Finalmente, abordamos el requisito común de realizar comprobaciones de subcadenas sin distinción de mayúsculas y minúsculas, demostrando técnicas para lograrlo independientemente de la capitalización de la cadena original.