Crea una serie di corrispondenze regex

In Java, sto cercando di restituire tutte le corrispondenze regex a un array, ma sembra che sia possibile verificare solo se il pattern corrisponde a qualcosa (booleano).

Come posso usare una corrispondenza regex per formare una matrice di tutte le stringhe che corrispondono a un'espressione regex in una determinata stringa?

( La risposta di 4castle è migliore di quella seguente se puoi assumere Java> = 9)

Devi creare un matcher e usarlo per trovare iterativamente corrispondenze.

 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());
 }

Dopo questo, allMatchescontiene le corrispondenze e puoi usare allMatches.toArray(new String[0])per ottenere un array se ne hai davvero bisogno.

Puoi anche usare MatchResultper scrivere le funzioni di supporto per ripetere le partite poiché Matcher.toMatchResult()restituisce un'istantanea dello stato corrente del gruppo.

Ad esempio puoi scrivere un iteratore pigro per farti fare

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

facendo qualcosa del genere:

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(); }
      };
    }
  };
}

Con questo,

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

i rendimenti

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

In Java 9, ora è possibile utilizzare Matcher#results()per ottenere un Stream<MatchResult>che è possibile utilizzare per ottenere un elenco / array di corrispondenze.

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 rende regex troppo complicato e non segue lo stile perl. Dai un'occhiata a MentaRegex per vedere come puoi farlo in una singola riga di codice Java:

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

Ecco un semplice esempio:

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

(se si dispone di più gruppi di acquisizione, è possibile fare riferimento a essi dal loro indice come argomento del metodo di gruppo. Se è necessario un array, utilizzare list.toArray())

Dalle tracce ufficiali 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;
        }

Usa finde inserisci il risultante groupnel tuo array / Elenco / qualunque cosa.

        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;