regular - Reemplazo de Java Regex con grupo de captura

expresiones regulares html

Question

¿Hay alguna manera de reemplazar una expresión regular con contenido modificado del grupo de captura?

Ejemplo:

Pattern regex = Pattern.compile("(//d{1,2})");
Matcher regexMatcher = regex.matcher(text);
resultString = regexMatcher.replaceAll("$1"); // *3 ??

Y me gustaría reemplazar todas las apariciones con $ 1 multiplicado por 3.

editar:

Parece que algo está mal :(

Si uso

Pattern regex = Pattern.compile("(//d{1,2})");
Matcher regexMatcher = regex.matcher("12 54 1 65");
try {
String resultString = regexMatcher.replaceAll(regexMatcher.group(1));
} catch (Exception e) {
e.printStackTrace();
}

Lanza una IllegalStateException: no se encontraron coincidencias

Pero

Pattern regex = Pattern.compile("(//d{1,2})");
Matcher regexMatcher = regex.matcher("12 54 1 65");
try {
String resultString = regexMatcher.replaceAll("$1");
} catch (Exception e) {
e.printStackTrace();
}

funciona bien, pero no puedo cambiar el $ 1 :(

editar:

Ahora funciona :)

Answer 1

Fuente: java-implementation-of-rubys-gsub

Uso:

// Rewrite an ancient unit of length in SI units.
String result = new Rewriter("([0-9]+(//.[0-9]+)?)[- ]?(inch(es)?)") {
public String replacement() {
float inches = Float.parseFloat(group(1));
return Float.toString(2.54f * inches) + " cm";
}
}.rewrite("a 17 inch display");
System.out.println(result);
// The "Searching and Replacing with Non-Constant Values Using a
// Regular Expression" example from the Java Almanac.
result = new Rewriter("([a-zA-Z]+[0-9]+)") {
public String replacement() {
return group(1).toUpperCase();
}
}.rewrite("ab12 cd efg34");
System.out.println(result);

Implementación (rediseñado):

import static java.lang.String.format;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public abstract class Rewriter {
private Pattern pattern;
private Matcher matcher;
public Rewriter(String regularExpression) {
this.pattern = Pattern.compile(regularExpression);
}
public String group(int i) {
return matcher.group(i);
}
public abstract String replacement() throws Exception;
public String rewrite(CharSequence original) {
return rewrite(original, new StringBuffer(original.length())).toString();
}
public StringBuffer rewrite(CharSequence original, StringBuffer destination) {
try {
this.matcher = pattern.matcher(original);
while (matcher.find()) {
matcher.appendReplacement(destination, "");
destination.append(replacement());
}
matcher.appendTail(destination);
return destination;
} catch (Exception e) {
throw new RuntimeException("Cannot rewrite " + toString(), e);
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(pattern.pattern());
for (int i = 0; i <= matcher.groupCount(); i++)
sb.append(format("/n/t(%s) - %s", i, group(i)));
return sb.toString();
}
}

Answer 2

La respuesta de earl te da la solución, pero pensé que agregaría el problema que está causando tu IllegalStateException . Está llamando al group(1) sin haber llamado primero una operación de coincidencia (como find() ). Esto no es necesario si solo está utilizando $1 ya que replaceAll() es la operación de coincidencia.

Answer 3

Qué tal si:

if (regexMatcher.find()) {
resultString = regexMatcher.replaceAll(
String.valueOf(3 * Integer.parseInt(regexMatcher.group(1))));
}

Para obtener la primera coincidencia, use #find() . Después de eso, puede usar #group(1) para referirse a esta primera coincidencia, y reemplazar todas las coincidencias por el primer valor de maches multiplicado por 3.

Y en caso de que quiera reemplazar cada partido por el valor de ese partido multiplicado por 3:

 Pattern p = Pattern.compile("(//d{1,2})");
Matcher m = p.matcher("12 54 1 65");
StringBuffer s = new StringBuffer();
while (m.find())
m.appendReplacement(s, String.valueOf(3 * Integer.parseInt(m.group(1))));
System.out.println(s.toString());

Es posible que desee revisar la documentación de Matcher , donde se cubren más detalles y esto y mucho más.