我正在尝试编写一个剧透识别系统，以便将字符串中的任何剧透都替换为指定的剧透字符。

我想匹配一个用方括号括起来的字符串，这样方括号内的内容就是捕获组1，并且包括括号在内的整个字符串就是匹配项。

我目前正在使用\[(.*?]*)\]，对这个答案中的表达式稍作修改here，因为我也希望嵌套方括号成为捕获组 1 的一部分。

该表达式的问题在于，尽管它有效并匹配以下内容：

• Jim ate a [sandwich]火柴[sandwich] with sandwich作为第 1 组
• Jim ate a [sandwich with [pickles and onions]]火柴[sandwich with [pickles and onions]] with sandwich with [pickles and onions]作为第 1 组
• [[[[]火柴[[[[] with [[[作为第 1 组
• []]]]火柴[]]]] with ]]]作为第 1 组

但是，如果我想匹配以下内容，它不会按预期工作：

• Jim ate a [sandwich with [pickles] and [onions]] matches both:
  • [sandwich with [pickles] with sandwich with [pickles作为第 1 组
  • [onions]] with onions]作为第 1 组

我应该使用什么表达式才能匹配[sandwich with [pickles] and [onions]] with sandwich with [pickles] and [onions]作为第 1 组？

EDIT:

由于在Java中使用正则表达式似乎不可能实现这一点，是否有替代解决方案？

EDIT 2:

我还希望能够按找到的每个匹配项分割字符串，因此正则表达式的替代方案将更难实现，因为String.split(regex)方便。这是一个例子：

• Jim ate a [sandwich] with [pickles] and [dried [onions]] matches all:
  • [sandwich] with sandwich作为第 1 组
  • [pickles] with pickles作为第 1 组
  • [dried [onions]] with dried [onions]作为第 1 组

分割句子应该是这样的：

Jim ate a
with
and

更直接的解决方案

这个解决方案将省略空子串或仅包含空格的子串

public static List<String> getStrsBetweenBalancedSubstrings(String s, Character markStart, Character markEnd) {
    List<String> subTreeList = new ArrayList<String>();
    int level = 0;
    int lastCloseBracket= 0;
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
            if (c == markStart) {
                    level++;
                    if (level == 1 && i != 0 && i!=lastCloseBracket &&
                        !s.substring(lastCloseBracket, i).trim().isEmpty()) {
                            subTreeList.add(s.substring(lastCloseBracket, i).trim());
                }
            }
        } else if (c == markEnd) {
            if (level > 0) { 
                level--;
                lastCloseBracket = i+1;
            }
            }
    }
    if (lastCloseBracket != s.length() && !s.substring(lastCloseBracket).trim().isEmpty()) {
        subTreeList.add(s.substring(lastCloseBracket).trim());  
    }
    return subTreeList;
}

然后，将其用作

String input = "Jim ate a [sandwich][ooh] with [pickles] and [dried [onions]] and ] [an[other] match] and more here";
List<String> between_balanced =  getStrsBetweenBalancedSubstrings(input, '[', ']');
System.out.println("Result: " + between_balanced);
// => Result: [Jim ate a, with, and, and ], and more here]

原始答案（更复杂，显示了提取嵌套括号的方法）

您还可以提取平衡括号内的所有子字符串，然后用它们分割：

String input = "Jim ate a [sandwich] with [pickles] and [dried [onions]] and ] [an[other] match]";
List<String> balanced = getBalancedSubstrings(input, '[', ']', true);
System.out.println("Balanced ones: " + balanced);
List<String> rx_split = new ArrayList<String>();
for (String item : balanced) {
    rx_split.add("\\s*" + Pattern.quote(item) + "\\s*");
}
String rx = String.join("|", rx_split);
System.out.println("In-betweens: " + Arrays.toString(input.split(rx)));

这个函数会找到所有[]- 平衡子串：

public static List<String> getBalancedSubstrings(String s, Character markStart, 
                                     Character markEnd, Boolean includeMarkers) {
    List<String> subTreeList = new ArrayList<String>();
    int level = 0;
    int lastOpenBracket = -1;
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if (c == markStart) {
            level++;
            if (level == 1) {
                lastOpenBracket = (includeMarkers ? i : i + 1);
            }
        }
        else if (c == markEnd) {
            if (level == 1) {
                subTreeList.add(s.substring(lastOpenBracket, (includeMarkers ? i + 1 : i)));
            }
            if (level > 0) level--;
        }
    }
    return subTreeList;
}

See IDEONE演示

代码执行结果：

Balanced ones: ['[sandwich], [pickles], [dried [onions]]', '[an[other] match]']
In-betweens: ['Jim ate a', 'with', 'and', 'and ]']

学分：getBalancedSubstrings是基于彼得·默里·拉斯特的答案如何在Java正则表达式中分割这个“树状”字符串？ post.