Grupos con nombre Regex en Java

Tengo entendido que el paquete java.regex no tiene soporte para grupos con nombre ( http://www.regular-expressions.info/named.html ) entonces, ¿puede alguien señalarme hacia una biblioteca de terceros que sí lo haga?

Miré jregex pero su último lanzamiento fue en 2002 y no funcionó para mí (admití que solo lo intenté brevemente) en java5.

( Actualización : agosto de 2011 )

Como geofflane menciona en su respuesta , Java 7 ahora admite grupos con nombre .
Tchrist señala en el comentario que el soporte es limitado.
Él detalla las limitaciones en su gran respuesta ” Java Regex Helper “

El soporte del grupo denominado Java 7 regex se presentó en septiembre de 2010 en el blog de Oracle .

En el lanzamiento oficial de Java 7, los constructos para soportar el grupo de captura nombrado son:

  • (?capturing text) para definir un nombre de grupo “nombre”
  • \k para referenciar un grupo llamado “nombre”
  • ${name} para hacer referencia al grupo capturado en la cadena de reemplazo de Matcher
  • Matcher.group(String name) para devolver la subsecuencia de entrada capturada por el “grupo nombrado” dado.

Otras alternativas para pre-Java 7 fueron:

  • Google named-regex (ver la respuesta de John Hardy )
    Gábor Lipták menciona (noviembre de 2012) que este proyecto podría no estar activo (con varios errores sobresalientes ), y que su bifurcación GitHub podría considerarse en su lugar.
  • jregex (Ver la respuesta de Brian Clozel )

( Respuesta original : enero de 2009 , con los siguientes dos enlaces ahora rotos)

No puede hacer referencia al grupo con nombre, a menos que codifique su propia versión de Regex …

Eso es precisamente lo que Gorbush2 hizo en este hilo .

Regex2

(Implementación limitada, como lo señaló nuevamente Tchrist , ya que solo busca identificadores ASCII. Tchrist detalla la limitación como:

solo puede tener un grupo nombrado por el mismo nombre (sobre el que no siempre se tiene control) y no poder usarlos para la recursión en regex.

Nota: Puede encontrar ejemplos de recursión de expresiones regulares reales en expresiones regulares de Perl y PCRE, como se menciona en Regexp Power , especificaciones de PCRE y diapositiva de cadenas coincidentes con paréntesis equilibrados )

Ejemplo:

Cuerda:

 "TEST 123" 

RegExp:

 "(?\\w+) (?\\d+)" 

Acceso

 matcher.group(1) ==> TEST matcher.group("login") ==> TEST matcher.name(1) ==> login 

Reemplazar

 matcher.replaceAll("aaaaa_$1_sssss_$2____") ==> aaaaa_TEST_sssss_123____ matcher.replaceAll("aaaaa_${login}_sssss_${id}____") ==> aaaaa_TEST_sssss_123____ 

(extracto de la implementación)

 public final class Pattern implements java.io.Serializable { [...] /** * Parses a group and returns the head node of a set of nodes that process * the group. Sometimes a double return system is used where the tail is * returned in root. */ private Node group0() { boolean capturingGroup = false; Node head = null; Node tail = null; int save = flags; root = null; int ch = next(); if (ch == '?') { ch = skip(); switch (ch) { case '<': // (?'){ // valid group name int len = cursor-start; int[] newtemp = new int[2*(len) + 2]; //System.arraycopy(temp, start, newtemp, 0, len); StringBuilder name = new StringBuilder(); for(int i = start; i< cursor; i++){ name.append((char)temp[i-1]); } // create Named group head = createGroup(false); ((GroupTail)root).name = name.toString(); capturingGroup = true; tail = root; head.next = expr(tail); break; } 

Sí, pero su desordenado hackear las clases de sol. Hay una manera más simple:

http://code.google.com/p/named-regexp/

named-regexp es una envoltura delgada para la implementación estándar de expresiones regulares JDK, con el único propósito de manejar grupos de captura nombrados en el estilo .net: (? …).

Se puede usar con Java 5 y 6 (se usan generics).

Java 7 manejará grupos de captura nombrados, por lo que este proyecto no debe durar.

Para las personas que llegan tarde: Java 7 agrega grupos con nombre. Matcher.group (String groupName) documentación.

¿Qué tipo de problema obtienes con jregex ? Me funcionó bien en java5 y java6.

Jregex hace bien el trabajo (incluso si la última versión es de 2002), a menos que desee esperar a Java 7 .

Para aquellos que ejecutan pre-java7, los grupos con nombre son compatibles con joni (puerto de Java de la biblioteca de expresiones regulares de Oniguruma ). La documentación es escasa, pero nos ha funcionado bien.
Los binarios están disponibles a través de Maven ( http://repository.codehaus.org/org/jruby/joni/joni/ ).

Una pregunta un poco vieja, pero me encontré que necesitaba esto también y que las sugerencias anteriores eran inadecuadas, y como tal, desarrollé una envoltura delgada: https://github.com/hofmeister/MatchIt