Java正则表达式匹配外部括号

假设有一个字符串：

“第一个选项第二个选项选择{aaaaaa/bbbbb/ccccccc}{eeeeee/fffff/ggggg}其他字符串”

现在我想得到3

ArrayList

一个用于“”内的字符串：

一个用于“{}”内的字符串：

一个用于外部/{}和内部/{}：

{“第一选项”、“第二选项”、“选择”、“其他字符串”}。

我知道我可以用如下代码在大括号中获取字符串：

    String Str = "first option<option 1/option 2/option 3>second option<option 5/option 6/option 7>selection{aaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}other string"`;
    Pattern patt = Pattern.compile("<(.*?)>");
    Matcher mtchr_r = patt.matcher(Str);
    while (mtchr_r.find()){
        String ssssssss = mtchr_r.group ();
    }

String Str=“第一选项第二选项选择{aaaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}其他字符串”`；
Pattern patt=Pattern.compile（“”）；
匹配器mtchr\u r=匹配器（Str）；
while（mtchr.find（））{
字符串ssss=mtchr_r.group（）；
}

但是如何匹配大括号外的字符串呢？此外，如何按顺序获得第三个ArrayList

(?<=<)[^>]*(?=>)|(?<={)[^}]*(?=})

---

一个选项是有一个匹配所有情况的正则表达式，例如，

（]*>）|（\{[^}]*}）|（[^{一个选项是有一个匹配所有情况的正则表达式，例如，
（]*>）|（\{[^}]*}）|（[^{一个选项是有一个匹配所有情况的正则表达式，例如，
（]*>）（\[^}*>）（\*>）|([^{一个选项是使用一个匹配所有情况的正则表达式，例如，
（]*>）|（\{[^}]*\}）|（[^{我认为对于第三个，只使用一个正则表达式是不正确的。我建议为您的三个数组创建三种不同的模式

String Str = "first option<option 1/option 2/option 3>second option<option 5/option 6/option 7>selection{aaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}other string";
        Pattern inside = Pattern.compile("<(.*?)>");
        Pattern insideBrackets = Pattern.compile("\\{(.+?)\\}");
        Pattern inAndOutside = Pattern.compile("(<[^>]*>)|(\\{[^}]*\\})|([^{<]*)");
        Matcher matcher1 = inside.matcher(Str);
        Matcher matcher2 = insideBrackets.matcher(Str);
        Matcher matcher3 = inAndOutside.matcher(Str);
        ArrayList<String> array1 = new ArrayList<>();
        ArrayList<String> array2 = new ArrayList<>();
        ArrayList<String> array3 = new ArrayList<>();
        boolean found = false;
        while (matcher1.find()) {
            array1.add(matcher1.group(1));
            System.out.println(matcher1.group(1));
            found = true;
        }

        while (matcher2.find()) {
            array2.add(matcher2.group(1));
            System.out.println(matcher2.group(1));
            found = true;
        }

        while (matcher3.find()) {
            array3.add(matcher3.group(1));
            System.out.println(matcher3.group(1));
            found = true;
        }

        if (!found) {
            System.out.println("No match found");
        }
    }

String Str=“第一选项第二选项选择{aaaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}其他字符串”；
内部模式=Pattern.compile（“”）；
Pattern-insideBrackets=Pattern.compile（“\\{（+.+？）\\}”）；
Pattern inAndOutside=Pattern.compile（“（]*>）|（\{[^}]*\}）|（[^{我认为对于第三个，只使用一个正则表达式是不正确的。我建议为三个数组创建三种不同的模式

String Str = "first option<option 1/option 2/option 3>second option<option 5/option 6/option 7>selection{aaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}other string";
        Pattern inside = Pattern.compile("<(.*?)>");
        Pattern insideBrackets = Pattern.compile("\\{(.+?)\\}");
        Pattern inAndOutside = Pattern.compile("(<[^>]*>)|(\\{[^}]*\\})|([^{<]*)");
        Matcher matcher1 = inside.matcher(Str);
        Matcher matcher2 = insideBrackets.matcher(Str);
        Matcher matcher3 = inAndOutside.matcher(Str);
        ArrayList<String> array1 = new ArrayList<>();
        ArrayList<String> array2 = new ArrayList<>();
        ArrayList<String> array3 = new ArrayList<>();
        boolean found = false;
        while (matcher1.find()) {
            array1.add(matcher1.group(1));
            System.out.println(matcher1.group(1));
            found = true;
        }

        while (matcher2.find()) {
            array2.add(matcher2.group(1));
            System.out.println(matcher2.group(1));
            found = true;
        }

        while (matcher3.find()) {
            array3.add(matcher3.group(1));
            System.out.println(matcher3.group(1));
            found = true;
        }

        if (!found) {
            System.out.println("No match found");
        }
    }

String Str=“第一选项第二选项选择{aaaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}其他字符串”；
内部模式=Pattern.compile（“”）；
Pattern-insideBrackets=Pattern.compile（“\\{（+.+？）\\}”）；
Pattern inAndOutside=Pattern.compile（“（]*>）|（\{[^}]*\}）|（[^{我认为对于第三个，只使用一个正则表达式是不正确的。我建议为三个数组创建三种不同的模式

String Str = "first option<option 1/option 2/option 3>second option<option 5/option 6/option 7>selection{aaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}other string";
        Pattern inside = Pattern.compile("<(.*?)>");
        Pattern insideBrackets = Pattern.compile("\\{(.+?)\\}");
        Pattern inAndOutside = Pattern.compile("(<[^>]*>)|(\\{[^}]*\\})|([^{<]*)");
        Matcher matcher1 = inside.matcher(Str);
        Matcher matcher2 = insideBrackets.matcher(Str);
        Matcher matcher3 = inAndOutside.matcher(Str);
        ArrayList<String> array1 = new ArrayList<>();
        ArrayList<String> array2 = new ArrayList<>();
        ArrayList<String> array3 = new ArrayList<>();
        boolean found = false;
        while (matcher1.find()) {
            array1.add(matcher1.group(1));
            System.out.println(matcher1.group(1));
            found = true;
        }

        while (matcher2.find()) {
            array2.add(matcher2.group(1));
            System.out.println(matcher2.group(1));
            found = true;
        }

        while (matcher3.find()) {
            array3.add(matcher3.group(1));
            System.out.println(matcher3.group(1));
            found = true;
        }

        if (!found) {
            System.out.println("No match found");
        }
    }

String Str=“第一选项第二选项选择{aaaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}其他字符串”；
内部模式=Pattern.compile（“”）；
Pattern-insideBrackets=Pattern.compile（“\\{（+.+？）\\}”）；
Pattern inAndOutside=Pattern.compile（“（]*>）|（\{[^}]*\}）|（[^{我认为对于第三个，只使用一个正则表达式是不正确的。我建议为三个数组创建三种不同的模式

String Str = "first option<option 1/option 2/option 3>second option<option 5/option 6/option 7>selection{aaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}other string";
        Pattern inside = Pattern.compile("<(.*?)>");
        Pattern insideBrackets = Pattern.compile("\\{(.+?)\\}");
        Pattern inAndOutside = Pattern.compile("(<[^>]*>)|(\\{[^}]*\\})|([^{<]*)");
        Matcher matcher1 = inside.matcher(Str);
        Matcher matcher2 = insideBrackets.matcher(Str);
        Matcher matcher3 = inAndOutside.matcher(Str);
        ArrayList<String> array1 = new ArrayList<>();
        ArrayList<String> array2 = new ArrayList<>();
        ArrayList<String> array3 = new ArrayList<>();
        boolean found = false;
        while (matcher1.find()) {
            array1.add(matcher1.group(1));
            System.out.println(matcher1.group(1));
            found = true;
        }

        while (matcher2.find()) {
            array2.add(matcher2.group(1));
            System.out.println(matcher2.group(1));
            found = true;
        }

        while (matcher3.find()) {
            array3.add(matcher3.group(1));
            System.out.println(matcher3.group(1));
            found = true;
        }

        if (!found) {
            System.out.println("No match found");
        }
    }

String Str=“第一选项第二选项选择{aaaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}其他字符串”；
内部模式=Pattern.compile（“”）；
Pattern-insideBrackets=Pattern.compile（“\\{（+.+？）\\}”）；
Pattern inAndOutside=Pattern.compile（（]*>）|（\{[^}]*\}）|（[^{使用
\G
（断言下一个匹配从最后一个匹配结束的地方开始），可以一次完成：

\G(?:[^<>{}]++|<(?<pointy>[^<>]++)>|\{(?<curly>[^{}]++)\})

在Java的早期版本（6及以下版本）中，您可以使用
Matcher.start
或
Matcher.end
方法检查捕获组是否捕获了某些内容

但是，在Java 7中，命名捕获组缺少相应的
Matcher.start
和
Matcher.end
方法（只有
Matcher.group
可用）。这两个方法后来在Java 8中添加。
使用
\G
（断言下一个匹配从最后一个匹配结束的位置开始），可以一次完成此操作：

\G(?:[^<>{}]++|<(?<pointy>[^<>]++)>|\{(?<curly>[^{}]++)\})

在Java的早期版本（6及以下版本）中，您可以使用
Matcher.start
或
Matcher.end
方法检查捕获组是否捕获了某些内容

但是，在Java 7中，命名捕获组缺少相应的
Matcher.start
和
Matcher.end
方法（只有
Matcher.group
可用）。这两个方法后来在Java 8中添加。
使用
\G
（断言下一个匹配从最后一个匹配结束的位置开始），可以一次完成此操作：

\G(?:[^<>{}]++|<(?<pointy>[^<>]++)>|\{(?<curly>[^{}]++)\})

在Java的早期版本（6及以下版本）中，您可以使用
Matcher.start
或
Matcher.end
方法检查捕获组是否捕获了某些内容

但是，在Java 7中，命名捕获组缺少相应的
Matcher.start
和
Matcher.end
方法（只有
Matcher.group
可用）。这两个方法后来在Java 8中添加。
使用
\G
（断言下一个匹配从最后一个匹配结束的位置开始），可以一次完成此操作：

\G(?:[^<>{}]++|<(?<pointy>[^<>]++)>|\{(?<curly>[^{}]++)\})

在Java的早期版本（6及以下版本）中，您可以使用
Matcher.start
或
Matcher.end
方法检查捕获组是否捕获了某些内容

但是，在Java 7中，缺少用于命名捕获组的相应的
Matcher.start
和
Matcher.end
方法（只有
Matcher.group
可用）。这两个方法后来被添加到Java 8中。
我认为拥有多个正则表达式是一个不错的选择。我认为拥有多个正则表达式是一个不错的选择。我认为拥有多个正则表达式是一个不错的选择。我认为拥有多个正则表达式是一个不错的选择。我使用
Pattern.compile（[^{}]+\\\{（？[^{}]+）\}）获得相同的结果
。
\\G
完成了什么？@Keppil：当输入无效时，强制正则表达式立即失败。它至少提供了一种检测错误输入的机制，而不仅仅是通过它。@Keppil:I匹配分隔符
import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class SO28210525 {
    private static final Pattern re = Pattern.compile("\\G(?:[^<>{}]++|<(?<pointy>[^<>]++)>|\\{(?<curly>[^{}]++)\\})");

    public static void main(String[] args) {
        String input = "first option<option 1/option 2/option 3>second option<option 5/option 6/option 7>selection{aaaaa/bbbbb/ccccc}{eeeeee/fffff/ggggg}other string";
        Matcher matcher = re.matcher(input);

        ArrayList<String> tokens = new ArrayList<String>();
        ArrayList<String> curly = new ArrayList<String>();
        ArrayList<String> pointy = new ArrayList<String>();

        int lastIndex = 0;

        while (matcher.find()) {
            tokens.add(matcher.group(0));

            String inCurly = matcher.group("curly");
            if (inCurly != null) {
                curly.add(inCurly);
            }

            String inPointy = matcher.group("pointy");
            if (inPointy != null) {
                pointy.add(inPointy);
            }

            lastIndex = matcher.end(0);
        }

        if (lastIndex != input.length()) {
            System.err.println("Invalid input");
        } else {

            System.out.println(tokens);
            System.out.println(curly);
            System.out.println(pointy);
        }
    }

}