java - 多个相似的正则表达式，有更好的方法吗？

Question

我有一个由几个部分组成的文件，这些部分由特定的字符串和字母分割，如下所示:

--673b0e57-A--
content here
--673b0e57-B--
content here
--673b0e57-C--
content here
--673b0e57-F--
content here

我创建了一个方法来将其解析为一个对象，如下所示:

for (String line:file) {
            if ((line.matches(".*-{1}[A]-{2}$") || currentPart == "A") && (!line.matches(".*-{1}[B|C|E|F|H|I|K|Z]-{2}$")) ) {
                currentPart = "A";
                //do stuff
            } else if ((line.matches(".*-{1}[B]-{2}$") || currentPart == "B") && (!line.matches(".*-{1}[C|E|F|H|I|K|Z]-{2}$")) ) {
                currentPart = "B";
                //do stuff
            } else if((line.matches(".*-{1}[C]-{2}$") || currentPart == "C") && (!line.matches(".*-{1}[E|F|H|I|K|Z]-{2}$")) ) {
                currentPart = "C";
                //do stuff
            } else if((line.matches(".*-{1}[E]-{2}$") || currentPart == "E") && (!line.matches(".*-{1}[F|H|I|K|Z]-{2}$")) ) {
                currentPart = "E";
                //do stuff
            } else if((line.matches(".*-{1}[F]-{2}$") || currentPart == "F") && (!line.matches(".*-{1}[H|I|K|Z]-{2}$")) ) {
                currentPart = "F";
                //do stuff
            } else if((line.matches(".*-{1}[H]-{2}$") || currentPart == "H") && (!line.matches(".*-{1}[I|K|Z]-{2}$")) ) {
                currentPart = "H";
                //do stuff
            } else if((line.matches(".*-{1}[I]-{2}$") || currentPart == "I") && (!line.matches(".*-{1}[K|Z]-{2}$")) ) {
                currentPart = "I";
                //do stuff
            } else if((line.matches(".*-{1}[K]-{2}$") || currentPart == "K") && (!line.matches(".*-{1}[Z]-{2}$")) ) {
                currentPart = "K";
                //do stuff
            } else if((line.matches(".*-{1}[Z]-{2}$") || currentPart == "Z")) {
                currentPart = "Z";
                //do stuff
            } else {
                System.out.println("No line marker to be found while parsing file!");
            }
        }

基本上发生的事情是:1.检查是否A并记住是否是2. 检查是否还有其他字母，如果没有则继续A，否则转到B3.等等

但我发现这个解决方案有点难看。有一个更好的方法吗？这可以是在可读性或内存使用方面。我认识的人告诉我使用 java.util.regex.Pattern。但据我所知，您仍然需要执行相同的正则表达式，因此似乎根本没有任何好处。我也许错过了什么吗？

亲切的问候

编辑:好的，我查看了 @brso05 提出的解决方案和 @Jeutnarg 编写的解决方案，结果如下:

String[] strings = new String[]{"--673b0e57-A--", "blah", "--673b0e57-B--", "something", "hello"};
        Pattern p = Pattern.compile("--.*-([ABCEFHIKZ])--");
        String currentPart = null;
        StringBuilder builder = new StringBuilder();
        for(String s : strings)
        {
            Matcher m = p.matcher(s);
            if(m.find())
            {
                if(currentPart != null){
                    storeData(builder.toString(), currentPart);
                    System.out.println(builder.toString());
                }
                currentPart = m.group(1);
                System.out.println("Current part is "+m.group(1));
            }else{
                if(currentPart != null){
                    builder.append(s);
                }
            }
        }
        storeData(builder.toString(), currentPart);
        System.out.println(builder.toString());
    }

private void storeData(String data, String part){
        switch (part){
            case "A": //objectA
                break;
            case "B": //objectB
                break;
            ...
        }
    }

我认为它看起来好多了。没有那么多需要加载的模式等。还有什么更有趣的想法可以添加到此吗？

Answer 1

正如 brrso05 所指出的，捕获组可以完成您想要做的事情。您使用捕获组(括号包围的部分)创建一个模式，然后为每个字符串创建一个 Matcher 对象。调用 find(或 matches)来确定字符串是否有效，然后使用 group(X) 方法来获取匹配项。

这里有一些代码可以完成您想要做的事情。您可能会注意到 group(X) 是 1 索引的，而不是 0 索引的。

String[] strings = new String[]{"hello", "blah", "--673b0e57-A--", "something", "--673b0e57-B--"};
    Pattern p = Pattern.compile("--.*-(\\w)--");
    for(String s : strings)
    {
        Matcher m = p.matcher(s);
        if(m.find())
        {
            System.out.println("Current part is "+m.group(1));
        }
    }

买者自负 - 我创建的模式将匹配一些您可能不想匹配的内容，例如小写字母。在生产或重要的地方尝试之前，请先进行自己的测试(我建议使用 regex101.com 来快速测试正则表达式)。