为什么在java正则表达式中只能找到一个组

我正在编写一个关于正则表达式的非常简单的示例代码，但未能使用

组

正则表达式是：

rowspan=（[\\d]+）

输入字符串为：

x.x.x

我正在在线regex引擎上测试它，很明显可以捕获组

66

，请参见下面的快照：

基于javadoc

组0表示整个模式，因此表达式m.Group（0）为 相当于m.group（）

所以我认为应该有两个组，组0应该是

rowspan=66

，组1应该是

66

。然而，我能从下面的代码中得到的只是前者

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

public class Test {

    public static void main(String args[]){
        String input = "<td rowspan=66>x.x.x</td> ";
        String regex = "rowspan=([\\d]+)";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);
        if(matcher.find()){
            for(int i = 0; i < matcher.groupCount(); i++){
                System.out.println(matcher.group(i));
            }
        }
    }

}

提前感谢您的帮助。

试试看

for(int i = 0; i <= matcher.groupCount(); i++){
    System.out.println(matcher.group(i));
}

for（inti=0；iTry

for（int i=0；i我认为您的代码的问题与理解
Matcher\groupCount
方法的功能有关。从：

返回此匹配器模式中的捕获组数。
组0按约定表示整个图案。它不包括在此计数中

换句话说，假设您有一个捕获组，那么您的
for
循环只会迭代一次。但是您打印的是第一个组，即整个模式：

for (int i=0; i < matcher.groupCount(); i++) {
    System.out.println(matcher.group(i));
}

for（int i=0；i

相反，只要在匹配时进行迭代，然后访问所需的组。我看不出对捕获组进行硬编码有多大问题，因为如果出现匹配，根据定义，该匹配中的捕获组也应该存在

String input = "<td rowspan=66>x.x.x</td> ";
String regex = "rowspan=(\\d+)";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
while (matcher.find()) {
    System.out.println(matcher.group(0));
    System.out.println(matcher.group(1));
}

String input=“x.x.x”；
String regex=“rowspan=（\\d+）；
Pattern=Pattern.compile（regex）；
Matcher Matcher=pattern.Matcher（输入）；
while（matcher.find（））{
System.out.println（matcher.group（0））；
系统输出println（匹配器组（1））；
}


注意：您的模式看起来也有点奇怪。如果您想通过
\\d
匹配数字，则不必将其放入字符类。因此我使用了模式
行span=（\\d+）
在我的代码中。
我认为您的代码的问题与理解
Matcher\groupCount
方法的功能有关。从：

返回此匹配器模式中的捕获组数。
组0按约定表示整个图案。它不包括在此计数中

换句话说，假设您有一个捕获组，那么您的
for
循环只会迭代一次。但是您打印的是第一个组，即整个模式：

for (int i=0; i < matcher.groupCount(); i++) {
    System.out.println(matcher.group(i));
}

for（int i=0；i

相反，只要在匹配时进行迭代，然后访问所需的组。我看不出对捕获组进行硬编码有多大问题，因为如果出现匹配，根据定义，该匹配中的捕获组也应该存在

String input = "<td rowspan=66>x.x.x</td> ";
String regex = "rowspan=(\\d+)";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
while (matcher.find()) {
    System.out.println(matcher.group(0));
    System.out.println(matcher.group(1));
}

String input=“x.x.x”；
String regex=“rowspan=（\\d+）；
Pattern=Pattern.compile（regex）；
Matcher Matcher=pattern.Matcher（输入）；
while（matcher.find（））{
System.out.println（matcher.group（0））；
系统输出println（匹配器组（1））；
}


注意：您的模式看起来也有点奇怪。如果您想通过
\\d
匹配数字，则不必将其放入字符类。因此我使用了模式
行span=（\\d+）
在我的代码中。
我一直是正则表达式命名组的粉丝，Java通过特殊的组构造
（？）支持这一点
。这使得检索正确的组更容易，而且如果以后在表达式的前面添加另一个组，也不会把事情搞砸。它还有一个副作用，即消除了有关
匹配器.groupCount（）的任何混淆。

将正则表达式更改为
rowspan=（？[\\d]+）

以及您的代码：

public class Test {

    public static void main(String args[]){
        String input = "<td rowspan=66>x.x.x</td> ";
        String regex = "rowspan=(?<rowspan>[\\d]+)";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);
        if(matcher.find()){
            System.out.println("Entire match: " + matcher.group());
            System.out.println("Row span: " + matcher.group("rowspan"));
        }
    }

}

我一直喜欢正则表达式的命名组，Java通过特殊的组构造
（？）来支持这一点
。这使得检索正确的组更容易，而且如果以后在表达式的前面添加另一个组，也不会把事情搞砸。它还有一个副作用，即消除了有关
匹配器.groupCount（）的任何混淆。

将正则表达式更改为
rowspan=（？[\\d]+）

以及您的代码：

public class Test {

    public static void main(String args[]){
        String input = "<td rowspan=66>x.x.x</td> ";
        String regex = "rowspan=(?<rowspan>[\\d]+)";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);
        if(matcher.find()){
            System.out.println("Entire match: " + matcher.group());
            System.out.println("Row span: " + matcher.group("rowspan"));
        }
    }

}

我不认为这完全是上述问题的重复。此模式似乎包含组：“返回此匹配器模式中捕获组的数量。组零表示按照约定的整个模式。它不包括在此计数中。”并且是。。。（停止搜索，因为有人认为这不是duplicae）我不认为这是上述问题的完全重复。此模式似乎包含组：：“返回此匹配器模式中捕获组的数量。组0按约定表示整个模式。它不包括在此计数中。”是重复的，，…（停止搜索，因为有人认为这不是小白鼠）嗯，这很有帮助。这里的groupCount真的让人困惑。谢谢。嗯，这很有帮助。这里的groupCount真的让人困惑。谢谢。很好的解决方案/建议！很好的解决方案/建议！