Java遍历HashMap替换表达式参数键匹配错误如何修复

当前替换逻辑存在两个核心缺陷，直接导致替换结果不符合预期：

• HashMap本身不保证键的遍历顺序，遍历过程中很可能先拿到P、L这类短键，提前把长参数名mP中的P、mL中的L替换为数字，后续匹配mP、mL时已经找不到完整键名，直接造成长参数被拆分替换。
• 普通字符串replace方法是全量子串匹配，没有做完整参数名的边界判断，就算手动调整遍历顺序，一旦替换后的参数值里包含其他参数名的子串，还会出现二次替换的连锁bug。

可根据场景复杂度选择以下两种实现方式：

方案1：长键优先替换（快速修复） #

将所有参数键按长度从长到短排序，优先替换长参数名，从根源避免长参数未处理就被短键拆碎的问题。
示例代码：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

public class ExpTest {
    public static void main(String[] args) {
        String exp = "k+(mP/P+mL/L)";
        Map<String, Integer> mp = new HashMap<>();
        mp.put("k", 1);
        mp.put("mP", 2);
        mp.put("P", 3);
        mp.put("mL", 4);
        mp.put("L", 5);

        // 键按长度降序排序
        ArrayList<String> keys = new ArrayList<>(mp.keySet());
        keys.sort(Comparator.comparingInt(String::length).reversed());

        // 按长键优先顺序替换
        for (String key : keys) {
            exp = exp.replace(key, mp.get(key).toString());
        }
        System.out.println(exp); // 输出1+(2/3+4/5)，符合预期
    }
}

注意：该方案仅解决长短键匹配优先级问题，如果替换后的参数值包含和其他参数名重合的子串，仍会出现重复替换问题，仅适合参数规则简单、值为纯数字不会和参数名冲突的场景。

方案2：正则整词匹配替换（高鲁棒性） #

通过正则做参数边界判断，确保每次匹配的都是独立完整的参数名，既不会匹配到长参数名的子串，也不会出现替换后的值被二次替换的问题，无需关心键的遍历顺序。
示例代码：

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

public class ExpTest {
    public static void main(String[] args) {
        String exp = "k+(mP/P+mL/L)";
        Map<String, Integer> mp = new HashMap<>();
        mp.put("k", 1);
        mp.put("mP", 2);
        mp.put("P", 3);
        mp.put("mL", 4);
        mp.put("L", 5);

        // 构建正则，用单词边界匹配独立完整的参数名
        StringBuilder regexBuilder = new StringBuilder("\\b(");
        for (String key : mp.keySet()) {
            regexBuilder.append(Pattern.quote(key)).append("|");
        }
        regexBuilder.deleteCharAt(regexBuilder.length() - 1);
        regexBuilder.append(")\\b");
        Pattern pattern = Pattern.compile(regexBuilder.toString());

        Matcher matcher = pattern.matcher(exp);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(sb, Matcher.quoteReplacement(mp.get(matcher.group(1)).toString()));
        }
        matcher.appendTail(sb);
        System.out.println(sb); // 输出1+(2/3+4/5)，符合预期
    }
}

该方案适配复杂表达式场景，就算参数值包含和参数名重合的子串也不会出现错误替换，稳定性更高。

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