Classes de Caracteres em Regex Java

Uma classe de caracteres é a parte de uma expressão regular que corresponde a um caractere de um conjunto de caracteres permitidos. Sempre que você escreve \d, [aeiou] ou [^0-9], está usando uma classe de caracteres. Elas são o menor bloco de construção de quase todo padrão útil, e o motor java.util.regex do Java oferece três tipos: atalhos prontos como \d, conjuntos personalizados definidos em [...], e classes nomeadas com suporte a Unicode como \p{Lower}. Domine esses e o restante do regex se encaixará no lugar.

Este capítulo cobre os três tipos — classes de colchetes personalizadas com intervalos e negação, os atalhos predefinidos, operações de conjunto (união, interseção, subtração) e classes nomeadas Unicode/POSIX — e depois os une em um programa executável. Se você é novo em regex Java, comece pela introdução ao regex e pela sintaxe de regex primeiro.

Classes personalizadas: colchetes, intervalos e negação

A classe de colchetes [...] corresponde a qualquer caractere único listado dentro dela. Escreva os caracteres um por um ou use um hífen para expressar um intervalo. Coloque ^ logo após o colchete de abertura para negar o conjunto — corresponder a qualquer caractere que não esteja listado.

"[abc]"      // matches one 'a', 'b', or 'c'
"[a-z]"      // any one lowercase letter (a range)
"[A-Za-z0-9]"// any letter or digit (three ranges in one class)
"[^aeiou]"   // any single character that is NOT a vowel

Dentro de uma classe, a maioria dos metacaracteres perde seu significado especial, então raramente é necessário escapá-los. Um ], ^, - ou \ literal é a exceção — escape esses, ou posicione-os de forma que não possam ser interpretados erroneamente (um - no início ou no fim é um hífen literal, não um intervalo).

java.util.regex.Pattern p = java.util.regex.Pattern.compile("[-+0-9]");
System.out.println(p.matcher("-").find());   // true: leading - is literal
System.out.println(p.matcher("*").find());   // false

Classes predefinidas: os atalhos

O Java fornece atalhos para os conjuntos que você usa constantemente. Cada forma em minúsculas tem um complemento em maiúsculas que corresponde a tudo que a forma em minúsculas não corresponde.

Atalho	Corresponde	Classe equivalente
`.`	qualquer caractere exceto terminadores de linha	—
`\d`	um dígito	`[0-9]`
`\D`	um não-dígito	`[^0-9]`
`\w`	um caractere de palavra	`[a-zA-Z_0-9]`
`\W`	um caractere não-palavra	`[^a-zA-Z_0-9]`
`\s`	um caractere de espaço em branco	`[ \t\n\x0B\f\r]`
`\S`	um caractere não-espaço em branco	`[^\s]`

Aviso

No código-fonte Java, a própria barra invertida deve ser escapada, então o regex \d é escrito como "\\d" em um literal de string, e \w se torna "\\w". Esquecer a segunda barra invertida é o erro mais comum em regex Java — "\d" nem mesmo compila.

String digits = "\\d+";          // regex is \d+  (one or more digits)
String word   = "\\w+";          // regex is \w+
"abc123".replaceAll("\\d", "#"); // "abc###"

Negação vs. interseção vs. união

Uma classe de colchetes é uma união por padrão — liste [abcxyz] e você corresponde a qualquer um dos seis. O Java adiciona dois operadores de conjunto dentro de classes. O operador && forma uma interseção (corresponde apenas a caracteres em ambos os conjuntos), e aninhar uma classe dentro de outra permite subtrair.

Construção	Significado
`[a-d[m-p]]`	união: `a`–`d` ou `m`–`p`
`[a-z&&[aeiou]]`	interseção: letras minúsculas que são vogais
`[a-z&&[^aeiou]]`	subtração: letras minúsculas que não são vogais (consoantes)

"[a-z&&[^aeiou]]"  // all lowercase consonants
"[\\p{L}&&[^\\p{Lu}]]" // any letter that is not uppercase

A negação com ^ inverte uma classe inteira; a interseção com && a restringe. Escolher a opção correta mantém os padrões legíveis em vez de acumular alternativas.

Classes nomeadas Unicode e POSIX

Para qualquer coisa além do ASCII, use a família \p{...}. Essas classes nomeadas conhecem categorias Unicode e grupos no estilo POSIX, e \P{...} é a forma negada. Elas são essenciais quando sua entrada contém letras acentuadas, scripts não-latinos, ou quando você simplesmente quer nomes que revelem a intenção.

Classe	Corresponde
`\p{Lower}`	uma letra ASCII minúscula (`[a-z]`)
`\p{Punct}`	um caractere de pontuação
`\p{Alnum}`	uma letra ASCII ou dígito
`\p{L}`	qualquer letra Unicode (com `UNICODE_CHARACTER_CLASS`)
`\p{IsDigit}`	um dígito Unicode

// Make \w, \d, \s honor full Unicode, not just ASCII:
java.util.regex.Pattern uni =
    java.util.regex.Pattern.compile("\\w+", java.util.regex.Pattern.UNICODE_CHARACTER_CLASS);
System.out.println(uni.matcher("café").results().count()); // 1: "café" is one word

Um exemplo prático: todos os tipos de classes em uma string

Este programa cria um pequeno auxiliar, count, que relata quantos caracteres de uma string de exemplo uma classe de um único caractere corresponde. Executar a mesma string através de dígito, palavra, espaço em branco, intervalo, negação, interseção, o ponto e uma classe POSIX torna os relacionamentos entre eles concretos — e mostra uma classe fazendo trabalho real dentro de um padrão maior.

java— editable, runs on the server

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

public class CharClassDemo {
  // Count how many chars of `input` match the single-class `regex`.
  static long count(String regex, String input) {
    return Pattern.compile(regex).matcher(input).results().count();
  }

public static void main(String[] args) {
    String sample = "Order #A7! cost $19.50, ship-by 2026-05-30.";
    System.out.println("sample: " + sample);
    System.out.println();

// 1. Predefined classes: \\d digits, \\w word chars, \\s whitespace.
    System.out.println("\\d (digits)      : " + count("\\d", sample));
    System.out.println("\\w (word chars)  : " + count("\\w", sample));
    System.out.println("\\s (whitespace)  : " + count("\\s", sample));

// 2. A custom set and a range mean the same thing here.
    System.out.println("[0-9] (range)    : " + count("[0-9]", sample));
    System.out.println("[A-Za-z] letters : " + count("[A-Za-z]", sample));

// 3. Negation: [^...] and \\D are complements.
    System.out.println("[^0-9] non-digit : " + count("[^0-9]", sample));
    System.out.println("\\D non-digit     : " + count("\\D", sample));

// 4. Intersection: vowels that are also lowercase letters.
    System.out.println("[a-z&&[aeiou]]   : " + count("[a-z&&[aeiou]]", sample));

// 5. The dot matches any char except line terminators by default.
    System.out.println(". (any char)     : " + count(".", sample));

// 6. A class inside a real pattern: validate a simple SKU like A7.
    Pattern sku = Pattern.compile("[A-Z]\\d");
    Matcher m = sku.matcher(sample);
    if (m.find()) {
      System.out.println("first [A-Z]\\d    : " + m.group());
    }

// 7. POSIX-style \\p classes are Unicode-aware names.
    System.out.println("\\p{Punct} count  : " + count("\\p{Punct}", sample));
  }
}

O que tirar da execução:

\d e [0-9] ambos relatam 13 para esta string — eles são exatamente equivalentes para entrada ASCII. Uma classe predefinida é apenas um nome embutido para um conjunto que você poderia escrever manualmente, então use o atalho para legibilidade.
\D e [^0-9] ambos relatam 30, o complemento dos 13 dígitos em uma string de 43 caracteres (13 + 30 = 43). Um atalho maiúsculo e uma classe de colchetes negada são duas grafias do mesmo complemento.
[a-z&&[aeiou]] relata 3 — apenas as vogais minúsculas, que são o e de Order, o o de cost e o i de ship-by. O O maiúsculo de Order é maiúsculo, então a interseção o exclui. O ponto: && restringe uma classe aos caracteres em ambos os conjuntos em vez de uni-los, então vogais maiúsculas nunca se qualificam.
O ponto correspondeu a 43, cada caractere incluindo espaços e pontuação, porque esta string de uma única linha não tem terminador de linha para o . parar. O ponto é a classe mais ampla de todas, o que é exatamente por que você geralmente o substitui por uma mais restrita.
O padrão [A-Z]\d encontrou A7: classes de caracteres não servem apenas para contagem — combinadas em uma sequência elas validam estrutura, aqui uma letra imediatamente seguida de um dígito. \p{Punct} separadamente encontrou 9 marcas de pontuação, mostrando que as classes POSIX nomeadas funcionam ao lado dos atalhos.

Prática

Em um regex Java, qual classe de caracteres corresponde a qualquer letra minúscula que também é uma vogal?

[a-z&&[aeiou]] — o operador && forma a interseção do intervalo de minúsculas e o conjunto de vogais[a-z||aeiou] — o operador || une os dois conjuntos para que apenas os membros comuns permaneçam[a-z[aeiou]] — aninhar uma classe em outra mantém apenas os caracteres em ambas[^a-z&&aeiou] — o ^ inicial restringe a classe às vogais

Para onde ir a seguir

Uma classe de caracteres corresponde a um caractere; o próximo passo é controlar quantos deles você corresponde e o que fazer com o resultado:

Quantificadores de regex — adicione +, *, ? e {n,m} para que uma classe corresponda a uma sequência de caracteres.
Grupos de captura — envolva uma classe em (...) para extrair uma substring correspondida.
Pattern e Matcher — a API usada em todos os exemplos acima, em profundidade.
Flags de regex — CASE_INSENSITIVE, UNICODE_CHARACTER_CLASS e outros que alteram o comportamento das classes.