Extraer elementos de una cadena con una expresión regular

Las expresiones regulares son muy útiles para comprobar si una cadena de texto o un subconjunto de ella cumple un determinado patrón. Un uso común de las expresiones regulares es para validar cadenas de texto pero también pueden usarse para obtener coincidencias de la cadena, esto se hace con los grupos de captura.

Por ejemplo, supongamos que tenemos un código de un producto formateado de la siguiente forma 123-123456/1, usando guiones y una barra para separar tres grupos de números. Y ahora aparte de validar el formato correcto del código del producto nos interesa obtener los tres grupos de números. En vez de separar la cadena con un split por el caracter guión y barra de una forma que sería más laboriosa y difícil de mantener si hay algún cambio, vamos a usar los grupos de captura para obtener los tres grupos de números que forman el código.

Los grupos de captura se especifican mediante paréntesis, «(» y «)», en la expresión regular. En el caso del código usaremos la siguiente expresión regular:

1
2

(\d{3})-(\d{6})/(\d{1})

En Java con la clase Pattern y Matcher podemos hacer las validaciones y obtener los grupos de captura de la usando el método group de la clase Matcher:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package io.github.picodotdev.blogbitix.javaregex;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

public class Main {

    private static Logger logger = LoggerFactory.getLogger(Main.class);

    private static final String REGEX = "(\\d{3})-(\\d{6})/(\\d{1})";
    private static final String DEFAULT_STRING = "123-123456/1";

    public static void main(String[] args) {
        String string = (args.length > 0) ? args[0]: DEFAULT_STRING;

        Pattern pattern = Pattern.compile(REGEX);
        Matcher matcher = pattern.matcher(string);

        if (matcher.matches()) {
            logger.info("Group count: {}", matcher.groupCount());
            logger.info("Group #1: {}", matcher.group(1));
            logger.info("Group #2: {}", matcher.group(2));
            logger.info("Group #3: {}", matcher.group(3));
        } else {
            logger.info("The expression \"{}\" does not matches regex.", string);
        }
    }
}

Esto simplifica el extraer los valores de un cadena, de una manera menos frágil y más fácil de leer posteriormente el código fuente que usar la función split por uno o varios determinados caracteres, esta es una cadena bastante sencilla si el patrón es más complejo el código usando split puede complicarse notablemente.

La clase Matcher contiene más métodos útiles, por ejemplo, con los métodos start y end nos es posible conocer la posición inicial y final de cada grupo de captura. En el caso del código de este ejemplo ya los conocemos de antemano pero usando alguna expresión que capture un número variable de caracteres como «X+», «X*», «X{n,}» o «{X{n,m}}» nos permitirá conocer las posiciones inicial y final.

El código fuente completo del ejemplo puedes descargarlo del repositorio de ejemplos de Blog Bitix alojado en GitHub y probarlo en tu equipo ejecutando siguiente comando:
./gradlew run