Java如何链式调用多个预编译正则Pattern进行字符串替换？

针对你需要灵活选择正则子集做链式替换的需求，这里提供几种简洁的实现方式：

一、构建器模式（推荐） #

自己实现一个轻量的构建器，支持链式添加替换规则，最后统一执行替换，完美适配“选择子集”的场景：

public class StringReplacer {
    private final List<ReplaceRule> rules = new ArrayList<>();

    private StringReplacer() {}

    public static StringReplacer create() {
        return new StringReplacer();
    }

    public StringReplacer add(Pattern pattern, String replacement) {
        rules.add(new ReplaceRule(pattern, replacement));
        return this;
    }

    public String apply(String input) {
        String result = input;
        for (ReplaceRule rule : rules) {
            result = rule.pattern.matcher(result).replaceFirst(rule.replacement);
        }
        return result;
    }

    private static class ReplaceRule {
        private final Pattern pattern;
        private final String replacement;

        ReplaceRule(Pattern pattern, String replacement) {
            this.pattern = pattern;
            this.replacement = replacement;
        }
    }
}

使用时链式选择需要的规则，代码非常清爽：

String s = "foo0bar1baz2";
// 只选择REGEX[0]和REGEX[1]进行替换
s = StringReplacer.create()
        .add(REGEX[0], "abc")
        .add(REGEX[1], "xyz")
        .apply(s);

二、Stream流处理 #

如果不想写额外类，用Stream的reduce操作也能实现链式替换，适合快速实现：

String s = "foo0bar1baz2";
// 把需要的替换规则封装成列表
List<Map.Entry<Pattern, String>> replacePairs = Arrays.asList(
        new AbstractMap.SimpleEntry<>(REGEX[0], "abc"),
        new AbstractMap.SimpleEntry<>(REGEX[1], "xyz")
);

// 用reduce依次应用替换
s = replacePairs.stream()
        .reduce(s, (currentStr, entry) -> entry.getKey().matcher(currentStr).replaceFirst(entry.getValue()),
                (a, b) -> b);

三、自定义工具方法 #

如果只是想简化循环，写个静态工具方法也能减少样板代码：

public static String replaceWithPatterns(String input, List<Pattern> patterns, List<String> replacements) {
    String result = input;
    for (int i = 0; i < Math.min(patterns.size(), replacements.size()); i++) {
        result = patterns.get(i).matcher(result).replaceFirst(replacements.get(i));
    }
    return result;
}

调用时：

s = replaceWithPatterns("foo0bar1baz2", 
                        Arrays.asList(REGEX[0], REGEX[1]), 
                        Arrays.asList("abc", "xyz"));

这几种方式都能避免嵌套调用的繁琐，同时支持灵活选择需要的正则子集，根据你的场景选就行。

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