Java带量词正则：动态替换匹配内容是否有简便实现方式？

Great question! When you need to replace every regex match (like digits \d+) with a string of the same length made of a repeated character (like D), you don’t have to manually extract each match, measure its length, and build the replacement string from scratch—though that’s a totally valid approach. Java does offer more streamlined ways to handle this dynamic replacement logic.

1. The Clean Pre-Java 9 Approach #

This method works across all Java versions and avoids manual index tracking. It uses the Matcher class’s built-in methods to handle the replacement flow:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DynamicRegexReplace {
    public static void main(String[] args) {
        String input = "a 123 b 1984 c 1 d 123456789";
        Pattern digitPattern = Pattern.compile("\\d+");
        Matcher matcher = digitPattern.matcher(input);
        
        StringBuilder result = new StringBuilder();
        while (matcher.find()) {
            // Get the length of the matched digit sequence
            int matchLength = matcher.group().length();
            // Create a string of 'D's with the same length
            String replacement = new String(new char[matchLength]).replace('\0', 'D');
            // Append the text before the match + our custom replacement
            matcher.appendReplacement(result, replacement);
        }
        // Append any remaining text after the last match
        matcher.appendTail(result);
        
        System.out.println(result.toString());
        // Output: a DDD b DDDD c D d DDDDDDDDD
    }
}

This approach handles all the position tracking for you—no need to worry about overlapping matches or shifted indices after each replacement.

2. The Concise Java 9+ Approach #

If you’re using Java 9 or later, you can use the overloaded String.replaceAll() method that accepts a lambda function. This cuts out the boilerplate and lets you define the replacement logic directly:

public class DynamicRegexReplaceJava9 {
    public static void main(String[] args) {
        String input = "a 123 b 1984 c 1 d 123456789";
        String result = input.replaceAll("\\d+", matchResult -> 
            new String(new char[matchResult.group().length()]).replace('\0', 'D')
        );
        
        System.out.println(result);
        // Same output as above
    }
}

Here, the lambda takes each MatchResult, calculates the length of the matched digits, and returns the corresponding string of Ds. Java handles the rest of the matching and replacement flow under the hood.

Quick Tips #

• The new String(new char[length]).replace('\0', 'D') trick is a fast way to create repeated character strings in Java. For readability, you could also use String.join("", Collections.nCopies(length, "D")) (though it’s slightly less efficient for large lengths).
• Both methods avoid the pitfalls of naive string replacement (like accidentally replacing parts of the input you didn’t target).

So to answer your original question: No, you don’t have to manually extract each match and handle all the boilerplate. Java provides built-in tools that let you implement this dynamic replacement logic directly, without reinventing the wheel.

内容的提问来源于stack exchange，提问作者Carsten