Cómo utilizar expresiones regulares en Java
Las expresiones regulares (regex) son patrones utilizados para buscar, validar, extraer o modificar cadenas de texto de forma eficiente. En Java, las regex proporcionan una forma poderosa y flexible de manipular cadenas mediante coincidencias de patrones complejos. Las expresiones regulares pueden ser utilizadas en una variedad de situaciones, como la validación de entradas, la búsqueda de patrones en textos y la extracción de datos.
Java incluye soporte para regex a través de la clase Pattern y Matcher, ambas en el paquete java.util.regex.
Conceptos básicos de Regex en Java
En Java, los patrones regex se definen utilizando la clase Pattern. Para aplicar el patrón a una cadena de texto, utilizamos un objeto Matcher. Estos dos objetos trabajan juntos para buscar coincidencias dentro de un texto y realizar diversas operaciones.
1. Sintaxis básica de regex
La sintaxis de una expresión regular incluye varios caracteres especiales que permiten crear patrones flexibles para buscar o manipular cadenas.
Algunos ejemplos básicos:
-
.: Coincide con cualquier carácter, excepto el salto de línea. -
*: Coincide con cero o más repeticiones del carácter o grupo anterior. -
+: Coincide con una o más repeticiones del carácter o grupo anterior. -
?: Coincide con cero o una repetición del carácter o grupo anterior. -
[abc]: Coincide con cualquier carácter dentro de los corchetes. -
\d: Coincide con un dígito (equivalente a[0-9]). -
\w: Coincide con un carácter de palabra (letras, números o guion bajo).
2. Clases principales para trabajar con Regex en Java
-
Pattern: Esta clase representa una expresión regular compilada. Proporciona métodos para crear patrones y definir reglas de coincidencia.
Pattern pattern = Pattern.compile("regex");-
Matcher: Representa una operación de coincidencia de patrones en una cadena. Esta clase tiene métodos para encontrar coincidencias, reemplazar texto y más.
Matcher matcher = pattern.matcher("cadena de texto");Ejemplos de uso de Regex en Java
1. Búsqueda de patrones en una cadena
Para buscar una secuencia de caracteres específica en una cadena, puedes usar las clases Pattern y Matcher para identificar coincidencias. En el siguiente ejemplo, buscamos todas las ocurrencias de un número en una cadena.
import java.util.regex.*;
public class RegexExample {
public static void main(String[] args) {
String texto = "El valor 123 y el código 456 están disponibles.";
String regex = "\\d+"; // Buscar uno o más dígitos
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(texto);
while (matcher.find()) {
System.out.println("Número encontrado: " + matcher.group());
}
}
}Salida:
Número encontrado: 123
Número encontrado: 4562. Validación de formato
Las regex también son útiles para validar el formato de los datos de entrada. Un ejemplo clásico es la validación de una dirección de correo electrónico.
import java.util.regex.*;
public class EmailValidator {
public static void main(String[] args) {
String email = "usuario@dominio.com";
String regex = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(email);
if (matcher.matches()) {
System.out.println("El correo electrónico es válido.");
} else {
System.out.println("El correo electrónico no es válido.");
}
}
}Explicación del patrón:
-
^[A-Za-z0-9+_.-]+: Coincide con el nombre de usuario (letras, números y algunos caracteres especiales). -
@: Coincide con el símbolo de arroba. -
[A-Za-z0-9.-]+$: Coincide con el dominio.
3. Reemplazo de texto con Regex
Con regex en Java, puedes buscar patrones y reemplazarlos en una cadena usando el método replaceAll del objeto Matcher o directamente desde la clase String. Esto es útil para modificar cadenas basadas en patrones específicos.
public class ReplaceExample {
public static void main(String[] args) {
String texto = "La fecha es 24/09/2024.";
String regex = "\\d{2}/\\d{2}/\\d{4}";
String nuevoTexto = texto.replaceAll(regex, "XX/XX/XXXX");
System.out.println(nuevoTexto);
}
}Salida:
La fecha es XX/XX/XXXX.4. División de cadenas
El método split() de la clase String también admite regex como argumento, lo que te permite dividir cadenas en función de patrones más complejos.
public class SplitExample {
public static void main(String[] args) {
String texto = "palabra1, palabra2; palabra3 palabra4";
String regex = "[,;\\s]+"; // Coincide con comas, puntos y comas, y espacios
String[] palabras = texto.split(regex);
for (String palabra : palabras) {
System.out.println(palabra);
}
}
}Salida:
palabra1
palabra2
palabra3
palabra45. Grupos en expresiones regulares
En las regex, los paréntesis () permiten agrupar partes de un patrón. Los grupos pueden ser referenciados posteriormente y extraídos del texto coincidente.
import java.util.regex.*;
public class GroupExample {
public static void main(String[] args) {
String texto = "El precio es 45.99 USD";
String regex = "(\\d+\\.\\d{2}) (USD|EUR|GBP)"; // Grupo para número decimal y grupo para moneda
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(texto);
if (matcher.find()) {
System.out.println("Precio: " + matcher.group(1)); // Extrae el precio
System.out.println("Moneda: " + matcher.group(2)); // Extrae la moneda
}
}
}Salida:
Precio: 45.99
Moneda: USD
En este ejemplo, matcher.group(1) obtiene el valor numérico, y matcher.group(2) obtiene el símbolo de la moneda (USD).
6. Casos de uso avanzados
a. Extracción de números de teléfono
import java.util.regex.*;
public class PhoneNumberExtractor {
public static void main(String[] args) {
String texto = "Llámanos al (123) 456-7890 o al (987) 654-3210.";
String regex = "\\(\\d{3}\\) \\d{3}-\\d{4}";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(texto);
while (matcher.find()) {
System.out.println("Número de teléfono encontrado: " + matcher.group());
}
}
}b. Validación de contraseñas
public class PasswordValidator {
public static void main(String[] args) {
String password = "A1b@Strong";
String regex = "^(?=.*[A-Z])(?=.*[a-z])(?=.*\\d)(?=.*[@#$%^&+=]).{8,}$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(password);
if (matcher.matches()) {
System.out.println("Contraseña válida.");
} else {
System.out.println("Contraseña no válida.");
}
}
}Este patrón asegura que la contraseña tenga al menos una letra mayúscula, una minúscula, un número, un símbolo especial y al menos 8 caracteres.
Conclusión
Las expresiones regulares en Java son una herramienta poderosa para la manipulación de cadenas. Desde validaciones simples hasta operaciones más complejas como la búsqueda, sustitución y extracción de datos, las regex permiten trabajar de manera eficiente con patrones. A través de la combinación de las clases Pattern y Matcher, junto con los métodos avanzados de la clase String, Java proporciona una manera robusta de realizar estas operaciones.
Jorge García
Fullstack developer