Java 正则表达式中实现“值降级为键”与嵌套结构的智能解析

聖光之護

发布时间：2026-01-10 17:33:09

487人浏览过

来源于php中文网

原创

Java 正则表达式中实现“值降级为键”与嵌套结构的智能解析

本文介绍如何在 java 中通过正则匹配结合逻辑判断，对形如 `key(value)` 或 `key(nestedkey(val)anotherkey(val))` 的字符串进行分层解析，并统一将无嵌套的纯值（如 `value(123)`）自动映射为 `{ "123": "" }`，同时保留嵌套结构的正常提取。

在处理领域特定语法（如配置片段、DSL 表达式）时，常遇到混合结构：某些键后直接跟原子值（如 VALUE(123)），另一些则包裹多组嵌套键值对（如 OUTERVALUE(INNERVALUE(123)OTHERVALUE(456))）。目标是统一建模为 Map>，其中：

若外层值不含嵌套结构（即无 X(Y) 形式子项），则将整个值字符串作为内层 key，value 设为空字符串 ""；
若含嵌套，则按 KEY(VALUE) 提取所有子键值对。

关键挑战在于：不能仅靠单个正则“重置捕获组编号”来切换语义（Java 不支持 PCRE 风格的 (?|...) 分支重置组），而应采用「先识别结构类型，再分路径处理」的稳健策略。

Short AI

AI短视频生成器，轻松创作爆款短视频！

下载

✅ 推荐实现方案（结构清晰 + 可读性强）

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

public class NestedValueParser {
    // 匹配顶层结构：KEY(...)
    private static final Pattern OUTER_PATTERN = Pattern.compile("([A-Z]+)\\((.*)\\)");
    // 精确匹配嵌套项：KEY(...)，要求括号内无嵌套括号（避免贪婪匹配越界）
    private static final Pattern INNER_PATTERN = Pattern.compile("([A-Z]+)\\(([^()]*)\\)");

    public static Map> parse(String input) {
        Map> result = new HashMap<>();

        for (String line : input.lines().filter(s -> !s.trim().isEmpty())) {
            Matcher outerMatcher = OUTER_PATTERN.matcher(line.trim());
            if (!outerMatcher.find()) continue;

            String key = outerMatcher.group(1);
            String valueContent = outerMatcher.group(2);

            Map innerMap = new HashMap<>();

            // 判断 valueContent 是否包含任何合法嵌套项（如 ABC(123)）
            if (INNER_PATTERN.asPredicate().test(valueContent)) {
                // 存在嵌套 → 按 INNER_PATTERN 提取所有 KEY(VALUE)
                Matcher innerMatcher = INNER_PATTERN.matcher(valueContent);
                while (innerMatcher.find()) {
                    innerMap.put(innerMatcher.group(1), innerMatcher.group(2));
                }
            } else {
                // 无嵌套 → 将整个 valueContent 视为原子 key，value 为空字符串
                innerMap.put(valueContent, "");
            }

            result.put(key, innerMap);
        }

        return result;
    }

    // 示例用法
    public static void main(String[] args) {
        String input = """
            VALUE(123)
            OUTERVALUE(INNERVALUE(123)OTHERVALUE(456))
            SIMPLE(SINGLE)
            COMPLEX(A(1)B(2)C(3))
            """;

        System.out.println(parse(input));
        // 输出：
        // {VALUE={123=}, OUTERVALUE={INNERVALUE=123, OTHERVALUE=456},
        //  SIMPLE={SINGLE=}, COMPLEX={A=1, B=2, C=3}}
    }
}

? 核心要点说明

[^()]* 替代 .*?：INNER_PATTERN 使用 ([^()]*) 而非 (.*?)，确保只匹配最内层无括号的值（如 INNERVALUE(123) 中的 123），避免跨嵌套误匹配；
asPredicate().test(...) 巧用：轻量判断字符串是否可能含嵌套结构，避免无效 Matcher.find() 循环，提升可读性与性能；
逐行处理（.lines()）：契合输入为多行键值对的典型场景，天然隔离不同记录，规避跨行匹配复杂度；
空值语义明确：innerMap.put(valueContent, "") 显式体现“原子值 → 键，空串 → 值”的约定，符合需求输出 {123=}。