如何用正则表达式智能解析嵌套键值结构并统一捕获组逻辑

本文介绍一种基于 java 正则表达式的健壮解析方案，用于处理形如 `key(value)` 或 `key(nestedkey(val)anotherkey(val))` 的混合结构，自动区分“纯值”与“嵌套映射”，并将纯值作为 key-value 对中的 key，value 设为空字符串。

在解析类似 DSL 或配置格式的字符串时（例如 VALUE(123) 和 OUTERVALUE(INNERVALUE(123)OTHERVALUE(456))），一个常见需求是：若括号内不含任何 XXX(YYY) 形式的子结构，则将整个内容视为一个“原子值”，并将其作为内层 Map 的 key，value 为空字符串；否则，按标准键值对解析所有嵌套结构。

原始代码的问题在于：它无条件使用 innerPattern 匹配括号内内容，而该正则（([A-Z]+)\((.*?)\)）对 123 这类纯值完全不匹配，导致 valueMatcher.find() 返回 false，最终 innerMap 为空 —— 从而丢失了 VALUE={123=} 这一关键映射。

解决思路很清晰：先判断括号内是否含有嵌套键值结构，再分支处理。为此，我们引入两个关键改进：

1. 更安全的 innerPattern：

   Pattern innerPattern = Pattern.compile("([A-Z]+)\\(([^()]*)\\)");

   使用 [^()]* 替代 .*?，避免跨层级匹配（如防止 INNERVALUE(123)OTHERVALUE(456) 中的 ) 被错误截断），提升鲁棒性。

2. 前置判定逻辑：
   利用 innerPattern.asPredicate().test(value) 快速判断 value 是否包含任意合法嵌套项。若不包含（即纯值），则直接 innerMap.put(value, "")；否则执行逐项匹配。

完整可运行示例：

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

public class NestedParser {
    public static void main(String[] args) {
        Pattern outerPattern = Pattern.compile("([A-Z]+)\\((.*)\\)");
        Pattern innerPattern = Pattern.compile("([A-Z]+)\\(([^()]*)\\)");

        String input = """
            VALUE(123)
            OUTERVALUE(INNERVALUE(123)OTHERVALUE(456))
            """;

        Map> outer = new HashMap<>(
);

        input.lines()
              .filter(line -> !line.trim().isEmpty()) // 忽略空行
              .forEach(line -> {
                  Matcher matcher = outerPattern.matcher(line);
                  if (!matcher.find()) return; // 跳过不匹配行

                  String key = matcher.group(1);
                  String value = matcher.group(2);
                  Map innerMap = new HashMap<>();

                  if (innerPattern.asPredicate().test(value)) {
                      // 含嵌套结构：逐个提取 KEY(VALUE)
                      Matcher valueMatcher = innerPattern.matcher(value);
                      while (valueMatcher.find()) {
                          innerMap.put(valueMatcher.group(1), valueMatcher.group(2));
                      }
                  } else {
                      // 纯值：视为 key，value 为空字符串
                      innerMap.put(value, "");
                  }
                  outer.put(key, innerMap);
              });

        System.out.println(outer);
        // 输出: {VALUE={123=}, OUTERVALUE={INNERVALUE=123, OTHERVALUE=456}}
    }
}

⚠️ 注意事项：

• 本方案假设输入格式严格：外层必为 KEY(...)，且括号内非嵌套即纯值，不支持混合（如 MIXED(123INNER(456))）或深层嵌套（如 A(B(C(D)))）。如需支持深度嵌套，应改用递归下降解析器或栈式匹配。
• [^()]* 保证单层匹配安全，但若业务允许括号内含转义（如 TEXT\(escaped\)），则需升级为更复杂的正则或手动解析。
• .lines() 是 Java 11+ 特性；若需兼容旧版本，可用 Arrays.stream(input.split("\n")) 替代。

总结：正则本身无法“重置捕获组编号”，但通过语义化预判 + 分支处理，我们能优雅绕过限制，在保持代码简洁的同时精准建模复杂结构。