Utwórz tablicę dopasowań wyrażeń regularnych

W Javie próbuję zwrócić wszystkie dopasowania wyrażeń regularnych do tablicy, ale wydaje się, że możesz tylko sprawdzić, czy wzorzec pasuje do czegoś, czy nie (boolean).

Jak mogę użyć dopasowania wyrażenia regularnego, aby utworzyć tablicę wszystkich ciągów pasujących do wyrażenia regularnego w danym ciągu?

( Odpowiedź 4castle jest lepsza niż poniżej, jeśli możesz założyć, że Java> = 9)

Musisz utworzyć dopasowanie i użyć go do iteracyjnego znajdowania dopasowań.

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

 ...

 List<String> allMatches = new ArrayList<String>();
 Matcher m = Pattern.compile("your regular expression here")
     .matcher(yourStringHere);
 while (m.find()) {
   allMatches.add(m.group());
 }

Następnie allMatcheszawiera dopasowania i możesz użyć allMatches.toArray(new String[0])do pobrania tablicy, jeśli naprawdę jej potrzebujesz.

Możesz również użyć MatchResultdo napisania funkcji pomocniczych do zapętlenia dopasowań, ponieważ Matcher.toMatchResult()zwraca migawkę bieżącego stanu grupy.

Na przykład możesz napisać leniwy iterator, który pozwoli ci to zrobić

for (MatchResult match : allMatches(pattern, input)) {
  // Use match, and maybe break without doing the work to find all possible matches.
}

robiąc coś takiego:

public static Iterable<MatchResult> allMatches(
      final Pattern p, final CharSequence input) {
  return new Iterable<MatchResult>() {
    public Iterator<MatchResult> iterator() {
      return new Iterator<MatchResult>() {
        // Use a matcher internally.
        final Matcher matcher = p.matcher(input);
        // Keep a match around that supports any interleaving of hasNext/next calls.
        MatchResult pending;

        public boolean hasNext() {
          // Lazily fill pending, and avoid calling find() multiple times if the
          // clients call hasNext() repeatedly before sampling via next().
          if (pending == null && matcher.find()) {
            pending = matcher.toMatchResult();
          }
          return pending != null;
        }

        public MatchResult next() {
          // Fill pending if necessary (as when clients call next() without
          // checking hasNext()), throw if not possible.
          if (!hasNext()) { throw new NoSuchElementException(); }
          // Consume pending so next call to hasNext() does a find().
          MatchResult next = pending;
          pending = null;
          return next;
        }

        /** Required to satisfy the interface, but unsupported. */
        public void remove() { throw new UnsupportedOperationException(); }
      };
    }
  };
}

Z tym,

for (MatchResult match : allMatches(Pattern.compile("[abc]"), "abracadabra")) {
  System.out.println(match.group() + " at " + match.start());
}

plony

a at 0
b at 1
a at 3
c at 4
a at 5
a at 7
b at 8
a at 10

W Javie 9 możesz teraz użyć, Matcher#results()aby uzyskać Stream<MatchResult>listę / tablicę dopasowań.

import java.util.regex.Pattern;
import java.util.regex.MatchResult;

String[] matches = Pattern.compile("your regex here")
                          .matcher("string to search from here")
                          .results()
                          .map(MatchResult::group)
                          .toArray(String[]::new);
                    // or .collect(Collectors.toList())

Java sprawia, że ​​regex jest zbyt skomplikowany i nie jest zgodny ze stylem perla. Spójrz na MentaRegex, aby zobaczyć, jak możesz to osiągnąć w jednej linii kodu Java:

String[] matches = match("aa11bb22", "/(\\d+)/g" ); // => ["11", "22"]

Oto prosty przykład:

Pattern pattern = Pattern.compile(regexPattern);
List<String> list = new ArrayList<String>();
Matcher m = pattern.matcher(input);
while (m.find()) {
    list.add(m.group());
}

(jeśli masz więcej grup przechwytywania, możesz odwołać się do nich przez ich indeks jako argument metody group. Jeśli potrzebujesz tablicy, użyj list.toArray())

Z oficjalnych tras Regex Java :

        Pattern pattern = 
        Pattern.compile(console.readLine("%nEnter your regex: "));

        Matcher matcher = 
        pattern.matcher(console.readLine("Enter input string to search: "));

        boolean found = false;
        while (matcher.find()) {
            console.format("I found the text \"%s\" starting at " +
               "index %d and ending at index %d.%n",
                matcher.group(), matcher.start(), matcher.end());
            found = true;
        }

Użyj findi wstaw wynik groupdo swojej tablicy / listy / cokolwiek.

        Set<String> keyList = new HashSet();
        Pattern regex = Pattern.compile("#\\{(.*?)\\}");
        Matcher matcher = regex.matcher("Content goes here");
        while(matcher.find()) {
            keyList.add(matcher.group(1)); 
        }
        return keyList;