Expresiones Regulares
en Java

Sección 01

¿Qué es una expresión regular?

Cuando empecé a investigar este tema me di cuenta de que una expresión regular (o regex) es básicamente un patrón escrito que le dice al programa cómo debe verse un texto para considerarse como válido. Con el mismo patrón puedo validar una entrada, buscar coincidencias dentro de un texto largo o reemplazar partes específicas. Al principio los símbolos pueden parecer confusos, pero después de explorar por un rato con ejemplos pequeños la lógica se vuelve bastante intuitiva.

En Java todo esto vive dentro del paquete java.util.regex, que existe desde Java 1.4. Las dos clases que hay que manipular son Pattern y Matcher, aunque si uno quiere validar de manera rápida está el atajo String.matches(). La documentación oficial describe a Pattern como «una representación compilada de una expresión regular. Una expresión regular, especificada como cadena de texto, debe primero compilarse en una instancia de esta clase» (Oracle, 2024). En términos sencillos: Pattern es la regla ya traducida a algo que la JVM (Java Virtual Machine) entiende bien, y Matcher es el que se encarga de aplicarla sobre el texto que sea que yo le pase.

// Forma rápida con String.matches()
String texto = "Hola123";
boolean resultado = texto.matches("[A-Za-z0-9]+");
System.out.println(resultado); // true

// Forma reutilizable con Pattern y Matcher
Pattern p = Pattern.compile("[A-Za-z0-9]+");
Matcher m = p.matcher(texto);
System.out.println(m.matches()); // true

Sección 02

¿Por qué usar expresiones regulares?

Uno de los aspectos que más me llamó la atención mientras investigaba es que las expresiones regulares tienen muchas aplicaciones, por ejemplo: validando formularios, revisando archivos de texto, leyendo logs, transformando datos o incluso en la búsqueda avanzada en editores de código. No son una herramienta pensada para un solo problema, y esa versatilidad fue lo que vi beneficioso para usarlas en el proyecto de KD-Electronics. Además, si tenemos en cuenta el rendimiento, la propia Oracle deja un consejo: «si un patrón va a usarse múltiples veces, compilarlo una vez y reutilizarlo será más eficiente que invocar este método cada vez» (Oracle, 2024). Básicamente, compilar una sola vez con Pattern.compile() y guardar ese objeto es mucho mejor que estar llamando String.matches() en cada validación.

Sección 03

Ventajas para la validación de datos

Aplicándolo al caso de KD-Electronics pude entender el por qué la calidad de los datos importa tanto en un sistema de inventario. Si alguien mete un código mal escrito, un precio con formato raro o una categoría con caracteres que no deberían estar ahí, eso puede dañar reportes, tronar integraciones externas o dejar la base de datos llena de basura difícil de limpiar después. Es por eso veo las regex como una especie de guardia de segurida, ya que antes de que el dato llegue siquiera a la capa de negocio, éste decide si entra o se devuelve con un error claro.

Sección 04

Caso KD-Electronics

KD-Electronics requiere un módulo CRUD de productos con los campos: código de producto, nombre, descripción, precio base, precio de venta, categoría y cantidad disponible. El delete es lógico (no físico) y el read filtra por código de producto.

A continuación se presentan cada campo con su regla de negocio, la expresión regular correspondiente y su implementación en Java.

Sección 05

Clase validadora en Java

Para cerrar, junté todas las expresiones regulares en una sola clase ValidadorProducto. Así cada campo del CRUD tiene su propio método y puedo llamarlos desde cualquier parte del proyecto sin repetir el patrón.

// Ejemplo completo: validar todos los campos del producto
public class ValidadorProducto {

    private static final String REGEX_CODIGO   = "^KD-[A-Z0-9]{4,8}$";
    private static final String REGEX_NOMBRE    = "^[A-Za-záéíóúÁÉÍÓÚñÑ\\s]{3,100}$";
    private static final String REGEX_DESC      = "^[\\s\\S]{10,500}$";
    private static final String REGEX_PRECIO    = "^[1-9]\\d*(\\.\\d{1,2})?$";
    private static final String REGEX_CATEGORIA = "^[A-Za-záéíóúÁÉÍÓÚñÑ\\s]{3,50}$";
    private static final String REGEX_CANTIDAD  = "^\\d+$";

    public static boolean validarCodigo(String v)    { return v.matches(REGEX_CODIGO); }
    public static boolean validarNombre(String v)    { return v.matches(REGEX_NOMBRE); }
    public static boolean validarDescripcion(String v){ return v.matches(REGEX_DESC); }
    public static boolean validarPrecio(String v)    { return v.matches(REGEX_PRECIO); }
    public static boolean validarCategoria(String v)  { return v.matches(REGEX_CATEGORIA); }
    public static boolean validarCantidad(String v)  { return v.matches(REGEX_CANTIDAD); }
}

Sección 06

Referencias

Fuentes bibliográficas y documentación consultada para la elaboración de este blog, citadas en formato APA.

1. Oracle. (2024). Class Pattern. Java SE 21 Documentation. https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/regex/Pattern.html
2. Stack Overflow contributors. (2019). Learning JDBC. Riptutorial. https://riptutorial.com/java
3. Toro, M. (2022). Fundamentos de programación: Java. Editorial Universidad de Sevilla.
4. Autentia. (2020). Back. Introducción al Backend y Java. Primera parte. Guía para directivos y técnicos.