tutorial - identificar las características y el uso de las expresiones regulares en java

Crear una matriz de coincidencias de expresiones regulares

Question

En Java intento devolver todas las coincidencias de expresiones regulares a una matriz, pero parece que solo se puede verificar si el patrón coincide con algo o no (booleano). ¿Alguien puede ayudarme a usar una coincidencia de expresiones regulares para formar una matriz de todas las cadenas que coincidan con una expresión de expresiones regulares en una cadena dada? ¡Gracias!

Answer 1

Aquí hay un ejemplo simple:

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

(Si tiene más grupos de captura, puede consultarlos por su índice como argumento del método de grupo. Si necesita una matriz, use list.toArray() )

Answer 2

Desde el oficial Regex Java Trails :

        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 find e insertar el group resultante en tu matriz / Lista / lo que sea.

Answer 3

En Java 9, ahora puede usar Matcher#results para obtener un Stream<MatchResult> que puede usar para obtener una lista / matriz de coincidencias.

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

Answer 4

Java hace que la expresión regular sea demasiado complicada y no sigue el estilo perl. Eche un vistazo a mentaregex.soliveirajr.com para ver cómo puede lograr eso en una sola línea de código Java:

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

Answer 5

( La respuesta de 4castle es mejor que la de abajo si puedes asumir que Java> = 9)

Necesita crear un marcador y usarlo para buscar coincidencias de forma iterativa.

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

Después de esto, allMatches contiene las coincidencias, y puedes usar allMatches.toArray(new String[0]) para obtener una matriz si realmente la necesitas.

También puede usar MatchResult para escribir funciones de ayuda para Matcher.toMatchResult() coincidencias, ya que Matcher.toMatchResult() devuelve una instantánea del estado del grupo actual.

Por ejemplo, puedes escribir un iterador perezoso para dejarte hacer

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

haciendo algo como esto:

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 este,

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

rendimientos

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

Answer 6

        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;