¿Cómo encontrar una palabra en una cadena Java usando el método indexOf()?

Introducción

En este tutorial de programación Java, exploraremos el método indexOf(), una herramienta versátil para encontrar palabras o caracteres dentro de una cadena (String) de Java. El método indexOf() es esencial para trabajar con texto en aplicaciones Java, permitiéndole buscar contenido específico dentro de cadenas más grandes. Al final de este tutorial, comprenderá cómo usar este método de manera efectiva y aplicarlo en varios escenarios para mejorar sus habilidades de manejo de cadenas en Java.

Creando tu Primer Programa de Búsqueda de Cadenas

En este paso, crearemos un programa Java simple que demuestra cómo usar el método indexOf() para encontrar una palabra específica dentro de una cadena.

Entendiendo el Método indexOf()

El método indexOf() es una función incorporada en la clase String de Java que ayuda a localizar la posición de una subcadena dentro de una cadena más grande. Aquí está la sintaxis básica:

int indexOf(String str)

Este método devuelve el índice (posición) de la primera aparición de la subcadena especificada. Si la subcadena no se encuentra, el método devuelve -1.

Creando el Archivo Java

Creemos nuestro primer programa para ver el método indexOf() en acción:

1. Abre el WebIDE en tu entorno LabEx
2. Crea un nuevo archivo haciendo clic en el icono "Nuevo Archivo" o usando el menú Archivo
3. Nombra el archivo StringSearchDemo.java
4. Introduce el siguiente código en el archivo:

public class StringSearchDemo {
    public static void main(String[] args) {
        // Crea una frase de ejemplo para buscar
        String sentence = "Java programming is both fun and challenging";

        // Encuentra la posición de una palabra usando indexOf()
        int position = sentence.indexOf("fun");

        // Muestra los resultados
        System.out.println("Frase original: " + sentence);
        System.out.println("Buscando la palabra 'fun'");

        if (position != -1) {
            System.out.println("La palabra 'fun' fue encontrada en la posición: " + position);
        } else {
            System.out.println("La palabra 'fun' no fue encontrada en la frase");
        }
    }
}

Compilando y Ejecutando el Programa

Ahora, compilemos y ejecutemos nuestro programa:

1. Abre una terminal en el WebIDE (si aún no está abierta)
2. Compila el archivo Java ejecutando:

   javac StringSearchDemo.java
   

3. Ejecuta el programa compilado:

   java StringSearchDemo
   

Deberías ver una salida similar a:

Frase original: Java programming is both fun and challenging
Buscando la palabra 'fun'
La palabra 'fun' fue encontrada en la posición: 25

Explorando el Resultado

La salida muestra que nuestro programa encontró con éxito la palabra "fun" en la posición 25 en la cadena. En Java, los índices de las cadenas comienzan en 0, por lo que el carácter 26 está en el índice 25.

Puedes verificar esto contando los caracteres: "Java programming is both " tiene exactamente 25 caracteres, y luego comienza "fun".

Intenta Buscar una Palabra Diferente

Modifiquemos nuestro programa para buscar una palabra diferente. Cambia el término de búsqueda de "fun" a "programming" en tu código:

int position = sentence.indexOf("programming");
System.out.println("Buscando la palabra 'programming'");

Compila y ejecuta el programa de nuevo:

javac StringSearchDemo.java
java StringSearchDemo

Ahora deberías ver:

Frase original: Java programming is both fun and challenging
Buscando la palabra 'programming'
La palabra 'programming' fue encontrada en la posición: 5

La palabra "programming" comienza en la posición 5, lo cual es correcto porque "Java " tiene 5 caracteres.

Encontrando Múltiples Ocurrencias de una Palabra

Ahora que entendemos los conceptos básicos de usar indexOf() para encontrar una sola ocurrencia de una palabra, mejoremos nuestras habilidades aprendiendo cómo encontrar todas las ocurrencias de una palabra en una cadena.

Entendiendo la Segunda Firma del Método indexOf()

El método indexOf() tiene otra forma útil:

int indexOf(String str, int fromIndex)

Esta versión te permite especificar una posición de inicio para la búsqueda. Al usar esta forma, podemos encontrar todas las ocurrencias de una palabra comenzando cada nueva búsqueda desde donde la dejamos.

Creando un Programa de Búsqueda Múltiple

Creemos un nuevo programa Java que encuentre todas las ocurrencias de una palabra específica:

1. Crea un nuevo archivo llamado MultipleFinder.java
2. Introduce el siguiente código:

public class MultipleFinder {
    public static void main(String[] args) {
        // Crea un texto de ejemplo con múltiples ocurrencias de una palabra
        String paragraph = "Java is a popular programming language. Java runs on various platforms. " +
                          "Java is used for developing web applications, mobile apps, and more. " +
                          "Learning Java is essential for many software development roles.";

        System.out.println("Texto original:");
        System.out.println(paragraph);
        System.out.println("\nBuscando todas las ocurrencias de 'Java':");

        // Encuentra todas las ocurrencias de "Java"
        String searchWord = "Java";
        int position = 0;
        int count = 0;

        // Bucle hasta que no se encuentren más ocurrencias
        while (position != -1) {
            position = paragraph.indexOf(searchWord, position);

            if (position != -1) {
                count++;
                System.out.println("Ocurrencia " + count + " encontrada en la posición: " + position);

                // Avanza más allá de esta ocurrencia para encontrar la siguiente
                position += searchWord.length();
            }
        }

        System.out.println("\nTotal de ocurrencias encontradas: " + count);
    }
}

Compilando y Ejecutando el Programa de Búsqueda Múltiple

Ahora, compilemos y ejecutemos nuestro nuevo programa:

1. En la terminal, compila el archivo Java:

   javac MultipleFinder.java
   

2. Ejecuta el programa compilado:

   java MultipleFinder
   

Deberías ver una salida similar a:

Texto original:
Java is a popular programming language. Java runs on various platforms. Java is used for developing web applications, mobile apps, and more. Learning Java is essential for many software development roles.

Buscando todas las ocurrencias de 'Java':
Ocurrencia 1 encontrada en la posición: 0
Ocurrencia 2 encontrada en la posición: 42
Ocurrencia 3 encontrada en la posición: 72
Ocurrencia 4 encontrada en la posición: 149

Total de ocurrencias encontradas: 4

Cómo Funciona el Programa

Desglosemos cómo este programa encuentra todas las ocurrencias:

1. Establecemos la posición de búsqueda inicial en 0 (el principio de la cadena)
2. Entramos en un bucle while que continúa hasta que indexOf() devuelve -1 (no más coincidencias)
3. Para cada coincidencia, hacemos lo siguiente:
   • Imprimimos la posición donde encontramos la palabra
   • Actualizamos la posición de búsqueda para comenzar después de la coincidencia actual agregando la longitud de la palabra de búsqueda
4. El bucle continúa hasta que no se encuentran más coincidencias
5. Finalmente, imprimimos el número total de ocurrencias encontradas

Manejo de la Sensibilidad a Mayúsculas y Minúsculas

El método indexOf() es sensible a mayúsculas y minúsculas por defecto. Modifiquemos nuestro programa para realizar una búsqueda que no distinga entre mayúsculas y minúsculas convirtiendo tanto el texto como el término de búsqueda a minúsculas:

Añade estas líneas a MultipleFinder.java justo después de que comience el método main:

// Demostración de búsqueda sin distinción entre mayúsculas y minúsculas
System.out.println("\n--- Búsqueda sin distinción entre mayúsculas y minúsculas ---");
String lowercaseParagraph = paragraph.toLowerCase();
String lowercaseSearchWord = searchWord.toLowerCase();

position = 0;
count = 0;

while (position != -1) {
    position = lowercaseParagraph.indexOf(lowercaseSearchWord, position);

    if (position != -1) {
        count++;
        System.out.println("Ocurrencia " + count + " encontrada en la posición: " + position);
        position += lowercaseSearchWord.length();
    }
}

System.out.println("\nTotal de ocurrencias encontradas (sin distinción entre mayúsculas y minúsculas): " + count);

Compila y ejecuta el programa actualizado:

javac MultipleFinder.java
java MultipleFinder

La salida ahora incluirá tanto los resultados de búsqueda con distinción entre mayúsculas y minúsculas como los resultados de búsqueda sin distinción entre mayúsculas y minúsculas.

Construyendo un Analizador de Texto Simple

En este paso, crearemos una aplicación práctica que utiliza el método indexOf(). Construiremos un analizador de texto simple que puede contar palabras específicas e identificar sus posiciones en un texto más grande.

Creando el Analizador de Texto

1. Crea un nuevo archivo llamado TextAnalyzer.java
2. Introduce el siguiente código:

import java.util.Scanner;

public class TextAnalyzer {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Texto de ejemplo para analizar
        String sampleText = "Java is one of the most popular programming languages. Java was developed " +
                          "by Sun Microsystems. Today, Java is used to develop mobile apps, web applications, " +
                          "desktop applications, games and much more. Java is known for its simplicity, " +
                          "object-oriented features, and platform independence.";

        System.out.println("Programa Analizador de Texto");
        System.out.println("=====================");
        System.out.println("\nTexto para analizar:");
        System.out.println(sampleText);

        // Solicita al usuario una palabra para buscar
        System.out.print("\nIntroduce una palabra para buscar: ");
        String searchWord = scanner.nextLine();

        // Llama a los métodos para analizar el texto
        int occurrences = countOccurrences(sampleText, searchWord);

        // Muestra los resultados
        System.out.println("\nResultados del Análisis:");
        System.out.println("----------------");
        System.out.println("Palabra buscada: \"" + searchWord + "\"");
        System.out.println("Número de ocurrencias: " + occurrences);

        // Muestra las posiciones si se encontró la palabra
        if (occurrences > 0) {
            System.out.println("\nPosiciones donde \"" + searchWord + "\" aparece:");
            findPositions(sampleText, searchWord);
        }

        // Calcula el porcentaje del texto que representa la palabra
        if (occurrences > 0) {
            // Calcula qué porcentaje del texto representa esta palabra
            double percentage = (double)(searchWord.length() * occurrences) / sampleText.length() * 100;
            System.out.printf("\nLa palabra \"%s\" representa el %.2f%% del texto total.\n",
                              searchWord, percentage);
        }

        scanner.close();
    }

    // Método para contar las ocurrencias de una palabra en el texto
    public static int countOccurrences(String text, String word) {
        int count = 0;
        int position = 0;

        while (position != -1) {
            position = text.indexOf(word, position);

            if (position != -1) {
                count++;
                position += word.length();
            }
        }

        return count;
    }

    // Método para encontrar e imprimir todas las posiciones de una palabra
    public static void findPositions(String text, String word) {
        int position = 0;
        int occurrence = 0;

        while (position != -1) {
            position = text.indexOf(word, position);

            if (position != -1) {
                occurrence++;
                System.out.println("  Ocurrencia " + occurrence + ": Posición " + position +
                                  " (termina en la posición " + (position + word.length() - 1) + ")");

                // Muestra el contexto alrededor de la palabra
                int contextStart = Math.max(0, position - 10);
                int contextEnd = Math.min(text.length(), position + word.length() + 10);
                String context = text.substring(contextStart, contextEnd);

                // Resalta la palabra en el contexto
                System.out.print("  Contexto: ");
                if (contextStart > 0) {
                    System.out.print("...");
                }

                System.out.print(context);

                if (contextEnd < text.length()) {
                    System.out.print("...");
                }
                System.out.println("\n");

                position += word.length();
            }
        }
    }
}

Compilando y Ejecutando el Analizador de Texto

Ahora, compilemos y ejecutemos nuestro analizador de texto:

1. En la terminal, compila el archivo Java:

   javac TextAnalyzer.java
   

2. Ejecuta el programa compilado:

   java TextAnalyzer
   

3. Cuando se te solicite, introduce una palabra para buscar, como Java

Deberías ver una salida similar a:

Programa Analizador de Texto
=====================

Texto para analizar:
Java is one of the most popular programming languages. Java was developed by Sun Microsystems. Today, Java is used to develop mobile apps, web applications, desktop applications, games and much more. Java is known for its simplicity, object-oriented features, and platform independence.

Introduce una palabra para buscar: Java

Resultados del Análisis:
----------------
Palabra buscada: "Java"
Número de ocurrencias: 4

Posiciones donde "Java" aparece:
  Ocurrencia 1: Posición 0 (termina en la posición 3)
  Contexto: ...Java is one o...

  Ocurrencia 2: Posición 48 (termina en la posición 51)
  Contexto: ...guages. Java was dev...

  Ocurrencia 3: Posición 93 (termina en la posición 96)
  Contexto: ...Today, Java is used...

  Ocurrencia 4: Posición 197 (termina en la posición 200)
  Contexto: ...more. Java is know...

La palabra "Java" representa el 1.67% del texto total.

Entendiendo el Analizador de Texto

Nuestro analizador de texto hace lo siguiente:

1. Muestra un texto de ejemplo para analizar
2. Le pide al usuario que introduzca una palabra para buscar
3. Cuenta cuántas veces aparece la palabra en el texto
4. Muestra las posiciones donde aparece la palabra
5. Para cada ocurrencia, muestra el contexto circundante
6. Calcula qué porcentaje del texto total está formado por la palabra de búsqueda

Esta aplicación demuestra un uso práctico del método indexOf() para el análisis de texto. El programa podría extenderse para incluir más funciones, como:

• Búsqueda sin distinción entre mayúsculas y minúsculas
• Encontrar solo palabras completas (no partes de palabras)
• Analizar múltiples palabras a la vez
• Generar estadísticas sobre el texto

Intenta ejecutar el programa de nuevo con diferentes palabras de búsqueda para ver cómo funciona con varias entradas.

Resumen

En este tutorial, has aprendido a usar el método indexOf() en Java para encontrar palabras dentro de cadenas. Has dominado:

1. Usar indexOf() para encontrar la primera ocurrencia de una palabra en una cadena
2. Encontrar todas las ocurrencias de una palabra usando un bucle y la segunda forma de indexOf()
3. Realizar búsquedas que no distinguen entre mayúsculas y minúsculas convirtiendo las cadenas a minúsculas
4. Construir una aplicación práctica de análisis de texto que demuestra usos del mundo real del método indexOf()

Estas habilidades de manipulación de cadenas son fundamentales en la programación Java y serán valiosas en varias tareas de programación, incluyendo el procesamiento de datos, la validación de la entrada del usuario y el análisis de texto. Al comprender cómo localizar y trabajar con partes específicas de las cadenas, puedes construir aplicaciones más sofisticadas y fáciles de usar.

A medida que continúas tu viaje en Java, puedes extender estos conceptos explorando otros métodos de String como substring(), replace() y expresiones regulares para un procesamiento de texto más avanzado.