0Pricing
Java Academy · Lección

Compilación de patrones

Pattern.compile y Matcher

Compilación de patrones es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

La pareja Pattern y Matcher

Las expresiones regulares de Java se encuentran en java.util.regex. Un Pattern es una expresión regular compilada; un Matcher aplica ese patrón a una entrada concreta.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        Matcher m = p.matcher("abc123");
        System.out.println(m.find());
    }
}

Compilar una vez, reutilizar muchas veces

Pattern.compile es relativamente costoso. Compile un patrón una vez y reutilícelo con muchas entradas, en lugar de volver a compilarlo dentro de un bucle.

import java.util.regex.Pattern;

public class Main {
    static final Pattern DIGITS = Pattern.compile("\\d+");

    public static void main(String[] args) {
        System.out.println(DIGITS.matcher("a1").find());
        System.out.println(DIGITS.matcher("bb").find());
    }
}

Escapar barras invertidas en Java

Los tokens de expresiones regulares como \d necesitan una barra invertida, pero las cadenas de Java también usan la barra invertida para las secuencias de escape. Por eso, en el código fuente se escribe \\d para representar la expresión regular \d.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern word = Pattern.compile("\\w+");
        System.out.println(word.matcher("hello").matches());
    }
}

Crear un Matcher

pattern.matcher(input) vincula el patrón a una cadena de entrada y devuelve un Matcher nuevo que realiza el seguimiento de la posición.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("cat");
        Matcher m = p.matcher("the cat sat");
        System.out.println(m.find());
    }
}

Los Matcher tienen estado

Un Matcher contiene estado mutable (la posición actual y la última coincidencia). Cree un matcher nuevo para cada entrada; no comparta uno entre varios hilos.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d");
        Matcher m = p.matcher("a1b2");
        System.out.println(m.find());
        System.out.println(m.find());
    }
}

Bandera sin distinción entre mayúsculas y minúsculas

Pase las banderas como segundo argumento de compile. Pattern.CASE_INSENSITIVE ignora las diferencias entre mayúsculas y minúsculas.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
        System.out.println(p.matcher("I love JAVA").find());
    }
}

Combinar banderas

Combine las banderas con el operador OR a nivel de bits. Aquí añadimos MULTILINE para que las anclas coincidan en cada línea.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("^a", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
        Matcher m = p.matcher("apple\nApricot");
        int count = 0;
        while (m.find()) count++;
        System.out.println(count);
    }
}

El atajo estático matches

Pattern.matches(regex, input) es un método auxiliar de un solo uso que compila y realiza la prueba en una sola llamada. Es práctico, pero vuelve a compilar el patrón cada vez.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        System.out.println(Pattern.matches("\\d{3}", "123"));
        System.out.println(Pattern.matches("\\d{3}", "12"));
    }
}

Dividir con un Pattern

Un Pattern compilado puede dividir cadenas mediante split, reutilizando de forma eficiente la misma expresión regular compilada.

import java.util.Arrays;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern comma = Pattern.compile("\\s*,\\s*");
        String[] parts = comma.split("a, b ,c,  d");
        System.out.println(Arrays.toString(parts));
    }
}

Inspeccionar el Pattern

pattern() devuelve la cadena original de la expresión regular y flags() devuelve las banderas activas como un int.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("[a-z]+", Pattern.CASE_INSENSITIVE);
        System.out.println(p.pattern());
        System.out.println(p.flags());
    }
}

Los patrones no válidos lanzan excepciones

Una expresión regular mal formada lanza PatternSyntaxException durante la compilación, lo que permite detectar los errores pronto.

import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class Main {
    public static void main(String[] args) {
        try {
            Pattern.compile("[unclosed");
        } catch (PatternSyntaxException e) {
            System.out.println("Invalid regex");
        }
    }
}

Comprobación rápida

¿Por qué debería compilar una expresión regular que usa con frecuencia en un campo Pattern estático?

Recapitulación

Ha compilado patrones:

  • Pattern.compile crea un patrón reutilizable, inmutable y seguro para los hilos; matcher lo vincula a una entrada.
  • En el código fuente de Java, escape las barras invertidas de las expresiones regulares como \\.
  • Las banderas como CASE_INSENSITIVE y MULTILINE se combinan con OR a nivel de bits.
  • Matcher tiene estado, por lo que debe crear uno para cada entrada.

Preguntas frecuentes

¿La lección «Compilación de patrones» es gratis?

Sí — el texto completo de «Compilación de patrones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Compilación de patrones»?

Pattern.compile y Matcher Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Compilación de patrones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Compilación de patrones
  2. Búsqueda y coincidencias
  3. Grupos de captura
  4. Reemplazo con expresiones regulares
← Volver a Java Academy