正则表达式拆分键=值

Question

我有一个这样的字符串：

KEY1=Value1, KE_Y2=[V@LUE2A, Value2B], Key3=, KEY4=V-AL.UE4, KEY5={Value5}

我需要拆分它以获得带有键值对的 Map。 [] 中的值应作为单个值传递（KE_Y2 是键，[V@LUE2A, Value2B] 是值）。

我应该使用什么正则表达式来正确拆分它？

Answer 1

第一次拆分有一个神奇的正则表达式：

String[] pairs = input.split(", *(?![^\\[\\]]*\\])");

然后用简单的“=”分割每个键/值：

for (String pair : pairs) {
    String[] parts = pair.split("=");
    String key = parts[0];
    String value = parts[1];
}

---

把它们放在一起：

Map<String, String> map = new HashMap<String, String>();
for (String pair : input.split(", *(?![^\\[\\]]*\\])")) {
    String[] parts = pair.split("=");
    map.put(parts[0], parts[1]);
}

瞧！

---

魔术正则表达式的解释：

正则表达式表示“逗号后跟任意数量的空格（因此键名没有前导空格），但前提是遇到的下一个括号不是右括号”

Answer 2

这个怎么样：

Map<String, String> map = new HashMap<String, String>();
Pattern regex = Pattern.compile(
    "(\\w+)        # Match an alphanumeric identifier, capture in group 1\n" +
    "=             # Match =                                             \n" +
    "(             # Match and capture in group 2:                       \n" +
    " (?:          # Either...                                           \n" +
    "  \\[         #  a [                                                \n" +
    "  [^\\[\\]]*  #  followed by any number of characters except [ or ] \n" +
    "  \\]         #  followed by a ]                                    \n" +
    " |            # or...                                               \n" +
    "  [^\\[\\],]* #  any number of characters except commas, [ or ]     \n" +
    " )            # End of alternation                                  \n" +
    ")             # End of capturing group", 
    Pattern.COMMENTS);
Matcher regexMatcher = regex.matcher(subjectString);
while (regexMatcher.find()) {
    map.put(regexMatcher.group(1), regexMatcher.group(2));
} 

Answer 3

从@achintya-jha 的回答开始。当你拆分一个字符串时，它会给你一个数组（或类似它的东西），所以你可以遍历这对键/值，然后你进行第二次拆分，这应该给你另一个大小为 2 的数组；然后，您将第一个元素用作键，将第二个元素用作值。

编辑：

我没有在 JAVA 中找到我的意思的有用链接（请参阅问题中的 cmets），（尽管有很多用于 C/C++ 的链接）所以我写了它：

Map<String, String> map = new HashMap<String, String>();
String str = "KEY1=Value1, KE_Y2=[V@LUE2A, Value2B]], Key3=, KEY4=V-AL.UE4, KEY5={Value5}";     


final String openBrackets =  "({[<";
final String closeBrackets = ")}]>";

String buffer = "";
int state = 0;
int i = 0;      
Stack<Integer> stack = new Stack<Integer>(); //For the brackets

String key = "";


while(  i < str.length() ) {

    char c = str.charAt(i);


    //Skip any whitespace
    if( " \t\n\r".indexOf(c) > -1 ) {
        ++i;
        continue;
    }


    switch(state) {

    //Reading Key
    case 0:
        if( c != '=' ) {
            buffer += c;
        } else {
            //Go read a value.
            key = buffer;
            state = 1;
            buffer = "";
        }
        ++i;
        break;

    //Reading value
    case 1:

        //Opening bracket
        int pos = openBrackets.indexOf(c);
        if( pos != -1 ) {
            stack.push(pos);
            ++i;
            break;
        }

        //Closing bracket
        pos = closeBrackets.indexOf(c);
        if( pos != -1 ) {

            if( stack.size() == 0 ) {
                throw new RuntimeException("Syntax error: Unmatched closing bracket '" + c + "'" );
            }

            int pos2 = stack.pop();
            if( pos != pos2 ) {
                throw new RuntimeException("Syntax error: Unmatched closing bracket, expected a '"
                        + closeBrackets.charAt(pos2) + "' got '" + c );             
            }
            ++i;
            break;
        }

        //Handling separators 
        if( c == ',' ) {
            if( stack.size() == 0 ) {
                //Put the pair in the map.
                map.put(key, buffer);

                //Go read a new Key.
                state = 0;
                buffer = "";
                ++i;
                break;
            }                       
        }

        //else
            buffer += c;
            ++i;


        } //switch
} //while

Answer 4

1. 用 String.split(","); 分割给定的字符串
2. 现在用 String.split("="); 分割数组的每个元素；