Clases de caracteres en regex de Java

Una clase de caracteres es la parte de una expresión regular que coincide con un carácter de un conjunto de caracteres permitidos. Cada vez que escribes \d, [aeiou] o [^0-9], estás usando una clase de caracteres. Son el bloque de construcción más pequeño de casi todos los patrones útiles, y el motor java.util.regex de Java ofrece tres tipos: abreviaciones predefinidas como \d, conjuntos personalizados que se definen en [...], y clases con nombre conscientes de Unicode como \p{Lower}. Dominar estos conceptos hace que el resto de regex encaje perfectamente.

Este capítulo cubre los tres tipos: clases de corchetes personalizadas con rangos y negación, las abreviaciones predefinidas, operaciones de conjuntos (unión, intersección, sustracción) y clases con nombre Unicode/POSIX; luego los combina en un programa ejecutable. Si eres nuevo en regex de Java, comienza primero con la introducción a regex y la sintaxis de regex.

Clases personalizadas: corchetes, rangos y negación

La clase de corchetes [...] coincide con cualquier carácter individual listado en su interior. Especifica los caracteres uno por uno, o usa un guión para expresar un rango. Coloca ^ justo después del corchete de apertura para negar el conjunto: coincide con cualquier carácter que no esté 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 una clase, la mayoría de los metacaracteres pierden su significado especial, por lo que raramente necesitas escaparlos. Un ], ^, - o \ literal es la excepción: escápalos o colócalos de modo que no puedan malinterpretarse (un - al principio o al final es un guión literal, no un rango).

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

Clases predefinidas: las abreviaciones

Java incluye abreviaciones para los conjuntos que se usan con mayor frecuencia. Cada forma en minúscula tiene un complemento en mayúscula que coincide con todo lo que la forma en minúscula no coincide.

Abreviación	Coincide con	Clase equivalente
`.`	cualquier carácter excepto terminadores de línea	—
`\d`	un dígito	`[0-9]`
`\D`	un no-dígito	`[^0-9]`
`\w`	un carácter de palabra	`[a-zA-Z_0-9]`
`\W`	un carácter que no es de palabra	`[^a-zA-Z_0-9]`
`\s`	un carácter de espacio en blanco	`[ \t\n\x0B\f\r]`
`\S`	un carácter que no es espacio en blanco	`[^\s]`

Advertencia

En código fuente Java, la barra invertida debe escaparse, por lo que el regex \d se escribe "\\d" en un literal de cadena, y \w se convierte en "\\w". Olvidar la segunda barra invertida es el error más común en regex de Java: "\d" ni siquiera compilará.

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

Negación vs. intersección vs. unión

Una clase de corchetes es una unión por defecto: lista [abcxyz] y coincidirá con cualquiera de los seis. Java añade dos operadores de conjuntos dentro de las clases. El operador && forma una intersección (coincide solo con los caracteres presentes en ambos conjuntos), y anidar una clase dentro de otra permite la sustracción.

Construcción	Significado
`[a-d[m-p]]`	unión: `a`–`d` o `m`–`p`
`[a-z&&[aeiou]]`	intersección: letras minúsculas que son vocales
`[a-z&&[^aeiou]]`	sustracción: letras minúsculas que no son vocales (consonantes)

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

La negación con ^ invierte una clase completa; la intersección con && la estrecha. Elegir la opción correcta mantiene los patrones legibles en lugar de acumular alternativas.

Clases con nombre Unicode y POSIX

Para cualquier cosa más allá de ASCII, usa la familia \p{...}. Estas clases con nombre conocen las categorías Unicode y los grupos estilo POSIX, y \P{...} es la forma negada. Son esenciales cuando la entrada contiene letras acentuadas, escrituras no latinas, o simplemente quieres nombres que expresen la intención.

Clase	Coincide con
`\p{Lower}`	una letra ASCII en minúscula (`[a-z]`)
`\p{Punct}`	un carácter de puntuación
`\p{Alnum}`	una letra ASCII o dígito
`\p{L}`	cualquier letra Unicode (con `UNICODE_CHARACTER_CLASS`)
`\p{IsDigit}`	un 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

Un ejemplo práctico: todos los tipos de clases en una sola cadena

Este programa construye un pequeño ayudante, count, que reporta cuántos caracteres de una cadena de muestra coinciden con una clase de un solo carácter. Ejecutar la misma cadena con dígito, palabra, espacio en blanco, rango, negación, intersección, el punto y una clase POSIX hace que las relaciones entre ellos sean concretas, y muestra una clase haciendo trabajo real dentro de un patrón más grande.

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));
  }
}

Lo que se puede extraer de la ejecución:

\d y [0-9] ambos reportan 13 para esta cadena: son exactamente equivalentes para entrada ASCII. Una clase predefinida es simplemente un nombre incorporado para un conjunto que podrías escribir a mano, así que usa la abreviación para mayor legibilidad.
\D y [^0-9] ambos reportan 30, el complemento de los 13 dígitos en una cadena de 43 caracteres (13 + 30 = 43). Una abreviación en mayúscula y una clase de corchetes negada son dos formas de escribir el mismo complemento.
[a-z&&[aeiou]] reporta 3: solo las vocales en minúscula, que son la e de Order, la o de cost y la i de ship-by. La O mayúscula de Order queda excluida por la intersección. El punto clave: && estrecha una clase a los caracteres en ambos conjuntos en lugar de unirlos, por lo que las vocales mayúsculas nunca califican.
El punto coincidió con 43, todos los caracteres incluyendo espacios y puntuación, porque esta cadena de una sola línea no tiene terminador de línea en el que . se detenga. El punto es la clase más amplia de todas, razón exacta por la que normalmente lo reemplazas con una más específica.
El patrón [A-Z]\d encontró A7: las clases de caracteres no son solo para contar; combinadas en una secuencia validan la estructura, aquí una letra seguida inmediatamente de un dígito. \p{Punct} por separado encontró 9 signos de puntuación, lo que muestra que las clases POSIX con nombre funcionan junto con las abreviaciones.

Práctica

En un regex de Java, ¿qué clase de caracteres coincide con cualquier letra minúscula que también sea una vocal?

[a-z&&[aeiou]] — el operador && forma la intersección del rango de minúsculas y el conjunto de vocales[a-z||aeiou] — el operador || une los dos conjuntos de modo que solo permanecen los miembros comunes[a-z[aeiou]] — anidar una clase dentro de otra conserva solo los caracteres presentes en ambas[^a-z&&aeiou] — el ^ inicial restringe la clase a las vocales

Qué ver a continuación

Una clase de caracteres coincide con un carácter; el siguiente paso es controlar cuántos de ellos coinciden y qué hacer con el resultado:

Cuantificadores en regex — añade +, *, ? y {n,m} para que una clase coincida con una serie de caracteres.
Grupos de captura — envuelve una clase en (...) para extraer la subcadena coincidente.
Pattern y Matcher — la API usada en todos los ejemplos anteriores, en profundidad.
Banderas de regex — CASE_INSENSITIVE, UNICODE_CHARACTER_CLASS y similares que cambian el comportamiento de las clases.