Java Academy · Aula

Compilando padrões

Pattern.compile e Matcher.

Compilando padrões é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O par de padrão e correspondedor

As expressões regulares de Java ficam em java.util.regex. Um Pattern é uma expressão regular compilada; um Matcher aplica esse padrão a uma entrada específica.

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

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        Matcher m = p.matcher("abc123");
        System.out.println(m.find());
    }
}

Compilação única, reutilização frequente

Pattern.compile é relativamente custoso. Compile um padrão uma única vez e reutilize-o em várias entradas, em vez de recompilá-lo em um laço.

import java.util.regex.Pattern;

public class Main {
    static final Pattern DIGITS = Pattern.compile("\\d+");

    public static void main(String[] args) {
        System.out.println(DIGITS.matcher("a1").find());
        System.out.println(DIGITS.matcher("bb").find());
    }
}

Escapando barras invertidas em Java

Tokens de expressões regulares como \d precisam de uma barra invertida, mas as cadeias de caracteres Java também usam a barra invertida para escapes. Portanto, no código-fonte, escreva \\d para representar a expressão regular \d.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern word = Pattern.compile("\\w+");
        System.out.println(word.matcher("hello").matches());
    }
}

Criando um objeto de correspondência

pattern.matcher(input) associa o padrão a uma cadeia de entrada e retorna um novo objeto de correspondência Matcher que acompanha a posição.

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

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("cat");
        Matcher m = p.matcher("the cat sat");
        System.out.println(m.find());
    }
}

Objetos de correspondência têm estado

Um objeto de correspondência mantém um estado mutável (posição atual, última correspondência). Crie um novo objeto para cada entrada; não compartilhe um entre diferentes linhas de execução.

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

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d");
        Matcher m = p.matcher("a1b2");
        System.out.println(m.find());
        System.out.println(m.find());
    }
}

Sinalizador que ignora maiúsculas e minúsculas

Passe os sinalizadores como segundo argumento para compile. Pattern.CASE_INSENSITIVE ignora a diferença entre maiúsculas e minúsculas.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
        System.out.println(p.matcher("I love JAVA").find());
    }
}

Combinando sinalizadores

Combine os sinalizadores com o operador OR bit a bit. Aqui, adicionamos MULTILINE para que as âncoras correspondam em cada linha.

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

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("^a", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
        Matcher m = p.matcher("apple\nApricot");
        int count = 0;
        while (m.find()) count++;
        System.out.println(count);
    }
}

O atalho estático matches

Pattern.matches(regex, input) é um recurso auxiliar de uso único que compila e testa em uma única chamada. É conveniente, mas recompila a expressão todas as vezes.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        System.out.println(Pattern.matches("\\d{3}", "123"));
        System.out.println(Pattern.matches("\\d{3}", "12"));
    }
}

Dividindo com um padrão

Um Pattern compilado pode dividir cadeias de caracteres por meio de split, reutilizando a mesma expressão regular compilada de forma eficiente.

import java.util.Arrays;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern comma = Pattern.compile("\\s*,\\s*");
        String[] parts = comma.split("a, b ,c,  d");
        System.out.println(Arrays.toString(parts));
    }
}

Inspecionando o padrão

pattern() retorna a cadeia de caracteres original da expressão regular, e flags() retorna os sinalizadores ativos como um número inteiro.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("[a-z]+", Pattern.CASE_INSENSITIVE);
        System.out.println(p.pattern());
        System.out.println(p.flags());
    }
}

Padrões inválidos lançam exceções

Uma expressão regular malformada lança PatternSyntaxException no momento da compilação, permitindo que você detecte os erros antecipadamente.

import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class Main {
    public static void main(String[] args) {
        try {
            Pattern.compile("[unclosed");
        } catch (PatternSyntaxException e) {
            System.out.println("Invalid regex");
        }
    }
}

Verificação rápida

Por que você deve compilar uma expressão regular usada com frequência em um campo estático Pattern?

Recapitulação

Você compilou padrões:

Pattern.compile cria um padrão reutilizável, imutável e seguro para uso concorrente; matcher associa-o a uma entrada.
Faça o escape das barras invertidas das expressões regulares como \\ no código-fonte Java.
Sinalizadores como CASE_INSENSITIVE e MULTILINE são combinados com OR bit a bit.
Matcher mantém estado, portanto crie um para cada entrada.

Perguntas Frequentes

A aula “Compilando padrões” é grátis?

Sim — o texto completo de “Compilando padrões” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Compilando padrões”?

Pattern.compile e Matcher. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Compilando padrões”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy