Java Regex thay thế bằng Capturing Group

Có cách nào để thay thế regexp bằng nội dung đã sửa đổi của nhóm capture không?

Thí dụ:

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

Và tôi muốn thay thế tất cả các lần xuất hiện bằng $ 1 nhân với 3.

biên tập:

Có vẻ như có gì đó không ổn :(

Nếu tôi sử dụng

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

Nó ném IllegalStateException: Không tìm thấy kết quả phù hợp

Nhưng

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

hoạt động tốt, nhưng tôi không thể thay đổi $ 1 :(

biên tập:

Bây giờ, nó đang hoạt động :)

Làm thế nào về:

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

Để có được trận đấu đầu tiên, hãy sử dụng #find(). Sau đó, bạn có thể sử dụng #group(1)để tham chiếu đến trận đấu đầu tiên này và thay thế tất cả các trận đấu bằng giá trị maches đầu tiên nhân với 3.

Và trong trường hợp bạn muốn thay thế từng trận đấu bằng giá trị của trận đấu đó nhân với 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());

Bạn có thể muốn xem qua Matchertài liệu của , nơi này và nhiều thứ khác được đề cập chi tiết.

câu trả lời của bá tước cung cấp cho bạn giải pháp, nhưng tôi nghĩ rằng tôi sẽ thêm những gì vấn đề đang gây ra cho bạn IllegalStateException. Bạn đang gọi group(1)mà không phải gọi trước một thao tác khớp (chẳng hạn như find()). Điều này không cần thiết nếu bạn chỉ đang sử dụng $1vì đây replaceAll()là hoạt động phù hợp.

Java 9 cung cấp một hàm Matcher.replaceAll()chấp nhận một hàm thay thế:

resultString = regexMatcher.replaceAll(
        m -> String.valueOf(Integer.parseInt(m.group()) * 3));

Nguồn: java-implement-of-rubys-gsub

Sử dụng:

// 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);

Thực hiện (thiết kế lại):

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