Criar matriz de correspondências regex

Em Java, estou tentando retornar todas as correspondências de regex para uma matriz, mas parece que você só pode verificar se o padrão corresponde a algo ou não (booleano).

Como posso usar uma correspondência de regex para formar uma matriz de todas as strings que correspondem a uma expressão de regex em uma determinada string?

( A resposta do 4castle é melhor que a abaixo, se você puder assumir Java> = 9)

Você precisa criar um correspondente e usá-lo para encontrar correspondências iterativamente.

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

Depois disso, allMatchescontém as correspondências e você pode usar allMatches.toArray(new String[0])para obter uma matriz se realmente precisar de uma.

Você também pode usar MatchResultpara escrever funções auxiliares para fazer loop sobre correspondências, pois Matcher.toMatchResult()retorna uma captura instantânea do estado atual do grupo.

Por exemplo, você pode escrever um iterador lento para permitir que você faça

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

fazendo algo parecido com isto:

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

Com isso,

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

rendimentos

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

No Java 9, agora você pode usar Matcher#results()para obter um Stream<MatchResult>que você pode usar para obter uma lista / matriz de correspondências.

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 torna o regex muito complicado e não segue o estilo perl. Dê uma olhada no MentaRegex para ver como você pode fazer isso em uma única linha de código Java:

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

Aqui está um exemplo simples:

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

(se você tiver mais grupos de captura, poderá consultá-los pelo índice deles como um argumento do método de grupo. Se precisar de uma matriz, use list.toArray())

Das trilhas oficiais do 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;
        }

Use finde insira o resultado groupem sua matriz / Lista / qualquer que seja.

        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;