Nazwane grupy Regex w Javie

Rozumiem, że java.regexpakiet nie obsługuje nazwanych grup ( http://www.regular-expressions.info/named.html ), więc czy ktoś może wskazać mi bibliotekę innej firmy, która ją obsługuje?

Patrzyłem na jregex, ale jego ostatnie wydanie było w 2002 roku i nie działało dla mnie (wprawdzie próbowałem tylko przez chwilę) pod java5.

( Aktualizacja : sierpień 2011 )

Jak geofflane wspomina w swojej odpowiedzi , Java 7 obsługuje teraz nazwane grupy .
tchrist zwraca uwagę w komentarzu, że wsparcie jest ograniczone.
On szczegóły ograniczeń w swej wielkiej odpowiedź „ Java Regex Helper ”

Obsługa grup o nazwie regex Java 7 została zaprezentowana we wrześniu 2010 roku na blogu Oracle .

W oficjalnym wydaniu Java 7 konstrukcje obsługujące nazwaną grupę przechwytującą to:

• (?<name>capturing text) definiowanie nazwanej grupy „nazwa”
• \k<name> odwoływać się do nazwanej grupy „nazwa”
• ${name} do odniesienia do przechwyconej grupy w łańcuchu zastępczym Matchera
• Matcher.group(String name) zwraca przechwycony podciąg wejściowy przez daną „nazwaną grupę”.

Inne alternatywy dla wersji przed Java 7 to:

• Google o nazwie-regex (patrz John Hardy „s odpowiedź )
  Gábor Lipták wspomina (listopad 2012), że projekt ten może nie być aktywne (z kilku wybitnych bugs ), a jego GitHub widelec można uznać zamiast.
• jregex (patrz Brian Clozel „s odpowiedź )

( Oryginalna odpowiedź : styczeń 2009 r. , Kolejne dwa linki są teraz uszkodzone)

Nie możesz odwoływać się do nazwanej grupy, chyba że zakodujesz własną wersję Regex ...

Dokładnie to zrobił Gorbush2 w tym wątku .

Regex2

(ograniczona implementacja, jak wskazał ponownie tchrist , ponieważ szuka tylko identyfikatorów ASCII. tchrist opisuje to ograniczenie jako:

możliwość posiadania tylko jednej nazwanej grupy dla tej samej nazwy (nad którą nie zawsze masz kontrolę!) i niemożność użycia ich do rekurencji w wyrażeniu regularnym.

Uwaga: przykłady prawdziwej rekurencji wyrażeń regularnych można znaleźć w wyrażeniach regularnych Perla i PCRE, jak wspomniano na slajdzie Regexp Power , PCRE specs and Matching Strings with Balanced Nawiasy

Przykład:

Strunowy:

"TEST 123"

RegExp:

"(?<login>\\w+) (?<id>\\d+)"

Dostęp

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

Zastąpić

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

(wyciąg z realizacji)

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 '<':   // (?<xxx)  look behind or group name
                ch = read();
                int start = cursor;
[...]
                // test forGroupName
                int startChar = ch;
                while(ASCII.isWord(ch) && ch != '>') ch=read();
                if(ch == '>'){
                    // 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;
                }

Dla osób przychodzących tak późno: Java 7 dodaje nazwane grupy. Dokumentacja Matcher.group (String groupName).

Tak, ale to niechlujne hakowanie zajęć ze słońca. Jest prostszy sposób:

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

named-regexp jest cienkim opakowaniem dla standardowej implementacji wyrażeń regularnych JDK, którego jedynym celem jest obsługa nazwanych grup przechwytywania w stylu .net: (? ...).

Może być używany z Javą 5 i 6 (używane są generyczne).

Java 7 będzie obsługiwać nazwane grupy przechwytywania, więc ten projekt nie jest trwały.

Jaki problem masz z jregex ? U mnie działało dobrze pod java5 i java6.

Jregex dobrze sobie radzi (nawet jeśli ostatnia wersja pochodzi z 2002 roku), chyba że chcesz poczekać na javaSE 7 .

W przypadku użytkowników korzystających z wersji starszej niż java7, nazwane grupy są obsługiwane przez joni (port Java biblioteki regexp Oniguruma ). Dokumentacja jest skromna, ale nam się udało.
Pliki binarne są dostępne za pośrednictwem Maven ( http://repository.codehaus.org/org/jruby/joni/joni/ ).

Trochę stare pytanie, ale okazało się, że potrzebuję tego również i że powyższe sugestie były nieadekwatne - i jako takie - sam opracowałem cienkie opakowanie: https://github.com/hofmeister/MatchIt