Java Expressões Regulares

Uma expressão regular (em inglês regular expression, apelidada de regex) é um texto que descreve um formato: "cinco dígitos, um hífen e mais três dígitos" é o formato de um CEP. Com ela, o Java responde perguntas como "este texto tem cara de CEP?", "onde estão os números nesta frase?" e "troque todos os espaços repetidos por um só".

Você já conhece os métodos de String e os caracteres especiais como \n; esta aula usa os dois. Os exemplos rodaram no JDK 25 da máquina da Ana, na pasta ~/java.

A ideia antes do código

Quando a Ana olha para 01310-100, ela reconhece um CEP sem pensar: "são 5 números, um tracinho, 3 números". Se alguém escrever 1310-100, ela estranha: falta um número. Ela não decorou todos os CEPs do Brasil; ela conhece o molde.

Uma regex é esse molde escrito numa linguagem que o computador entende. O molde do CEP fica assim:

\d

Um dígito (de digit): qualquer caractere de 0 a 9.

{5}

O item anterior, exatamente 5 vezes.

-

Um hífen de verdade. Letras e símbolos comuns representam eles mesmos.

\d{3}

Mais três dígitos.

Juntando: \d{5}-\d{3}. A regex é uma linguagem pequena e própria, que existe também no grep do Linux, no JavaScript, no Python… O que você aprender aqui vale em quase todo lugar.

1. A primeira regex: String.matches

O jeito mais rápido de usar uma regex é o método matches ("casa com") de qualquer String. Ele devolve true se o texto inteiro se encaixa no molde:

public class Main {
    public static void main(String[] args) {
        String cep = "01310-100";
        System.out.println(cep.matches("\\d{5}-\\d{3}"));
        System.out.println("1310-100".matches("\\d{5}-\\d{3}"));
        System.out.println("01310100".matches("\\d{5}-\\d{3}"));
        System.out.println("01310-100".matches("\\d{5}-?\\d{3}"));
        System.out.println("01310100".matches("\\d{5}-?\\d{3}"));
    }
}

$ javac Main.java && java Main
true
false
false
true
true

Por que "\\d" com duas barras?

Repare que no código está escrito "\\d{5}-\\d{3}", e não \d{5}-\d{3}. Acontece que há duas linguagens aqui, uma dentro da outra:

1. O Java lê o texto entre aspas primeiro. Para o Java, a barra invertida começa um caractere especial (\n é quebra de linha, \" é aspas). Para ter uma barra de verdade dentro de um String, escreve-se \\.
2. Depois a regex recebe o resultado: \d{5}-\d{3}, com uma barra só, que é o que ela queria.

Regra prática: toda barra da regex vira duas barras no código Java. \d → "\\d"; \s → "\\s"; \. → "\\.". Se você esquecer, o javac reclama:

public class Main {
    public static void main(String[] args) {
        System.out.println("12345".matches("\d+"));
    }
}

$ javac Main.java
Main.java:3: error: illegal escape character
        System.out.println("12345".matches("\d+"));
                                             ^
1 error

"Caractere de escape ilegal": o Java não conhece nenhum \d (ele conhece \n, \t, \"…). A setinha aponta para o d. Conserto: "\\d+".

"01310-100".matches("\\d{5}-\\d{3}")

2. Os blocos de uma regex

Toda regex é montada com poucas peças. Não precisa decorar: volte a esta tabela quando precisar. A coluna "no Java" mostra como escrever entre aspas.

$ jshell
jshell> "maçã".matches("\\w+")
$1 ==> false
jshell> "maçã".matches("\\p{L}+")
$2 ==> true

Maiúsculas e minúsculas

Uma regex diferencia maiúsculas de minúsculas: "JAVA".matches("java") é false. Para ignorar a diferença, comece a regex com (?i) (de ignore case): "JAVA".matches("(?i)java") é true.

public class Main {
    public static void main(String[] args) {
        String padrao = "";   // escreva a regex aqui
        String[] placas = { "ABC1D23", "ABC1234", "abc1d23", "BRA2E19" };
        for (String p : placas) {
            System.out.println(p + " -> " + p.matches(padrao));
        }
    }
}

public class Main {
    public static void main(String[] args) {
        String padrao = "[A-Z]{3}\\d[A-Z]\\d{2}";
        String[] placas = { "ABC1D23", "ABC1234", "abc1d23", "BRA2E19" };
        for (String p : placas) {
            System.out.println(p + " -> " + p.matches(padrao));
        }
    }
}

3. Trocar e cortar: replaceAll e split

Alguns métodos de String recebem uma regex no lugar de um texto fixo:

public class Main {
    public static void main(String[] args) {
        String bagunca = "Ana   gosta    de  Java";
        System.out.println(bagunca.replaceAll("\\s+", " "));

        String iso = "2026-10-16";
        System.out.println(iso.replaceAll("(\\d{4})-(\\d{2})-(\\d{2})", "$3/$2/$1"));

        String telefone = "(11) 98765-4321";
        System.out.println(telefone.replaceAll("\\D", ""));

        System.out.println("banana".replaceFirst("a", "A"));
        System.out.println("banana".replace("a", "A"));
    }
}

$ javac Main.java && java Main
Ana gosta de Java
16/10/2026
11987654321
bAnana
bAnAnA

split: cortar por um molde

O split ("dividir") corta o texto em pedaços onde a regex casar, e devolve um array:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String feira = "maçã, banana;uva  kiwi";
        String[] frutas = feira.split("[,;\\s]+");
        System.out.println(Arrays.toString(frutas));
        System.out.println(frutas.length);

        String versao = "25.0.4";
        System.out.println(Arrays.toString(versao.split(".")));
        System.out.println(Arrays.toString(versao.split("\\.")));
    }
}

$ javac Main.java && java Main
[maçã, banana, uva, kiwi]
4
[]
[25, 0, 4]

A regex [,;\s]+ quer dizer "um ou mais caracteres que sejam vírgula, ponto e vírgula ou espaço". Assim, a lista bagunçada virou quatro frutas limpas. Já a linha seguinte é uma armadilha famosa: split(".") devolveu um array vazio. Na regex, o ponto quer dizer "qualquer caractere": todos os caracteres viraram separadores, e o que sobrou foram pedaços vazios, que o split descarta. Para cortar no ponto de verdade, escape-o: split("\\.").

4. Pattern e Matcher: achar pedaços no meio do texto

O matches responde só "sim ou não, para o texto todo". Para procurar pedaços dentro de um texto maior, o Java tem duas classes do pacote java.util.regex:

• Pattern ("padrão"): a regex já compilada, isto é, conferida e preparada para uso. Você cria com Pattern.compile("…").
• Matcher ("casador"): um "leitor" que percorre um texto procurando o padrão. Você cria com padrao.matcher(texto).

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

public class Main {
    public static void main(String[] args) {
        String frase = "Ana comprou 3 maçãs, 12 bananas e pagou 25 reais.";
        Pattern padrao = Pattern.compile("\\d+");
        Matcher m = padrao.matcher(frase);
        while (m.find()) {
            System.out.println("Achei " + m.group() + " nas posições " + m.start() + " a " + m.end());
        }
    }
}

$ javac Main.java && java Main
Achei 3 nas posições 12 a 13
Achei 12 nas posições 21 a 23
Achei 25 nas posições 40 a 42

matches() × find()

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

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        Matcher m1 = p.matcher("Pedido 42");
        System.out.println("matches: " + m1.matches());
        Matcher m2 = p.matcher("Pedido 42");
        System.out.println("find: " + m2.find() + " -> " + m2.group());
        System.out.println("matches em \"42\": " + p.matcher("42").matches());
    }
}

$ javac Main.java && java Main
matches: false
find: true -> 42
matches em "42": true

matches exige que o texto inteiro seja só dígitos; "Pedido 42" tem letras, então é false. find aceita o pedaço 42 no meio. Use matches para validar e find para procurar.

5. Grupos: separar as partes

Os parênteses de uma regex criam grupos: além de casar, o Java guarda o pedaço que caiu em cada par de parênteses. Eles são numerados da esquerda para a direita, a partir de 1; o grupo 0 é o trecho inteiro. Você também pode dar nomes com (?<nome>…):

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

public class Main {
    public static void main(String[] args) {
        Pattern data = Pattern.compile("(\\d{2})/(\\d{2})/(\\d{4})");
        Matcher m = data.matcher("16/10/2026");
        if (m.matches()) {
            System.out.println("Tudo: " + m.group(0));
            System.out.println("Dia: " + m.group(1));
            System.out.println("Mês: " + m.group(2));
            System.out.println("Ano: " + m.group(3));
        }

        Pattern comNomes = Pattern.compile("(?<dia>\\d{2})/(?<mes>\\d{2})/(?<ano>\\d{4})");
        Matcher m2 = comNomes.matcher("Entrega em 25/12/2026, sem falta.");
        if (m2.find()) {
            System.out.println(m2.group("ano") + "-" + m2.group("mes") + "-" + m2.group("dia"));
        }
    }
}

$ javac Main.java && java Main
Tudo: 16/10/2026
Dia: 16
Mês: 10
Ano: 2026
2026-12-25

Repare que group(1) devolve um String. Para fazer contas, converta com Integer.parseInt (veja wrappers). Para datas de verdade, o Java tem uma ferramenta melhor: java.time. A regex é útil para achar a data no meio de um texto.

6. Validar formatos: CEP, CPF e e-mail

Um uso clássico é conferir se o que o usuário digitou tem o formato certo antes de seguir adiante:

public class Main {
    public static void main(String[] args) {
        String[] cpfs = { "123.456.789-09", "12345678909", "123.456.789-0" };
        for (String c : cpfs) {
            System.out.println(c + " -> " + c.matches("\\d{3}\\.\\d{3}\\.\\d{3}-\\d{2}"));
        }
        String[] ceps = { "01310-100", "0131-0100" };
        for (String c : ceps) {
            System.out.println(c + " -> " + c.matches("\\d{5}-\\d{3}"));
        }
        String[] emails = { "ana@email.com", "ana.souza@loja.com.br", "ana@", "ana email.com" };
        for (String e : emails) {
            System.out.println(e + " -> " + e.matches("[\\w.+-]+@[\\w-]+(\\.[\\w-]+)+"));
        }
    }
}

$ javac Main.java && java Main
123.456.789-09 -> true
12345678909 -> false
123.456.789-0 -> false
01310-100 -> true
0131-0100 -> false
ana@email.com -> true
ana.souza@loja.com.br -> true
ana@ -> false
ana email.com -> false

Formas diferentes de usar regex

Quando dá errado

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("(\\d+");
        System.out.println("não chega aqui");
    }
}

$ javac Main.java && java Main
Exception in thread "main" java.util.regex.PatternSyntaxException: Unclosed group near index 4
(\d+
	at java.base/java.util.regex.Pattern.error(Pattern.java:2205)
	at java.base/java.util.regex.Pattern.accept(Pattern.java:2055)
	at java.base/java.util.regex.Pattern.group0(Pattern.java:3233)
	at java.base/java.util.regex.Pattern.sequence(Pattern.java:2301)
	at java.base/java.util.regex.Pattern.expr(Pattern.java:2246)
	at java.base/java.util.regex.Pattern.compile(Pattern.java:1946)
	at java.base/java.util.regex.Pattern.<init>(Pattern.java:1577)
	at java.base/java.util.regex.Pattern.compile(Pattern.java:1102)
	at Main.main(Main.java:5)

Referência

Exercícios

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

public class Main {
    public static void main(String[] args) {
        String cupom = "Café R$ 4,50; pão R$ 1,25; bolo R$ 12,00";
        int centavos = 0;
        // crie o Pattern, o Matcher e o laço com find()

        System.out.println("Total em centavos: " + centavos);
    }
}

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

public class Main {
    public static void main(String[] args) {
        String cupom = "Café R$ 4,50; pão R$ 1,25; bolo R$ 12,00";
        Pattern preco = Pattern.compile("R\\$ (\\d+),(\\d{2})");
        Matcher m = preco.matcher(cupom);
        int centavos = 0;
        while (m.find()) {
            int reais = Integer.parseInt(m.group(1));
            int cents = Integer.parseInt(m.group(2));
            System.out.println("Preço: " + m.group());
            centavos = centavos + reais * 100 + cents;
        }
        System.out.println("Total em centavos: " + centavos);
    }
}

Saída real da solução:

$ java Main.java
Preço: R$ 4,50
Preço: R$ 1,25
Preço: R$ 12,00
Total em centavos: 1775

Resumo

• Uma regex descreve um formato: \d dígito, [A-Z] faixa, + "um ou mais", {5} "cinco vezes", ( ) grupo.
• No código Java, cada \ da regex vira \\: "\\d+". Esquecer dá illegal escape character.
• matches valida o texto inteiro; Matcher.find procura pedaços; group separa as partes.
• replaceAll, replaceFirst e split aceitam regex; replace não. Cuidado com . e $.
• Regex confere formato (CEP, CPF, e-mail), não validade.
• Regex inválida só é descoberta ao rodar: PatternSyntaxException.

Próxima aula: Anotações.