Como Verificar se uma String Contém uma Substring em Java: Guia Completo

Introdução

Neste laboratório, você aprenderá como verificar se uma string contém uma substring específica em Java. Exploraremos diferentes métodos para esta tarefa comum, começando com o método direto contains(). Você aprenderá como usar contains() para determinar se uma string inclui uma sequência de caracteres dada e praticará a implementação disso em um programa Java simples.

Após a introdução ao contains(), o laboratório o guiará através do uso do método indexOf() não apenas para verificar a presença de uma substring, mas também para encontrar sua posição dentro da string. Finalmente, você aprenderá técnicas para realizar verificações de substring que não diferenciam maiúsculas e minúsculas (case-insensitive), garantindo que seu código possa lidar com variações na capitalização. Ao final deste laboratório, você terá uma sólida compreensão de várias abordagens para a verificação de substring em Java.

Usar `contains()` para Procurar uma Substring

Nesta etapa, aprenderemos como verificar se uma string contém uma substring específica em Java usando o método contains(). Esta é uma tarefa comum em programação, por exemplo, ao procurar uma palavra-chave em uma frase ou verificar se um nome de arquivo contém uma determinada extensão.

O método contains() faz parte da classe String em Java. Ele retorna true se a string contém a sequência especificada de caracteres e false caso contrário.

Vamos criar um novo arquivo Java para praticar o uso de contains().

Abra o Explorador de Arquivos no lado esquerdo da WebIDE.
Certifique-se de estar no diretório ~/project.
Clique com o botão direito no espaço vazio e selecione "Novo Arquivo".
Nomeie o novo arquivo StringContains.java.
Abra o arquivo StringContains.java no editor.

Copie e cole o seguinte código no 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);
    }
}

Neste código:

Declaramos uma variável String chamada sentence e uma variável String chamada keyword.
Usamos sentence.contains(keyword) para verificar se sentence contém a sequência de caracteres em keyword. O resultado é armazenado em uma variável boolean chamada containsKeyword.
Imprimimos a frase original, a palavra-chave e o resultado da verificação contains().
Repetimos o processo com uma palavra-chave diferente, "Python", para ver o resultado quando a substring não é encontrada.

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal na parte inferior da WebIDE.
Certifique-se de estar no diretório ~/project usando o comando:
```
cd ~/project
```
Compile o programa Java usando o comando javac:
```
javac StringContains.java
```
Se não houver erros, você não verá nenhuma saída. Um arquivo StringContains.class será criado no diretório ~/project.

Execute o programa Java compilado usando o comando java:

java StringContains

Você deve ver uma saída semelhante 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 saída mostra que o método contains() identificou corretamente que a frase contém "programming", mas não "Python".

Explorar `indexOf()` para a Posição da Substring

Na etapa anterior, aprendemos como verificar se uma string contém uma substring usando contains(). Agora, vamos explorar outro método útil, indexOf(), que não apenas nos diz se uma substring existe, mas também nos fornece sua posição inicial dentro da string.

O método indexOf() na classe String do Java retorna o índice dentro da string da primeira ocorrência da substring especificada. O índice é a posição do primeiro caractere da substring. Lembre-se de que, em programação, a indexação geralmente começa em 0. Se a substring não for encontrada, indexOf() retorna -1.

Vamos modificar nosso arquivo Java anterior, StringContains.java, para usar o método indexOf().

Abra o arquivo StringContains.java no editor da WebIDE.

Substitua todo o conteúdo do arquivo pelo seguinte 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.");
        }
    }
}

Neste código atualizado:

Usamos sentence.indexOf(keyword) para encontrar o índice inicial de keyword dentro de sentence. O resultado é armazenado em uma variável int chamada index.
Usamos uma instrução if para verificar se o index retornado é -1. Se não for -1, significa que a palavra-chave foi encontrada e imprimimos seu índice. Caso contrário, imprimimos uma mensagem indicando que a palavra-chave não foi encontrada.
Repetimos o processo para "Python" para demonstrar o caso em que a substring não está presente.

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal na parte inferior da WebIDE.
Certifique-se de estar no diretório ~/project.
Compile o programa Java modificado:
```
javac StringContains.java
```

Execute o programa Java compilado:

java StringContains

Você deve ver uma saída semelhante 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.

A saída mostra que "programming" começa no índice 5 na frase (lembrando que 'J' está no índice 0, 'a' está no índice 1 e assim por diante, incluindo o espaço). Também indica corretamente que "Python" não foi encontrado.

Usar indexOf() é uma maneira poderosa não apenas de verificar a presença de uma substring, mas também de determinar sua localização exata, o que pode ser útil para várias tarefas de manipulação de strings.

Tornar a Verificação de Substring Case-Insensitive

Nas etapas anteriores, usamos contains() e indexOf() para procurar substrings. No entanto, esses métodos são case-sensitive (sensíveis a maiúsculas e minúsculas). Isso significa que "Java" é considerado diferente de "java" ou "JAVA". Em muitas situações, você pode querer realizar uma pesquisa case-insensitive (sem distinção entre maiúsculas e minúsculas).

A classe String do Java não possui um método embutido como containsIgnoreCase() ou indexOfIgnoreCase(). No entanto, podemos obter a case-insensitivity convertendo tanto a string original quanto a substring para o mesmo caso (minúsculas ou maiúsculas) antes de realizar a pesquisa. A abordagem mais comum é converter ambas para minúsculas usando o método toLowerCase().

Vamos modificar nosso arquivo StringContains.java novamente para realizar uma pesquisa case-insensitive.

Abra o arquivo StringContains.java no editor da WebIDE.

Substitua todo o conteúdo do arquivo pelo seguinte 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).");
        }
    }
}

Neste código:

Definimos a keyword como "JAVA" (maiúsculas).
Criamos novas strings lowerSentence e lowerKeyword convertendo as strings originais para minúsculas usando toLowerCase().
Em seguida, usamos o método contains() nas strings em minúsculas para realizar uma verificação case-insensitive.
Também demonstramos como usar indexOf() de forma case-insensitive, aplicando-o às strings em minúsculas.

Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal na parte inferior da WebIDE.
Certifique-se de estar no diretório ~/project.
Compile o programa Java modificado:
```
javac StringContains.java
```

Execute o programa Java compilado:

java StringContains

Você deve ver uma saída semelhante 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 saída mostra que, embora a palavra-chave original fosse "JAVA" (maiúsculas), a pesquisa case-insensitive a encontrou corretamente na frase e relatou seu índice (que é 0 para "Java" em minúsculas).

Ao converter strings para um caso consistente antes de pesquisar, você pode facilmente realizar verificações de substring case-insensitive em Java.

Resumo

Neste laboratório, aprendemos como verificar se uma string contém uma substring específica em Java. Começamos usando o método contains(), que fornece uma simples verificação booleana para a presença de uma substring. Este método é direto e útil para verificações básicas de existência de substring.

Em seguida, exploramos o método indexOf(), que não apenas verifica a presença de uma substring, mas também retorna o índice inicial da primeira ocorrência. Isso permite uma análise mais detalhada da posição da substring dentro da string. Finalmente, abordamos o requisito comum de realizar verificações de substring case-insensitive (sem distinção entre maiúsculas e minúsculas), demonstrando técnicas para alcançar isso, independentemente do uso de maiúsculas e minúsculas da string original.

Como Verificar se uma String Contém uma Substring Específica em Java

Introdução

Usar contains() para Procurar uma Substring

Explorar indexOf() para a Posição da Substring

Tornar a Verificação de Substring Case-Insensitive

Resumo

Usar `contains()` para Procurar uma Substring

Explorar `indexOf()` para a Posição da Substring