Como encontrar uma palavra em uma String Java usando o método indexOf()

JavaBeginner
Pratique Agora

Introdução

Neste tutorial de programação Java, exploraremos o método indexOf(), uma ferramenta versátil para encontrar palavras ou caracteres dentro de uma String Java. O método indexOf() é essencial para trabalhar com texto em aplicações Java, permitindo que você procure por conteúdo específico dentro de strings maiores. Ao final deste tutorial, você entenderá como usar este método de forma eficaz e aplicá-lo em vários cenários para aprimorar suas habilidades de manipulação de strings em Java.

Criando Seu Primeiro Programa de Busca em Strings

Nesta etapa, criaremos um programa Java simples que demonstra como usar o método indexOf() para encontrar uma palavra específica dentro de uma string.

Entendendo o Método indexOf()

O método indexOf() é uma função embutida na classe String do Java que ajuda a localizar a posição de uma substring dentro de uma string maior. Aqui está a sintaxe básica:

int indexOf(String str)

Este método retorna o índice (posição) da primeira ocorrência da substring especificada. Se a substring não for encontrada, o método retorna -1.

Criando o Arquivo Java

Vamos criar nosso primeiro programa para ver o método indexOf() em ação:

  1. Abra o WebIDE no seu ambiente LabEx
  2. Crie um novo arquivo clicando no ícone "New File" ou usando o menu File
  3. Nomeie o arquivo StringSearchDemo.java
  4. Insira o seguinte código no arquivo:
public class StringSearchDemo {
    public static void main(String[] args) {
        // Crie uma frase de exemplo para pesquisar
        String sentence = "Java programming is both fun and challenging";

        // Encontre a posição de uma palavra usando indexOf()
        int position = sentence.indexOf("fun");

        // Exiba os resultados
        System.out.println("Original sentence: " + sentence);
        System.out.println("Searching for the word 'fun'");

        if (position != -1) {
            System.out.println("The word 'fun' was found at position: " + position);
        } else {
            System.out.println("The word 'fun' was not found in the sentence");
        }
    }
}

Compilando e Executando o Programa

Agora vamos compilar e executar nosso programa:

  1. Abra um terminal no WebIDE (se ainda não estiver aberto)
  2. Compile o arquivo Java executando:
    javac StringSearchDemo.java
  3. Execute o programa compilado:
    java StringSearchDemo

Você deve ver uma saída semelhante a:

Original sentence: Java programming is both fun and challenging
Searching for the word 'fun'
The word 'fun' was found at position: 25

Explorando o Resultado

A saída mostra que nosso programa encontrou com sucesso a palavra "fun" na posição 25 na string. Em Java, os índices de string começam em 0, então o 26º caractere está no índice 25.

Você pode verificar isso contando os caracteres: "Java programming is both " tem exatamente 25 caracteres, e então "fun" começa.

Tente Pesquisar por uma Palavra Diferente

Vamos modificar nosso programa para pesquisar por uma palavra diferente. Mude o termo de pesquisa de "fun" para "programming" no seu código:

int position = sentence.indexOf("programming");
System.out.println("Searching for the word 'programming'");

Compile e execute o programa novamente:

javac StringSearchDemo.java
java StringSearchDemo

Você deve ver agora:

Original sentence: Java programming is both fun and challenging
Searching for the word 'programming'
The word 'programming' was found at position: 5

A palavra "programming" começa na posição 5, o que está correto porque "Java " tem 5 caracteres.

Encontrando Múltiplas Ocorrências de uma Palavra

Agora que entendemos os conceitos básicos de como usar indexOf() para encontrar uma única ocorrência de uma palavra, vamos aprimorar nossas habilidades aprendendo como encontrar todas as ocorrências de uma palavra em uma string.

Entendendo a Segunda Assinatura do Método indexOf()

O método indexOf() tem outra forma útil:

int indexOf(String str, int fromIndex)

Esta versão permite que você especifique uma posição inicial para a pesquisa. Ao usar esta forma, podemos encontrar todas as ocorrências de uma palavra, começando cada nova pesquisa de onde paramos.

Criando um Programa de Pesquisa Múltipla

Vamos criar um novo programa Java que encontra todas as ocorrências de uma palavra específica:

  1. Crie um novo arquivo chamado MultipleFinder.java
  2. Insira o seguinte código:
public class MultipleFinder {
    public static void main(String[] args) {
        // Crie um texto de exemplo com múltiplas ocorrências de uma palavra
        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("Original text:");
        System.out.println(paragraph);
        System.out.println("\nSearching for all occurrences of 'Java':");

        // Encontre todas as ocorrências de "Java"
        String searchWord = "Java";
        int position = 0;
        int count = 0;

        // Loop até que não sejam encontradas mais ocorrências
        while (position != -1) {
            position = paragraph.indexOf(searchWord, position);

            if (position != -1) {
                count++;
                System.out.println("Occurrence " + count + " found at position: " + position);

                // Mova-se após esta ocorrência para encontrar a próxima
                position += searchWord.length();
            }
        }

        System.out.println("\nTotal occurrences found: " + count);
    }
}

Compilando e Executando o Programa de Pesquisa Múltipla

Agora vamos compilar e executar nosso novo programa:

  1. No terminal, compile o arquivo Java:
    javac MultipleFinder.java
  2. Execute o programa compilado:
    java MultipleFinder

Você deve ver uma saída semelhante a:

Original text:
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.

Searching for all occurrences of 'Java':
Occurrence 1 found at position: 0
Occurrence 2 found at position: 42
Occurrence 3 found at position: 72
Occurrence 4 found at position: 149

Total occurrences found: 4

Como o Programa Funciona

Vamos detalhar como este programa encontra todas as ocorrências:

  1. Definimos a posição inicial da pesquisa como 0 (o início da string)
  2. Entramos em um loop while que continua até que indexOf() retorne -1 (sem mais correspondências)
  3. Para cada correspondência, nós:
    • Imprimimos a posição onde encontramos a palavra
    • Atualizamos a posição da pesquisa para começar após a correspondência atual, adicionando o comprimento da palavra de pesquisa
  4. O loop continua até que não sejam encontradas mais correspondências
  5. Finalmente, imprimimos o número total de ocorrências encontradas

Lidando com a Sensibilidade a Case

O método indexOf() é sensível a case por padrão. Vamos modificar nosso programa para realizar uma pesquisa sem distinção entre maiúsculas e minúsculas, convertendo o texto e o termo de pesquisa para minúsculas:

Adicione estas linhas a MultipleFinder.java logo após o início do método main:

// Demonstração de pesquisa sem distinção entre maiúsculas e minúsculas
System.out.println("\n--- Case-insensitive search ---");
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("Occurrence " + count + " found at position: " + position);
        position += lowercaseSearchWord.length();
    }
}

System.out.println("\nTotal occurrences found (case-insensitive): " + count);

Compile e execute o programa atualizado:

javac MultipleFinder.java
java MultipleFinder

A saída agora incluirá os resultados da pesquisa com e sem distinção entre maiúsculas e minúsculas.

Construindo um Analisador de Texto Simples

Nesta etapa, criaremos uma aplicação prática que usa o método indexOf(). Construiremos um analisador de texto simples que pode contar palavras específicas e identificar suas posições em um texto maior.

Criando o Analisador de Texto

  1. Crie um novo arquivo chamado TextAnalyzer.java
  2. Insira o seguinte código:
import java.util.Scanner;

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

        // Texto de exemplo para analisar
        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("Text Analyzer Program");
        System.out.println("=====================");
        System.out.println("\nText to analyze:");
        System.out.println(sampleText);

        // Solicitar ao usuário uma palavra para pesquisar
        System.out.print("\nEnter a word to search for: ");
        String searchWord = scanner.nextLine();

        // Chamar métodos para analisar o texto
        int occurrences = countOccurrences(sampleText, searchWord);

        // Exibir resultados
        System.out.println("\nAnalysis Results:");
        System.out.println("----------------");
        System.out.println("Word searched for: \"" + searchWord + "\"");
        System.out.println("Number of occurrences: " + occurrences);

        // Mostrar as posições se a palavra foi encontrada
        if (occurrences > 0) {
            System.out.println("\nPositions where \"" + searchWord + "\" appears:");
            findPositions(sampleText, searchWord);
        }

        // Calcular a porcentagem do texto que a palavra representa
        if (occurrences > 0) {
            // Calcular qual porcentagem do texto esta palavra representa
            double percentage = (double)(searchWord.length() * occurrences) / sampleText.length() * 100;
            System.out.printf("\nThe word \"%s\" makes up %.2f%% of the total text.\n",
                              searchWord, percentage);
        }

        scanner.close();
    }

    // Método para contar ocorrências de uma palavra no 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 as posições de uma palavra
    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("  Occurrence " + occurrence + ": Position " + position +
                                  " (ends at position " + (position + word.length() - 1) + ")");

                // Mostrar o contexto em torno da palavra
                int contextStart = Math.max(0, position - 10);
                int contextEnd = Math.min(text.length(), position + word.length() + 10);
                String context = text.substring(contextStart, contextEnd);

                // Destacar a palavra no contexto
                System.out.print("  Context: ");
                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 e Executando o Analisador de Texto

Agora vamos compilar e executar nosso analisador de texto:

  1. No terminal, compile o arquivo Java:

    javac TextAnalyzer.java
  2. Execute o programa compilado:

    java TextAnalyzer
  3. Quando solicitado, insira uma palavra para pesquisar, como Java

Você deve ver uma saída semelhante a:

Text Analyzer Program
=====================

Text to analyze:
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.

Enter a word to search for: Java

Analysis Results:
----------------
Word searched for: "Java"
Number of occurrences: 4

Positions where "Java" appears:
  Occurrence 1: Position 0 (ends at position 3)
  Context: ...Java is one o...

  Occurrence 2: Position 48 (ends at position 51)
  Context: ...guages. Java was dev...

  Occurrence 3: Position 93 (ends at position 96)
  Context: ...Today, Java is used...

  Occurrence 4: Position 197 (ends at position 200)
  Context: ...more. Java is know...

The word "Java" makes up 1.67% of the total text.

Entendendo o Analisador de Texto

Nosso analisador de texto faz o seguinte:

  1. Ele exibe um texto de exemplo para análise
  2. Ele pede ao usuário para inserir uma palavra para pesquisar
  3. Ele conta quantas vezes a palavra aparece no texto
  4. Ele exibe as posições onde a palavra aparece
  5. Para cada ocorrência, ele mostra o contexto circundante
  6. Ele calcula qual porcentagem do texto total é composta pela palavra de pesquisa

Esta aplicação demonstra um uso prático do método indexOf() para análise de texto. O programa pode ser estendido para incluir mais recursos, como:

  • Pesquisa sem distinção entre maiúsculas e minúsculas
  • Encontrar apenas palavras inteiras (não partes de palavras)
  • Analisar várias palavras de uma vez
  • Gerar estatísticas sobre o texto

Tente executar o programa novamente com diferentes palavras de pesquisa para ver como ele se comporta com várias entradas.

Resumo

Neste tutorial, você aprendeu como usar o método indexOf() em Java para encontrar palavras dentro de strings. Você dominou:

  1. Usar indexOf() para encontrar a primeira ocorrência de uma palavra em uma string
  2. Encontrar todas as ocorrências de uma palavra usando um loop e a segunda forma de indexOf()
  3. Realizar pesquisas sem distinção entre maiúsculas e minúsculas, convertendo strings para minúsculas
  4. Construir uma aplicação prática de análise de texto que demonstra usos do mundo real do método indexOf()

Essas habilidades de manipulação de strings são fundamentais na programação Java e serão valiosas em várias tarefas de programação, incluindo processamento de dados, validação de entrada do usuário e análise de texto. Ao entender como localizar e trabalhar com partes específicas de strings, você pode construir aplicações mais sofisticadas e fáceis de usar.

À medida que você continua sua jornada em Java, você pode estender esses conceitos explorando outros métodos de String como substring(), replace() e expressões regulares para um processamento de texto mais avançado.