如何在Java中实现类似JavaScript的正则表达式动态替换（避免索引偏移）

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

public class NaiveReplacement {
    public static void main(String[] args) {
        String p = "delivery45-2.5.6/8/3.4?1=f-g&e=d&h=i";
        Pattern pattern = Pattern.compile("\b\w+\b");

        // 模拟 JavaScript 中的 k[c] 函数，根据匹配的字符串返回替换值
        Function<String, String> z = s -> {
            if (s.matches("\d+")) {
                return "NUM"; // 示例：数字替换为 "NUM"
            } else if (s.matches("[a-zA-Z]+")) {
                // 示例：特定字母替换为特定值
                switch (s) {
                    case "delivery": return "DELIVERY_PREFIX";
                    case "f": return "F_VAL";
                    case "g": return "G_VAL";
                    case "e": return "E_VAL";
                    case "d": return "D_VAL";
                    case "h": return "H_VAL";
                    case "i": return "I_VAL";
                    default: return s.toUpperCase(); // 其他单词转大写
                }
            }
            return s; // 默认返回原字符串
        };

        Matcher matcher = pattern.matcher(p);
        while (matcher.find()) {
            String matchedString = matcher.group();
            String replacementString = z.apply(matchedString);
            // 问题所在：String.replace() 会替换所有匹配项，并且改变字符串长度，
            // 导致后续 matcher.find() 的索引失效
            p = p.replace(matchedString, replacementString);
        }
        System.out.println("Naive replacement result: " + p);
        // 实际输出可能类似于：STRING_tliv56287592ry45-2.5.6/8/3.4?1=f-g&e=d&h=i
        // 出现多次替换、索引错乱等问题
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DynamicRegexReplacer {

    // 辅助类，用于存储每个匹配项的详细信息
    private static class MatchInfo {
        int start; // 匹配项的起始索引
        int end;   // 匹配项的结束索引
        String replacement; // 对应的替换字符串

        MatchInfo(int start, int end, String replacement) {
            this.start = start;
            this.end = end;
            this.replacement = replacement;
        }
    }

    /**
     * 实现类似JavaScript的动态正则表达式替换功能。
     * @param originalString 原始字符串。
     * @param pattern 用于匹配的正则表达式模式。
     * @param replacer 一个函数，接收匹配到的字符串，返回其对应的替换字符串。
     * @return 替换后的新字符串。
     */
    public static String replaceRegexMatches(String originalString, Pattern pattern, Function<String, String> replacer) {
        List<MatchInfo> matchesToReplace = new ArrayList<>();
        Matcher matcher = pattern.matcher(originalString);

        // 步骤1：遍历原始字符串，收集所有匹配项的起始、结束索引及替换字符串
        while (matcher.find()) {
            int start = matcher.start();
            int end = matcher.end();
            String matchedSubstring = matcher.group();
            String replacementString = replacer.apply(matchedSubstring);
            matchesToReplace.add(new MatchInfo(start, end, replacementString));
        }

        // 如果没有匹配项，直接返回原始字符串
        if (matchesToReplace.isEmpty()) {
            return originalString;
        }

        // 步骤2：使用StringBuilder从右到左执行替换操作
        // StringBuilder比String的反复拼接更高效
        StringBuilder sb = new StringBuilder(originalString);

        // 从后向前遍历匹配列表，确保替换操作不会影响尚未处理的匹配项的索引
        for (int i = matchesToReplace.size() - 1; i >= 0; i--) {
            MatchInfo info = matchesToReplace.get(i);
            // 使用 StringBuilder 的 replace 方法直接替换指定范围的字符
            sb.replace(info.start, info.end, info.replacement);
        }

        return sb.toString();
    }

    public static void main(String[] args) {
        String p = "delivery45-2.5.6/8/3.4?1=f-g&e=d&h=i";
        Pattern pattern = Pattern.compile("\b\w+\b");

        // 模拟 JavaScript 中的 k[c] 函数，根据匹配的字符串返回替换值
        Function<String, String> z = s -> {
            if (s.matches("\d+")) {
                return "NUM"; // 示例：数字替换为 "NUM"
            } else if (s.matches("[a-zA-Z]+")) {
                // 示例：特定字母替换为特定值
                switch (s) {
                    case "delivery": return "DELIVERY_PREFIX";
                    case "f": return "F_VAL";
                    case "g": return "G_VAL";
                    case "e": return "E_VAL";
                    case "d": return "D_VAL";
                    case "h": return "H_VAL";
                    case "i": return "I_VAL";
                    default: return s.toUpperCase(); // 其他单词转大写
                }
            }
            return s; // 默认返回原字符串
        };

        String result = replaceRegexMatches(p, pattern, z);
        System.out.println("Original String: " + p);
        System.out.println("Modified String: " + result);
        // 预期输出：Original String: delivery45-2.5.6/8/3.4?1=f-g&e=d&h=i
        // Modified String: DELIVERY_PREFIX-NUM.NUM.NUM/NUM/NUM?NUM=F_VAL-G_VAL&E_VAL=D_VAL&H_VAL=I_VAL
    }
}