Como Verificar Correspondência de Expressão Regular em Java: Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se uma string corresponde a uma expressão regular em Java. Começaremos entendendo os fundamentos das expressões regulares e como criar um padrão simples usando o pacote java.util.regex.

Em seguida, você explorará as classes Pattern e Matcher para realizar operações de correspondência. Por fim, você aplicará seu conhecimento para testar padrões de regex com a entrada do usuário, ganhando experiência prática no uso de expressões regulares para validação e manipulação de strings em Java.

Criar um Padrão Regex Básico

Nesta etapa, começaremos entendendo o que são expressões regulares (regex) e como criar um padrão básico em Java.

Expressões regulares são ferramentas poderosas usadas para corresponder e manipular strings de texto. Pense nelas como uma mini-linguagem para descrever padrões em texto. Elas são incrivelmente úteis para tarefas como pesquisar texto específico, validar formatos de entrada (como endereços de e-mail ou números de telefone) e substituir texto com base em padrões.

Em Java, as expressões regulares são tratadas pelo pacote java.util.regex. As duas classes principais que usaremos são Pattern e Matcher.

Pattern: Esta classe representa uma expressão regular compilada. Você compila uma string regex em um objeto Pattern.
Matcher: Esta classe é usada para realizar operações de correspondência em uma string de entrada, interpretando um Pattern.

Vamos criar um programa Java simples para definir e imprimir um padrão regex básico.

Abra o arquivo HelloJava.java no editor WebIDE, caso ele ainda não esteja aberto.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Print the pattern
        System.out.println("Our regex pattern is: " + pattern.pattern());
    }
}
```
Vamos analisar as novas partes:
- import java.util.regex.Pattern;: Esta linha importa a classe Pattern, que precisamos para trabalhar com regex.
- String regexPattern = "Java";: Esta linha define uma variável de string simples regexPattern que contém nossa expressão regular. Neste caso, o padrão é apenas a palavra literal "Java".
- Pattern pattern = Pattern.compile(regexPattern);: É aqui que compilamos nossa string regex em um objeto Pattern. O método Pattern.compile() recebe a string regex como argumento e retorna um objeto Pattern.
- System.out.println("Our regex pattern is: " + pattern.pattern());: Esta linha imprime a string regex original que foi usada para criar o objeto Pattern. O método pattern() do objeto Pattern retorna a string regex.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, vamos compilar nosso programa. Abra o Terminal na parte inferior do WebIDE e certifique-se de estar no diretório ~/project. Execute o seguinte comando:
```
javac HelloJava.java
```
Se não houver erros, um arquivo HelloJava.class será criado no diretório ~/project.
Finalmente, execute o programa compilado:
```
java HelloJava
```
Você deve ver a seguinte saída:
```
Our regex pattern is: Java
```
Isso confirma que nosso padrão regex básico foi definido e compilado com sucesso. Na próxima etapa, usaremos este padrão para encontrar correspondências em uma determinada string.

Usar as Classes Pattern e Matcher

Nesta etapa, aprenderemos como usar a classe Matcher com nosso Pattern para encontrar ocorrências do padrão dentro de uma determinada string de entrada.

Como discutimos na etapa anterior, a classe Pattern representa a expressão regular compilada. A classe Matcher é o que usamos para realmente realizar as operações de pesquisa em uma string de entrada específica usando esse padrão compilado.

Aqui está como o processo geralmente funciona:

Compilar a regex: Crie um objeto Pattern a partir de sua string regex usando Pattern.compile().
Criar um Matcher: Obtenha um objeto Matcher chamando o método matcher() no objeto Pattern, passando a string de entrada que você deseja pesquisar.
Realizar a correspondência: Use os métodos do objeto Matcher para encontrar correspondências. Os métodos comuns incluem find() (para encontrar a próxima correspondência) e matches() (para verificar se toda a string de entrada corresponde ao padrão).

Vamos modificar nosso programa HelloJava.java para usar um Matcher para encontrar a palavra "Java" em uma frase de exemplo.

Abra o arquivo HelloJava.java no editor WebIDE.
Substitua o código existente pelo seguinte:
```
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // The input string to search within
        String inputString = "Hello, Java! Welcome to Java programming.";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
        }
    }
}
```
Aqui está o que é novo:
- import java.util.regex.Matcher;: Importamos a classe Matcher.
- String inputString = "Hello, Java! Welcome to Java programming.";: Definimos a string que queremos pesquisar.
- Matcher matcher = pattern.matcher(inputString);: Criamos um objeto Matcher chamando o método matcher() em nosso objeto pattern e passando o inputString.
- while (matcher.find()) { ... }: Este loop usa o método find() do Matcher. O método find() tenta encontrar a próxima subsequência da sequência de entrada que corresponde ao padrão. Ele retorna true se uma correspondência for encontrada e false caso contrário. O loop while continua enquanto find() retorna true.
- System.out.println("Found match at index: " + matcher.start());: Dentro do loop, se uma correspondência for encontrada, matcher.start() retorna o índice inicial da subsequência correspondente na string de entrada. Imprimimos este índice.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac HelloJava.java
```
Execute o programa compilado:
```
java HelloJava
```
Você deve ver uma saída semelhante a esta:
```
Searching for pattern: 'Java' in string: 'Hello, Java! Welcome to Java programming.'
Found match at index: 7
Found match at index: 27
```
Esta saída mostra que nosso programa encontrou com sucesso duas ocorrências da palavra "Java" na string de entrada e imprimiu o índice inicial de cada correspondência.

Você agora usou com sucesso as classes Pattern e Matcher para encontrar um padrão específico dentro de uma string. Na próxima etapa, tornaremos este programa interativo, permitindo que o usuário insira a string a ser pesquisada.

Testar Regex com Entrada do Usuário

Nesta etapa final, tornaremos nosso programa regex interativo, permitindo que o usuário insira a string que deseja pesquisar. Isso tornará o programa mais flexível e demonstrará como combinar regex com a interação do usuário.

Usaremos a classe Scanner, da qual você pode se lembrar do "Seu Primeiro Lab Java", para ler a entrada do usuário.

Abra o arquivo HelloJava.java no editor WebIDE.

Substitua o código existente pelo seguinte:

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Prompt the user to enter a string
        System.out.print("Enter the string to search within: ");
        String inputString = scanner.nextLine();

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        boolean found = false;
        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
            found = true;
        }

        if (!found) {
            System.out.println("No match found.");
        }

        // Close the scanner
        scanner.close();
    }
}

Aqui estão as alterações que fizemos:

import java.util.Scanner;: Importamos a classe Scanner.
Scanner scanner = new Scanner(System.in);: Criamos um objeto Scanner para ler a entrada do console.
System.out.print("Enter the string to search within: ");: Solicitamos que o usuário insira a string.
String inputString = scanner.nextLine();: Lemos a linha inteira de entrada do usuário e a armazenamos na variável inputString.
Adicionamos uma variável boolean found = false; e um bloco if (!found) para imprimir uma mensagem se nenhuma correspondência for encontrada.
scanner.close();: Fechamos o Scanner para liberar recursos do sistema.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa no Terminal:
```
javac HelloJava.java
```
Execute o programa:
```
java HelloJava
```

O programa agora esperará que você insira uma string. Digite uma string que contenha a palavra "Java" (ou não) e pressione Enter.

Por exemplo, se você inserir:

Learning Java is fun!

A saída será:

Enter the string to search within: Learning Java is fun!
Searching for pattern: 'Java' in string: 'Learning Java is fun!'
Found match at index: 9

Se você inserir:

Python is also great.

A saída será:

Enter the string to search within: Python is also great.
Searching for pattern: 'Java' in string: 'Python is also great.'
No match found.

Você agora criou com sucesso um programa Java interativo que usa expressões regulares para pesquisar um padrão em uma string fornecida pelo usuário. Este é um exemplo prático de como regex pode ser usado em aplicações do mundo real.

Resumo

Neste laboratório, começamos entendendo os fundamentos das expressões regulares (regex) em Java, com foco no pacote java.util.regex. Aprendemos que regex é uma ferramenta poderosa para correspondência e manipulação de padrões em strings, e que as classes-chave são Pattern e Matcher. Em seguida, praticamos a criação de um padrão regex básico, definindo uma string simples e compilando-a em um objeto Pattern usando Pattern.compile(), demonstrando como definir e imprimir um padrão regex básico em um programa Java.

Como Verificar se uma String Corresponde a uma Expressão Regular em Java

Introdução

Criar um Padrão Regex Básico

Usar as Classes Pattern e Matcher

Testar Regex com Entrada do Usuário

Resumo