Expresiones Regulares en Java – Inventario KD-Electronics

•     ¿Qué es una expresión regular?

      (EXPRESIONES REGULARES Desde Cero), Son patrones que se usan para analizar cadenas de caracteres, fueron iniciadas en la década de los 50, y popularizadas en los años 60, usadas en ese momento por el análisis de compiladores, las primeras expresiones regulares fueron: “regulares pressures” o “reggae”.

(Expresiones regulares en Java), En Java una expresión regular usada es String con la expresión “regex”, se crean o escriben con letras y números, así también se usan meta caracteres, los meta caracteres se definen como caracteres que tienen un significado especial en la sintaxis de las expresiones regulares.

Por ejemplo:

Para poder crear expresiones regulares en Java se realizan en dos pasos:

1.    Escribir como una cadena cumpliendo la sintaxis de expresiones regulares.

2.    Compilar la cadena en una expresión regular.

Un ejemplo de creación de expresiones regulares es:

Crear una expresión regular creando “Pattern” tipo objeto, seguido a esto se llama a un método estático de la clase “compile” de esta forma:

En la primera línea el primer método toma un argumento: una cadena literal que contiene la expresión regular.

En la segunda línea la expresión regular toma un segundo argumento en donde determina la configuración de coincidencia de patrones.

La clase “Pattern” es un constructor de expresiones regulares, al hacer que “compile” que es un método llame a “Pattern” como un constructor privado de la clase para crear una representación compilada.

La sintaxis de una expresión regular es:

< ( [ { \ ^ - = $ !| } ] ) >

Estos caracteres se combinan con letras, dependiendo la función se pueden dividir en varios grupos:

1)    Estos se usan para coincidir los límites de texto:

2)    Para emparejar clases de caracteres predifinidas:

3)    Para emparejar caracteres de control:

4)    Para emparejar clases de personales:

5)    Para indicar cantidad de caracteres o cuantificadores:

·       ¿Por qué usar expresiones regulares?

Las expresiones regulares ofrecen validación rápida y precisa para una sola línea de código si cumple con el formato requerido.

Permiten mayor control sobre los datos: pueden evitar errores de entrada que pueden causar fallos en la lógica del sistema o resultados inesperados.

Reducen el código repetitivo: reemplazan códigos largos de bloque con validaciones en expresiones compactas. 

Facilitan la búsqueda y extracción de datos pues se usan en patrones específicos dentro de textos, fechas, números o palabras claves.

Compatibilidad con varios lenguajes de programación: Java, Python, JavaScript o C#

·       ¿Qué ventajas proporcionan las expresiones regulares para la validación de datos?

 Las ventajas de las expresiones regulares son:

 Tienen amplio soporte en los distintos lenguajes de programación.

Verificación temprana a errores permiten evitar datos inválidos lleguen a un sistema base de datos, calidad del software y reducen los errores.

Flexibilización y personalización: su adaptabilidad de validar distintos tipos de datos como campos numéricos, cadenas alfanuméricas, limitación de longitud.

● Caso de Estudio:

Descripción de la problemática:

En la empresa KD-Electronics venden productos electrónicos y desean desarrollar un sistema de gestión de inventario. En el módulo de productos se debe realizar un CRUD, es decir, el registro (create) de nuevos productos en el inventario con su código de producto, nombre, descripción, precio base, precio de venta, categoría y cantidad disponible; así mismo, la actualización (update) de todos los campos, excepto el código del producto; en la parte de eliminación (delete) del producto, no se podrá eliminar físicamente y se debe permitir traer consultas (read) por código de producto.

Creación de Clases:

Clase Main:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Inventario inventario = new Inventario();

        Scanner sc = new Scanner(System.in);

        int opcion;

        do {

            System.out.println("\n--- Menú Inventario KD-Electronics ---");

            System.out.println("1. Agregar producto");

            System.out.println("2. Buscar producto");

            System.out.println("3. Actualizar producto");

            System.out.println("4. Eliminar producto");

            System.out.println("5. Listar productos");

            System.out.println("0. Salir");

            System.out.print("Seleccione una opción: ");

            opcion = sc.nextInt(); sc.nextLine();

            switch (opcion) {

                case 1:

                    System.out.print("Código (ej. PROD-1234): ");

                    String codigo = sc.nextLine();

                    if (!inventario.validarCodigo(codigo)) {

                        System.out.println("❌ Código inválido.");

                        break;

                    }

                    System.out.print("Nombre: ");

                    String nombre = sc.nextLine();

                    if (!inventario.validarNombre(nombre)) {

                        System.out.println("❌ Nombre inválido.");

                        break;

                    }

                    System.out.print("Descripción: ");

                    String desc = sc.nextLine();

                    System.out.print("Precio base: ");

                    double pb = sc.nextDouble();

                    System.out.print("Precio venta: ");

                    double pv = sc.nextDouble(); sc.nextLine();

                    System.out.print("Categoría: ");

                    String cat = sc.nextLine();

                    System.out.print("Cantidad: ");

                    int cant = sc.nextInt(); sc.nextLine();

                    Producto nuevo = new Producto(codigo, nombre, desc, pb, pv, cat, cant);

                    if (inventario.agregarProducto(nuevo)) {

                        System.out.println("✅ Producto agregado.");

                    } else {

                        System.out.println("❌ No se pudo agregar (código duplicado o inválido).");

                    }

                    break;

                case 2:

                    System.out.print("Ingrese el código del producto: ");

                    String codBuscar = sc.nextLine();

                    Producto p = inventario.buscarProducto(codBuscar);

                    if (p != null) {

                        System.out.println("✅ Producto encontrado: " + p);

                    } else {

                        System.out.println("❌ Producto no encontrado.");

                    }

                    break;

                case 3:

                    System.out.print("Ingrese el código del producto a actualizar: ");

                    String codAct = sc.nextLine();

                    Producto prodActual = inventario.buscarProducto(codAct);

                    if (prodActual == null) {

                        System.out.println("❌ Producto no encontrado.");

                        break;

                    }

                    System.out.print("Nuevo nombre: ");

                    String newName = sc.nextLine();

                    System.out.print("Nueva descripción: ");

                    String newDesc = sc.nextLine();

                    System.out.print("Nuevo precio base: ");

                    double newPB = sc.nextDouble();

                    System.out.print("Nuevo precio venta: ");

                    double newPV = sc.nextDouble(); sc.nextLine();

                    System.out.print("Nueva categoría: ");

                    String newCat = sc.nextLine();

                    System.out.print("Nueva cantidad: ");

                    int newCant = sc.nextInt(); sc.nextLine();

                    Producto actualizado = new Producto(codAct, newName, newDesc, newPB, newPV, newCat, newCant);

                    inventario.actualizarProducto(codAct, actualizado);

                    System.out.println("✅ Producto actualizado.");

                    break;

                case 4:

                    System.out.print("Ingrese el código del producto a eliminar: ");

                    String codDel = sc.nextLine();

                    if (inventario.eliminarProducto(codDel)) {

                        System.out.println("✅ Producto eliminado.");

                    } else {

                        System.out.println("❌ Producto no encontrado.");

                    }

                    break;

                case 5:

                    inventario.listarProductos();

                    break;

                case 0:

                    System.out.println("Saliendo...");

                    break;

                default:

                    System.out.println("❌ Opción no válida.");

            }

        } while (opcion != 0);

    }

}

Clase Inventario

import java.util.HashMap;

import java.util.regex.Pattern;

public class Inventario {

    private HashMap<String, Producto> productos = new HashMap<>();

    // Expresiones Regulares

    private final Pattern codigoPattern = Pattern.compile("PROD-\\d{4}");

    private final Pattern nombrePattern = Pattern.compile("[A-Za-zÁÉÍÓÚáéíóúñÑ ]{3,}");

    public boolean validarCodigo(String codigo) {

        return codigoPattern.matcher(codigo).matches();

    }

    public boolean validarNombre(String nombre) {

        return nombrePattern.matcher(nombre).matches();

    }

    public boolean agregarProducto(Producto p) {

        if (!validarCodigo(p.getCodigo()) || productos.containsKey(p.getCodigo())) return false;

        productos.put(p.getCodigo(), p);

        return true;

    }

    public Producto buscarProducto(String codigo) {

        return productos.get(codigo);

    }

    public boolean actualizarProducto(String codigo, Producto actualizado) {

        if (!productos.containsKey(codigo)) return false;

        productos.put(codigo, actualizado);

        return true;

    }

    public boolean eliminarProducto(String codigo) {

        if (!productos.containsKey(codigo)) return false;

        productos.remove(codigo);

        return true;

    }

    public void listarProductos() {

        if (productos.isEmpty()) {

            System.out.println("No hay productos en inventario.");

            return;

        }

        for (Producto p : productos.values()) {

            System.out.println(p);

        }

    }

}

Clase Producto

public class Producto {

    private String codigo;

    private String nombre;

    private String descripcion;

    private double precioBase;

    private double precioVenta;

    private String categoria;

    private int cantidad;

    public Producto(String codigo, String nombre, String descripcion, double precioBase, double precioVenta, String categoria, int cantidad) {

        this.codigo = codigo;

        this.nombre = nombre;

        this.descripcion = descripcion;

        this.precioBase = precioBase;

        this.precioVenta = precioVenta;

        this.categoria = categoria;

        this.cantidad = cantidad;

    }

    // Getters y Setters

    public String getCodigo() { return codigo; }

    public String getNombre() { return nombre; }

    public void setNombre(String nombre) { this.nombre = nombre; }

    public String getDescripcion() { return descripcion; }

    public void setDescripcion(String descripcion) { this.descripcion = descripcion; }

    public double getPrecioBase() { return precioBase; }

    public void setPrecioBase(double precioBase) { this.precioBase = precioBase; }

    public double getPrecioVenta() { return precioVenta; }

    public void setPrecioVenta(double precioVenta) { this.precioVenta = precioVenta; }

    public String getCategoria() { return categoria; }

    public void setCategoria(String categoria) { this.categoria = categoria; }

    public int getCantidad() { return cantidad; }

    public void setCantidad(int cantidad) { this.cantidad = cantidad; }

    @Override

    public String toString() {

        return "Código: " + codigo + ", Nombre: " + nombre + ", Descripción: " + descripcion +

               ", Precio Base: $" + precioBase + ", Precio Venta: $" + precioVenta +

               ", Categoría: " + categoria + ", Cantidad: " + cantidad;

    }

}

Clase Validador

import java.util.regex.Pattern;

public class Validador {

    public static boolean validarCodigo(String codigo) {

        return Pattern.matches("PROD-[0-9]{4}", codigo);

    }

    public static boolean validarNombre(String nombre) {

        return Pattern.matches("[A-Za-zÁÉÍÓÚáéíóú\\s]{3,50}", nombre);

    }

    public static boolean validarDescripcion(String descripcion) {

        return descripcion.length() <= 100;

    }

    public static boolean validarPrecio(String precio) {

        return Pattern.matches("\\d+(\\.\\d{1,2})?", precio);

    }

    public static boolean validarCategoria(String categoria) {

        return Pattern.matches("[A-Za-z]{3,20}", categoria);

    }

    public static boolean validarCantidad(String cantidad) {

        return Pattern.matches("\\d+", cantidad);

    }

}

Compilación y Ejecución

Dentro de la clase Validador se encuentran las expresiones regulares que permiten agrupar por patrones de cadenas de caracteres aplicando así el concepto:

Aqui en la clase Inventario se muestra la creación de expresiones regulares usando regex.Pattern:

Así como tambien en la clase Validador nuevamente:

Referencias

·       EXPRESIONES REGULARES Desde Cero, https://www.youtube.com/watch?v=MRKpVxn5fqI.

• Expresiones regulares en Java, https://codegym.cc/es/groups/posts/es.130.expresiones-regulares-en-java   
•  Autentia (2020). Back. Introducción al Backend y Java. Primera parte. Guía para directivos y técnicos.