Expressões Regulares (Regex) — História, Conceitos e Java na Prática

O que São Expressões Regulares?

Expressões regulares, ou simplesmente regex, são padrões utilizados para encontrar, validar ou substituir textos dentro de outras strings.

Imagine querer achar todos os e-mails num texto, ou validar se um CEP foi digitado corretamente. Regex permite fazer isso em uma única linha de código, algo que seria bem mais trabalhoso com verificações manuais.

Breve História das Expressões Regulares

A história das expressões regulares é fascinante e está ligada à matemática e à ciência da computação:

• 1951 — O matemático norte-americano Stephen Kleene introduz o conceito de “expressões regulares” enquanto estudava automatos finitos e linguagens formais.
• 1968 — Ken Thompson implementa regex pela primeira vez em software, no editor QED para o sistema operacional CTSS, um antecessor do Unix.
• 1970s — Regex passa a integrar o Unix, em ferramentas como ed, sed, grep e awk.
• Décadas seguintes — Regex se espalha para quase todas as linguagens de programação, inclusive Java, PHP, Python, Perl e muitas outras.

Curiosidade: A sigla regex também é chamada de regexp (regular expression) ou RE.

Para Que Serve Regex?

• Validação

  • E-mail, CPF, telefone, datas, etc.

• Busca

  • Encontrar palavras-chave, padrões ou formatos específicos em textos.

• Substituição

  • Trocar pedaços do texto por outros (ex.: remover espaços extras).

• Extração

  • Pegar apenas partes específicas de uma string (como o domínio de um e-mail).

🧩 Como Usar Regex no Java

No Java, regex está no pacote:

import java.util.regex.*;

Principais classes:

Classe	Função
Pattern	Armazena o padrão regex compilado
Matcher	Permite procurar o padrão em uma string

Exemplos Simples em Java

Procurando uma palavra em um texto

import java.util.regex.*;

public class RegexDemo {
    public static void main(String[] args) {
        String texto = "Hoje é sexta-feira!";
        String regex = "sexta";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(texto);

        if (matcher.find()) {
            System.out.println("Encontrei a palavra: " + matcher.group());
        } else {
            System.out.println("Não encontrei a palavra.");
        }
    }
}

Saída:

Encontrei a palavra: sexta

🔣 Símbolos Essenciais em Regex

Vamos entender agora os símbolos especiais de regex, com exemplos em Java para cada um.

. → Qualquer caractere (menos \n)

String texto = "casa";
System.out.println(texto.matches("c.s.")); // true (casa)

* → Zero ou mais ocorrências

String texto = "aaab";
System.out.println(texto.matches("a*b")); // true

• Casa com:

  • "b"
  • "ab"
  • "aaab"

+ → Uma ou mais ocorrências

String texto = "aaab";
System.out.println(texto.matches("a+b")); // true

• Não casa com “b” sozinho.

? → Zero ou uma ocorrência

String texto = "color";
System.out.println(texto.matches("colou?r")); // true

• Casa com “color” ou “colour”.

^ → Início da string

String texto = "Bom dia!";
System.out.println(texto.matches("^Bom.*")); // true

$ → Fim da string

String texto = "Documento.pdf";
System.out.println(texto.matches(".*\\.pdf$")); // true

[] → Conjunto de caracteres

String texto = "casa";
System.out.println(texto.matches("c[aeiou]sa")); // true

• Casa com “casa”, “cesa”, “cisa” etc.

[^] → Negação

String texto = "c1sa";
System.out.println(texto.matches("c[^aeiou]sa")); // true

• O segundo caractere não pode ser vogal.

{n} → Exatamente n ocorrências

String texto = "aaa";
System.out.println(texto.matches("a{3}")); // true

{n,} → Pelo menos n ocorrências

String texto = "aaaa";
System.out.println(texto.matches("a{2,}")); // true

{n,m} → Entre n e m ocorrências

String texto = "aaa";
System.out.println(texto.matches("a{2,4}")); // true

\\d → Dígito (equivale a [0-9])

String texto = "5";
System.out.println(texto.matches("\\d")); // true

\\w → Letra, dígito ou underscore

String texto = "Java_9";
System.out.println(texto.matches("\\w+")); // true

\\s → Espaço em branco (tab, espaço, quebra de linha)

Agrupamento com ()

Capturar partes específicas:

String texto = "Dia 15/08/2025";
String regex = "Dia (\\d{2})/(\\d{2})/(\\d{4})";

Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(texto);

if (matcher.find()) {
    System.out.println("Dia: " + matcher.group(1));
    System.out.println("Mês: " + matcher.group(2));
    System.out.println("Ano: " + matcher.group(3));
}

Saída:

Dia: 15
Mês: 08
Ano: 2025

🧪 Exemplos Práticos de Regex em Java

1. Validar E-mail

String email = "[e-mail]";
String regex = "\\w+@\\w+\\.\\w+";

System.out.println(email.matches(regex)); // true

2. Verificar CPF

String cpf = "123.456.789-00";
String regex = "\\d{3}\\.\\d{3}\\.\\d{3}-\\d{2}";

System.out.println(cpf.matches(regex)); // true

3. Extrair domínios de e-mails

String texto = "Meu email é [e-mail]";
String regex = "@(\\w+\\.\\w+)";

Matcher m = Pattern.compile(regex).matcher(texto);
if (m.find()) {
    System.out.println("Domínio: " + m.group(1));
}

Saída:

Domínio: email.com

4. Substituir espaços múltiplos por apenas um

String texto = "Nome    Sobrenome";
texto = texto.replaceAll("\\s+", " ");
System.out.println(texto);

Saída:

Nome Sobrenome

Dicas Avançadas

Prefira Pattern e Matcher para buscas complexas ou múltiplas ocorrências.

Em Java, lembre-se sempre que precisa escapar a barra invertida → \ vira \\ na string.

Para ler múltiplas ocorrências num texto:

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("Temos 15 laranjas e 32 maçãs.");
while (m.find()) {
    System.out.println("Número encontrado: " + m.group());
}

Saída:

Número encontrado: 15
Número encontrado: 32

Conclusão

Regex é um superpoder. Se usado com cuidado, economiza centenas de linhas de código ao buscar, extrair ou validar padrões. No Java, a API java.util.regex oferece tudo o que você precisa para manipular textos com eficiência.