Expressões Regulares em Java com Exemplos: Guia Completo

Expressões Regulares em Java com Exemplos

Expressões regulares (regex) são uma ferramenta poderosa para pesquisar, extrair e substituir texto com base em um padrão. Em Java, o trabalho com expressões regulares é implementado através do pacote java.util.regex, que inclui duas classes principais: Pattern (padrão) e Matcher (correspondente). Neste artigo, vamos analisar a sintaxe das expressões regulares, os métodos para trabalhar com elas e fornecer exemplos práticos em Java.

1. Fundamentos da Sintaxe de Expressões Regulares

Uma expressão regular define um padrão para pesquisar strings. Aqui estão as construções básicas:

• . — qualquer caractere (exceto quebra de linha).
• \\d — dígito (0-9).
• \\w — letra, dígito ou sublinhado (alfabeto latino).
• \\s — caractere de espaço em branco (espaço, tabulação, quebra de linha).
• [abc] — um dos caracteres a, b ou c.
• [^abc] — qualquer caractere, exceto a, b, c.
• * — zero ou mais repetições.
• + — uma ou mais repetições.
• ? — zero ou uma repetição.
• {n,m} — de n a m repetições.
• ^ — início da string.
• $ — fim da string.
• | — OU lógico.
• () — grupo de captura.

Escape em Java: em literais de string Java, a barra invertida \\ é um caractere de escape. Para passar, por exemplo, \\d para o regex, você precisa escrever "\\\\d". Para um ponto — "\\\\.".

2. Classes Pattern e Matcher

O trabalho com expressões regulares em Java começa com a compilação do padrão:

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

public class RegexExample {
    public static void main(String[] args) {
        // Compila o padrão
        Pattern pattern = Pattern.compile("\\\\d+");
        // Cria um Matcher para a string
        Matcher matcher = pattern.matcher("Preço: 150 reais, desconto 20%");
        
        // Busca todas as correspondências
        while (matcher.find()) {
            System.out.println("Encontrado: " + matcher.group());
        }
    }
}

Saída:

Encontrado: 150
Encontrado: 20

Principais métodos de Matcher:

• find() — procura a próxima correspondência (pode ser chamado várias vezes).
• matches() — verifica se toda a string corresponde ao padrão (requer correspondência completa).
• lookingAt() — verifica se a string começa com o padrão.
• group() — retorna a substring encontrada (ou um grupo específico).
• groupCount() — número de grupos de captura.

3. Exemplos Práticos

3.1. Validação de Endereço de Email

Vamos verificar se a string é um email válido (versão simplificada):

public class EmailValidator {
    public static boolean isValidEmail(String email) {
        String regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(email);
        return matcher.matches();
    }

    public static void main(String[] args) {
        System.out.println(isValidEmail("test@example.com")); // true
        System.out.println(isValidEmail("invalid-email"));    // false
    }
}

Explicação do padrão:

• ^[a-zA-Z0-9._%+-]+ — parte local (letras, dígitos, pontos, sublinhados, etc.).
• @ — símbolo @.
• [a-zA-Z0-9.-]+ — domínio (letras, dígitos, pontos, hífens).
• \\\\.[a-zA-Z]{2,}$ — ponto e domínio de nível superior (pelo menos 2 caracteres).

3.2.