Programación 1º – UD6 – Expresiones regulares

¿Qué son las expresiones regulares?

Las expresiones regulares (o regex) son una herramienta para describir patrones en las cadenas de texto.
Sirven para verificar si un texto cumple con una estructura determinada o para buscar y extraer partes del texto. Por ejemplo: Verificar si un correo electrónico tiene el formato adecuado; Comprobar si un DNI es correcto.

Símbolos básicos en Expresiones Regulares

¿Qué son Pattern y Matcher?

Cuando quieres trabajar con expresiones regulares en Java, necesitas dos clases principales que vienen del paquete java.util.regex:

Ejemplo:

import java.util.regex.*;

public class EjemploRegex {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("[01]+"); // patrón: uno o más ceros o unos
        Matcher m = p.matcher("00001010");    // cadena a comprobar
        
        if (m.matches())
            System.out.println("Sí, contiene el patrón");
        else
            System.out.println("No, no contiene el patrón");
    }
}

¿Cómo usar las clases Pattern y Matcher ?

Paso 1: Crear un Pattern a partir de la expresión regular (es decir, preparar el “molde”).

Pattern p = Pattern.compile("a+b");  // Buscamos una o más "a" seguidas de una "b"

Paso 2: Crear un Matcher usando el Pattern y la cadena de texto.

Matcher m = p.matcher("aaab");

Paso 3: Usar métodos del Matcher para comprobar si encaja o buscar coincidencias.

System.out.println(m.matches()); // true

Métodos importantes de Matcher

Ejemplo:

import java.util.regex.*;

public class EjemploRegex {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("[0-9]+");
        Matcher m = p.matcher("abc1234xyz");

        System.out.println(m.matches());    // false, NO toda la cadena son números
        System.out.println(m.find());       // true, encontró "1234"
        System.out.println(m.group());      // imprime "1234"
        
        Matcher m2 = p.matcher("1234abc");
        System.out.println(m2.lookingAt()); // true, empieza con números
    }
}

Grupos en Expresiones Regulares

Los paréntesis ( ) sirven para crear grupos en la expresión:

• Permiten capturar partes específicas de una coincidencia.
• Cada grupo tiene un número (grupo 1, grupo 2, etc).

Ejemplo:

import java.util.regex.*;

public class GruposRegex {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("([XY]?)([0-9]{1,9})([A-Za-z])");
        Matcher m = p.matcher("X123456789Z Y00110011M 999999T");
        
        while (m.find()) {
            System.out.println("Letra inicial (opcional): " + m.group(1));
            System.out.println("Número: " + m.group(2));
            System.out.println("Letra final: " + m.group(3));
        }
    }
}

¿Qué hace este código?

• Encuentra cada DNI o NIE en el texto.
• Extrae:
  • La letra inicial (grupo 1).
  • El número (grupo 2).
  • La letra final (grupo 3).

Secuencias de Escape

Caracteres como (, [, ], . normalmente tienen un significado especial. Si quieres buscarlos como texto normal, debes escaparlos usando \\.

Ejemplo:

import java.util.regex.*;

public class EjemploEscape {
    public static void main(String[] args) {
        // Crear un patrón con secuencias de escape para caracteres especiales
        String texto = "Este es un ejemplo con caracteres especiales: (abc), [def], a.b y (xyz).";
        
        // Definir las expresiones regulares con las secuencias de escape
        Pattern p1 = Pattern.compile("\\(abc\\)");  // Busca "(abc)"
        Pattern p2 = Pattern.compile("\\[def\\]");  // Busca "[def]"
        Pattern p3 = Pattern.compile("a\\.b");      // Busca "a.b"
        Pattern p4 = Pattern.compile("\\(xyz\\)");  // Busca "(xyz)"
        
        // Crear Matcher para cada patrón
        Matcher m1 = p1.matcher(texto);
        Matcher m2 = p2.matcher(texto);
        Matcher m3 = p3.matcher(texto);
        Matcher m4 = p4.matcher(texto);
        
        // Verificar si los patrones se encuentran en el texto
        if (m1.find()) {
            System.out.println("Encontrado: " + m1.group());  // Salida esperada: (abc)
        } else {
            System.out.println("No se encontró: (abc)");
        }

        if (m2.find()) {
            System.out.println("Encontrado: " + m2.group());  // Salida esperada: [def]
        } else {
            System.out.println("No se encontró: [def]");
        }

        if (m3.find()) {
            System.out.println("Encontrado: " + m3.group());  // Salida esperada: a.b
        } else {
            System.out.println("No se encontró: a.b");
        }

        if (m4.find()) {
            System.out.println("Encontrado: " + m4.group());  // Salida esperada: (xyz)
        } else {
            System.out.println("No se encontró: (xyz)");
        }
    }
}

Actividades de programación

Actividad 1: Validar una dirección de correo electrónico

Escribe un programa que utilice expresiones regulares para validar la siguiente dirección de correo electrónico: usuario@dominio.com

Actividad 2: Extracción de números de una cadena

Dado un texto que puede contener números, escribe un programa que extraiga todos los números de la cadena y los imprima por separado. Por ejemplo, si la cadena es “Tengo 2 gatos y 3 perros”, el programa debe imprimir “2” y “3”.

Actividad 3: Comprobación de un formato de fecha (DD/MM/YYYY)

Escribe un programa que valide si una fecha (por ejemplo 31/12/2023) tiene el formato correcto DD/MM/YYYY . La expresión regular debe:

• Validar que los días estén entre 01 y 31.
• Validar que los meses estén entre 01 y 12.
• Validar que el año sea un número de 4 dígitos.

Actividad 4: Contar palabras en una cadena

Escribe un programa que cuente cuántas palabras hay en una cadena. (Ejemplo de cadena: El perro corre rápido).

Actividad 5: Búsqueda y reemplazo de texto

Escribe un programa que busque todas las ocurrencias de una palabra en una cadena y la reemplace por otra. Por ejemplo, si el texto es “La bombilla brilla muy fuerte” y la palabra a reemplazar es “bombilla”, el programa debe reemplazarla por “luna” resultando en “La luna brilla muy fuerte”.