199

我试图理解这个代码块。在第一个中，我们在表达式中寻找什么？

我的理解是，它是任何字符（0 次或多次 *）后跟 0 到 9 之间的任何数字（一次或多次 +）后跟任何字符（0 次或多次 *）。

执行此操作时，结果为：

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

有人可以和我一起经历吗？

使用捕获组有什么好处？

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

public class RegexTut3 {

    public static void main(String args[]) {
        String line = "This order was placed for QT3000! OK?"; 
        String pattern = "(.*)(\\d+)(.*)";

        // Create a Pattern object
        Pattern r = Pattern.compile(pattern);

        // Now create matcher object.
        Matcher m = r.matcher(line);

        if (m.find()) {
            System.out.println("Found value: " + m.group(0));
            System.out.println("Found value: " + m.group(1));
            System.out.println("Found value: " + m.group(2));
        } else {
            System.out.println("NO MATCH");
        }
    }

}
4

4 回答 4

280

您遇到的问题是量词的类型。您在第一组中使用了一个贪婪的量词（索引1 - 索引 0 代表整个Pattern），这意味着它将尽可能多地匹配（并且由于它是任何字符，它将匹配尽可能多的字符为了满足下一组的条件）。

简而言之，.*只要下一组\\d+可以匹配某些内容（在本例中为最后一个数字），您的第一组就可以匹配任何内容。

根据第三组，它将匹配最后一位数字之后的任何内容。

如果您将其更改为第一组中不情愿的量词，您将得到我想您所期望的结果，即3000部分。

注意第一组中的问号。 

String line = "This order was placed for QT3000! OK?";
Pattern pattern = Pattern.compile("(.*?)(\\d+)(.*)");
Matcher matcher = pattern.matcher(line);
while (matcher.find()) {
    System.out.println("group 1: " + matcher.group(1));
    System.out.println("group 2: " + matcher.group(2));
    System.out.println("group 3: " + matcher.group(3));
}

输出：

group 1: This order was placed for QT
group 2: 3000
group 3: ! OK?

有关 Java 的更多信息，请Pattern 点击此处。

最后，捕获组由圆括号分隔，并提供一种非常有用的方式来使用反向引用（除其他外），一旦您Pattern与输入匹配。

在 Java 6 中，组只能通过它们的顺序来引用（注意嵌套组和排序的微妙之处）。

在 Java 7 中这要容易得多，因为您可以使用命名组。

于 2013-07-31T11:51:58.453 回答
19

这完全没问题。

  1. 第一组 ( m.group(0)) 始终捕获正则表达式所涵盖的整个区域。在这种情况下，它是整个字符串。
  2. 正则表达式默认是贪婪的，这意味着第一组在不违反正则表达式的情况下尽可能多地捕获。（(.*)(\\d+)您的正则表达式的第一部分）涵盖...QT300第一组中的 int 和第二组0中的 the。
  3. 您可以通过使第一组非贪婪来快速解决此问题：更改(.*)为(.*?).

有关贪婪与懒惰的更多信息，请查看此网站。

于 2013-07-31T11:51:54.057 回答
6

你的理解是正确的。但是，如果我们遍历：

  • (.*)会吞下整根弦；
  • 它需要返回字符以便(\\d+)满足（这就是为什么0被捕获，而不是被捕获3000）；
  • 最后一个(.*)将捕获其余部分。

但是，我不确定作者的初衷是什么。

于 2013-07-31T11:49:51.180 回答
5

从文档：

Capturing groups</a> are indexed from left
 * to right, starting at one.  Group zero denotes the entire pattern, so
 * the expression m.group(0) is equivalent to m.group().

所以捕获组 0 发送整行。

于 2013-07-31T11:51:46.850 回答