Probador de RegEx para Java

Probador de Regex para Java

El Probador de Regex para Java de Qodex ayuda a los desarrolladores a escribir, probar y depurar expresiones regulares en tiempo real utilizando el paquete java.util.regex de Java. Admite pruebas instantáneas de patrones para correos electrónicos, contraseñas, números de teléfono, fechas, tarjetas de crédito y más.

Puede ver resultados de coincidencias en vivo, grupos de captura y retroalimentación de sintaxis al instante, facilitando el refinamiento de su regex antes de usarlo en código Java.

Nota Importante: Esta herramienta se ejecuta en el navegador utilizando el motor de regex de JavaScript, que difiere del java.util.regex de Java en varias formas. Diferencias clave a tener en cuenta:

• Los cuantificadores posesivos (*+, ++, ?+) son compatibles con Java pero no con JavaScript

• Los grupos atómicos ((?>...)) funcionan en Java pero no en JavaScript

• Las clases de propiedades Unicode como \p{IsGreek} o \p{Sc} tienen un soporte más amplio en Java

• La sintaxis de referencia inversa difiere en cadenas de reemplazo: Java usa $1, JavaScript usa $1 (igual), pero Java también admite \1 en el patrón

• Banderas: Java admite Pattern.CANON_EQ y Pattern.UNIX_LINES que no tienen equivalente en JS

Para código Java de producción, verifique siempre los patrones usando Pattern.compile() en su IDE o un entorno de ejecución Java.

Cómo Usar:

1. Ingrese su expresión regular.

2. Proporcione una cadena de prueba.

3. Vea al instante las coincidencias resaltadas y los grupos de captura.

¿Necesita entradas de prueba? Pruebe nuestros:

• Generador de Correo Electrónico

• Generador de UUID

• Generador de Número de Teléfono

• Generador de Contraseñas

Referencia Rápida de Regex para Java / Hoja de Trucos

Marque esta tabla para búsquedas rápidas al escribir patrones regex de Java:

Fundamentos de la Sintaxis Regex para Java

Metacaracteres

• .: Coincide con cualquier carácter excepto caracteres de nueva línea. Se usa comúnmente para representar cualquier carácter comodín.

• ^: Ancla la coincidencia al inicio de una línea o cadena. Ejemplo: ^abc coincide con abc solo si está al inicio.

• $: Ancla la coincidencia al final de una línea o cadena. Ejemplo: xyz$ coincide con xyz solo al final.

• |: Actúa como operador lógico OR. Ejemplo: cat|dog coincide con cat o dog.

Clases de Caracteres

• [abc]: Coincide con cualquiera de los caracteres: a, b o c.

• [^abc]: Coincide con cualquier carácter excepto a, b o c.

• [a-zA-Z]: Especifica un rango, coincide con cualquier letra mayúscula o minúscula de la a a la z.

Clases de Caracteres Predefinidas

• \d: Coincide con cualquier dígito; equivalente a [0-9].

• \D: Coincide con cualquier carácter que no sea un dígito; equivalente a [^0-9].

• \s: Coincide con cualquier espacio en blanco (espacio, tabulador, nueva línea).

• \S: Coincide con cualquier carácter que no sea espacio en blanco.

• \w: Coincide con cualquier carácter de palabra (letras, dígitos o guión bajo); equivalente a [a-zA-Z0-9_].

• \W: Coincide con cualquier carácter que no sea un carácter de palabra.

Cuantificadores

• *: Coincide con el elemento anterior cero o más veces. Ejemplo: lo*l coincide con ll, lol, lool, etc.

• +: Coincide con una o más ocurrencias. Ejemplo: lo+l coincide con lol, lool, pero no con ll.

• ?: Coincide con cero o una ocurrencia. También hace que los cuantificadores sean perezosos cuando se coloca después de ellos.

• {n}: Coincide exactamente con n ocurrencias. Ejemplo: a{3} coincide con aaa.

• {n,}: Coincide con n o más ocurrencias.

• {n,m}: Coincide entre n y m ocurrencias.

Grupos y Captura

• (abc): Captura y agrupa la coincidencia para abc. Puede reutilizarse con referencias inversas.

• (?:abc): Agrupa abc sin capturarlo. Útil para aplicar cuantificadores sin crear referencias.

• (?i)abc: Habilita la coincidencia sin distinción entre mayúsculas y minúsculas para el grupo.

• \b: Un límite de palabra.

• \B: Un límite que no es de palabra.

• \1, \2, etc.: Referencias inversas a grupos capturados. Ejemplo: (\w+)\s\1 coincide con palabras repetidas como hello hello.

Aserciones Lógicas (Anticipaciones y Retrospecciones)

• (?=...): Anticipación positiva. Garantiza que lo que sigue a la posición actual coincida con el patrón interno. Ejemplo: \d(?=px) coincide con un dígito solo si va seguido de px.

• (?!...): Anticipación negativa. Garantiza que los caracteres siguientes no coincidan con el patrón. Ejemplo: foo(?!bar) coincide con foo solo si no va seguido de bar.

• (?<=...): Retrospección positiva. Garantiza que lo que precede a la posición actual coincida con el patrón. Ejemplo: (?<=@)\w+ coincide con el nombre de usuario después de un @.

• (?<!...): Retrospección negativa. Garantiza que lo que precede no sea una coincidencia.

Cuantificadores Codiciosos vs. Perezosos

• *?: Coincide con el menor número posible, cero o más veces.

• +?: Coincide con el menor número posible, una o más veces.

• ??: Coincide con el menor número posible, cero o una vez.

• {n,m}?: Coincide entre n y m veces, eligiendo la coincidencia más pequeña posible.

Los cuantificadores perezosos son útiles cuando intenta evitar consumir demasiado texto, especialmente útil para etiquetas anidadas o delimitadores repetidos.

Soporte Unicode

• \p{L}: Coincide con cualquier tipo de letra de cualquier idioma.

• \p{N}: Coincide con cualquier tipo de carácter numérico.

• \p{IsGreek}: Coincide con cualquier carácter del bloque Unicode griego.

• \P{...}: El inverso de \p{...}.

Las propiedades Unicode permiten que su regex funcione globalmente: ideal para aplicaciones internacionales.

Ejemplos Comunes de Regex para Java

Cada ejemplo a continuación incluye código Java completo y ejecutable que puede copiar en su IDE.

1. Validación de Correo Electrónico

Use con el Validador de Regex de Correo Electrónico para Java

import java.util.regex.*;
public class EmailValidator {
public static void main(String[] args) {
String email = "test@example.com";
Pattern pattern = Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$");
Matcher matcher = pattern.matcher(email);
System.out.println("Email valid: " + matcher.matches()); // true
}
}

2. Verificación de Contraseña Segura

Pruebe con el Validador de Regex de Contraseña para Java

import java.util.regex.*;
public class PasswordValidator {
public static void main(String[] args) {
String password = "Str0ng@Pass!";
String regex = "(?=.[a-z])(?=.[A-Z])(?=.\d)(?=.[@$!%?&])[A-Za-z\d@$!%?&]{8,}";
boolean isStrong = password.matches(regex);
System.out.println("Password strong: " + isStrong); // true
}
}

3. Formatos de Número de Teléfono

Cubre (123) 456-7890, 1234567890, 123-456-7890:

import java.util.regex.*;
public class PhoneValidator {
public static void main(String[] args) {
String[] phones = {"(123) 456-7890", "1234567890", "123-456-7890"};
Pattern pattern = Pattern.compile(
"^(\d{10}|\(\d{3}\)[\s.-]?\d{3}[\s.-]\d{4}|\d{3}[\s.-]\d{3}[\s.-]\d{4})$"
);
for (String phone : phones) {
System.out.println(phone + " valid: " + pattern.matcher(phone).matches());
}
}
}

4. Coincidencia de Patrón de Tarjeta de Crédito (Visa)

Use el Validador de Regex de Tarjeta de Crédito para Java con verificación Luhn para validación completa.

import java.util.regex.*;
public class CreditCardValidator {
public static void main(String[] args) {
String card = "4111111111111111";
Pattern visa = Pattern.compile("^4[0-9]{12}(?:[0-9]{3})?$");
System.out.println("Visa valid: " + visa.matcher(card).matches()); // true
}
}

5. Formatos de Fecha (ISO / EE.UU.)

El regex verifica solo el formato. Use las bibliotecas de fecha de Java para validación de calendario (por ejemplo, años bisiestos).

import java.util.regex.*;
public class DateValidator {
public static void main(String[] args) {
String isoDate = "2024-12-25";
String usDate = "12/25/2024";
    Pattern isoPattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
    Pattern usPattern = Pattern.compile("\\d{2}/\\d{2}/\\d{4}");

    System.out.println("ISO valid: " + isoPattern.matcher(isoDate).matches()); // true
    System.out.println("US valid: " + usPattern.matcher(usDate).matches());     // true
}

}

6. Extraer Nombre de Archivo de una Ruta de Windows

import java.util.regex.*;
public class FilenameExtractor {
public static void main(String[] args) {
String path = "C:\Users\Bob\Documents\presentation_final.pptx";
Pattern pattern = Pattern.compile("[^\\]+$");
Matcher matcher = pattern.matcher(path);
if (matcher.find()) {
System.out.println("Filename: " + matcher.group()); // presentation_final.pptx
}
}
}

7. Validación de Dirección IPv4

import java.util.regex.*;
public class IPv4Validator {
public static void main(String[] args) {
String ip = "192.168.1.1";
String regex = "^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$";
System.out.println(ip + " valid: " + ip.matches(regex)); // true
    String badIp = "999.999.999.999";
    System.out.println(badIp + " valid: " + badIp.matches(regex)); // false
}

}

8. Validación de Formato de Hora en 24 Horas (HH:MM)

import java.util.regex.*;
public class TimeValidator {
public static void main(String[] args) {
String[] times = {"14:45", "09:02", "24:00", "00:00"};
Pattern pattern = Pattern.compile("^([01]\d|2[0-3]):[0-5]\d$");
for (String time : times) {
System.out.println(time + " valid: " + pattern.matcher(time).matches());
}
// 14:45 valid: true
// 09:02 valid: true
// 24:00 valid: false
// 00:00 valid: true
}
}

9. Validar Colores Hexadecimales

import java.util.regex.*;
public class HexColorValidator {
public static void main(String[] args) {
String[] colors = {"#1a2B3c", "123", "#ABCDEF", "#zzz", "FFF0A"};
Pattern hexPattern = Pattern.compile("^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$");
for (String color : colors) {
Matcher matcher = hexPattern.matcher(color);
System.out.println(color + " is valid hex: " + matcher.matches());
}
}
}

10. Patrones de SSN / ZIP

Solo verificación de formato. Use estos patrones:

import java.util.regex.*;
public class FormatValidator {
public static void main(String[] args) {
// SSN: 123-45-6789 or 123456789
String ssn = "123-45-6789";
System.out.println("SSN valid: " + ssn.matches("^\d{3}-?\d{2}-?\d{4}$")); // true
    // ZIP+4: 12345 or 12345-6789
    String zip = "12345-6789";
    System.out.println("ZIP valid: " + zip.matches("^\\d{5}(-\\d{4})?$")); // true

    // Canadian Postal Code: A1B 2C3
    String postal = "K1A 0B1";
    System.out.println("Postal valid: " + postal.matches(
        "^[ABCEGHJ-NPRSTVXY]\\d[ABCEGHJ-NPRSTV-Z]\\s?\\d[ABCEGHJ-NPRSTV-Z]\\d$"
    )); // true
}

}

11. Eliminar Etiquetas HTML de una Cadena

import java.util.regex.*;
public class HtmlStripper {
public static void main(String[] args) {
String html = "<p>Hello <b>World</b></p>";
String cleaned = html.replaceAll("<[^>]+>", "");
System.out.println(cleaned); // Hello World
}
}

12. Eliminar Líneas en Blanco de una Cadena

import java.util.regex.*;
public class BlankLineRemover {
public static void main(String[] args) {
String messyText = "Line one.\n\n\nLine two after blanks.\n\nLine three.";
String cleaned = messyText.replaceAll("(?m)^\s*$\n+", "");
System.out.println(cleaned);
// Line one.
// Line two after blanks.
// Line three.
}
}

13. Validar Notación de Pies y Pulgadas

import java.util.regex.*;
public class HeightValidator {
public static void main(String[] args) {
String[] heights = {"6'2"", "5'11"", "0'0"", "6'13""};
Pattern pattern = Pattern.compile("^\d+'(\d|1[01])"$");
for (String h : heights) {
System.out.println(h + " valid: " + pattern.matcher(h).matches());
}
// 6'2" valid: true
// 5'11" valid: true
// 0'0" valid: true
// 6'13" valid: false
}
}

Patrones Comunes para Validación de Números

Las expresiones regulares son invaluables para validar y analizar números en varios formatos. Estos son los patrones utilizados con más frecuencia:

Consejos Importantes

• Siempre escape los caracteres regex dos veces en cadenas Java (por ejemplo, \. para coincidir con un punto literal).

• Prefiera grupos sin captura a menos que necesite referencias.

• Evite usar regex para analizar formatos estructurados como JSON, HTML o XML: use parsers en su lugar.

• Use Pattern.compile() una vez y reutilice los patrones compilados para un mejor rendimiento.

• Use [\s\S] en lugar de . para la coincidencia multilínea cuando se necesita el modo DOTALL.

Pruebe Más Patrones Regex en Java:

• Validador de Regex de Correo Electrónico para Java

• Validador de Regex de Contraseña para Java

• Validador de Regex de Número de Teléfono para Java

• Validador de Regex de Tarjeta de Crédito para Java

• Validador de Regex de UUID para Java

• Validador de Regex de Fecha para Java

¿Quiere probar en un idioma diferente? Pruebe nuestros:

• Probador de Regex para JavaScript

• Probador de Regex para Go

• Probador de Regex para Python