Java Academy · Lección

Grupos de captura

Extraiga subcadenas coincidentes

Grupos de captura es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 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.

Qué son los grupos de captura

Los paréntesis ( ) de una expresión regular crean grupos de captura. Después de una coincidencia, puede extraer por separado el texto de cada grupo, lo que resulta ideal para analizar datos estructurados.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)-(\\d+)").matcher("42-99");
        if (m.find()) {
            System.out.println(m.group(1));
            System.out.println(m.group(2));
        }
    }
}

El grupo 0 es la coincidencia completa

group(0) (o group()) devuelve todo el texto coincidente. Los grupos numerados comienzan en 1.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)px").matcher("width: 24px");
        if (m.find()) {
            System.out.println(m.group(0));
            System.out.println(m.group(1));
        }
    }
}

Contar grupos

groupCount() indica el número de grupos de captura del patrón (sin contar el grupo 0).

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})").matcher("2026-05-30");
        if (m.find()) System.out.println(m.groupCount());
    }
}

Analizar una fecha

Los grupos de captura facilitan dividir un valor con formato en sus distintas partes.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})").matcher("2026-05-30");
        if (m.matches()) {
            System.out.println("year=" + m.group(1));
            System.out.println("month=" + m.group(2));
            System.out.println("day=" + m.group(3));
        }
    }
}

Grupos con nombre

Asigne un nombre a un grupo con (?<name>...) y recupérelo por su nombre. Esto hace que los patrones sean mucho más legibles.

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

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("(?<user>\\w+)@(?<host>\\w+\\.\\w+)");
        Matcher m = p.matcher("alice@example.com");
        if (m.find()) {
            System.out.println(m.group("user"));
            System.out.println(m.group("host"));
        }
    }
}

Límites de los grupos

start(n) y end(n) indican el intervalo de índices de un grupo específico dentro de la entrada.

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

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

Grupos sin captura

Use (?:...) para agrupar con alternancia o cuantificadores sin crear una captura numerada. Así, los números de los grupos siguen teniendo un significado claro.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(?:Mr|Ms)\\.? (\\w+)").matcher("Ms. Smith");
        if (m.find()) System.out.println(m.group(1));
    }
}

Los grupos opcionales pueden ser null

Si un grupo es opcional y no participó en la coincidencia, group(n) devuelve null. Gestione siempre este caso.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)(px)?").matcher("50");
        if (m.matches()) {
            System.out.println(m.group(1));
            System.out.println(m.group(2));
        }
    }
}

Iterar sobre coincidencias con grupos

Combine find en un bucle con la extracción de grupos para obtener tokens estructurados de un texto más grande.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\w+)=(\\d+)").matcher("a=1 b=2 c=3");
        while (m.find()) {
            System.out.println(m.group(1) + " -> " + m.group(2));
        }
    }
}

Referencias inversas en el patrón

Dentro de una expresión regular, \1 coincide con el mismo texto que capturó un grupo anterior. Esto permite detectar repeticiones, como una palabra duplicada.

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

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

Capturar en records

Un patrón claro consiste en hacer coincidir, extraer los grupos y construir un objeto pequeño. Aquí usamos un record.

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

public class Main {
    record Point(int x, int y) {}

    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\((\\d+),(\\d+)\\)").matcher("(3,7)");
        if (m.matches()) {
            Point p = new Point(Integer.parseInt(m.group(1)), Integer.parseInt(m.group(2)));
            System.out.println(p);
        }
    }
}

Comprobación rápida

¿Qué devuelve group(0) después de una coincidencia correcta?

Recapitulación

Ha extraído subcadenas coincidentes:

Los paréntesis crean grupos numerados; group(0) es la coincidencia completa y los grupos a partir de 1 son capturas.
(?<name>...) crea grupos con nombre que se leen mediante group("name").
(?:...) agrupa sin capturar.
Los grupos opcionales pueden ser null; \1 hace referencia inversa a un grupo anterior.

Preguntas frecuentes

¿La lección «Grupos de captura» es gratis?

Sí — el texto completo de «Grupos de captura» 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 «Grupos de captura»?

Extraiga subcadenas coincidentes 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 3 de 4.

¿Cuánto tiempo toma la lección «Grupos de captura»?

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

← Volver a Java Academy