正则表达式的捕获组与非捕获组

在工作中，经常会用到正则表达式，这篇文章并不是讲正则表达式的基本使用，则是侧重讲正则表达式的捕获组与非捕获组。

所用语言均为Java 。

一、捕获组

捕获组，通过括号将正则表达式括起来，正则表达式匹配成功后，可以通过组号来获取相应的匹配内容。如，我们想获取数字中的整数部分和小数部分，可以用这样的正则表达式。

    @Test
    public void testCaptureGroup(){
        String regex = "(\\d+)\\.(\\d+)";
        String content = "12.98";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(content);
        if(matcher.find()){
            System.out.println("数字：" + matcher.group());
            System.out.println("整数部分 ： " + matcher.group(1));
            System.out.println("小数部分 ： " + matcher.group(2));
        }
    }

这里用Matcher 中的 group(1)，可以获取整数部分，用group(2)可以获取小数部分，如果group()中不填数字，则默认获取整个匹配组，即整个数字。

这里，我们用序号来获取相应的捕获组，但其实也可能给每个捕获组命名，通过名称来获取捕获组。这种方式可以查阅相关资料，在此不详细展开。

 

二、非捕获组

非捕获组，即不要获取括号里的内容。

问1：既然不要获取括号里的内容，那在正则表达式中不加括号不就可以吗？

答1：正则表达式中的括号，不仅用来分组，有些场景下，不加括号并不能写出你想要的效果。

举个例子：String regex = "12(a|b)12";

这个正则表达式，匹配的是开头和结尾是“12”，中间字符是a或b，如果没有括号，那就就成：

String regex = "12a|b12";

匹配的结果就是字符“12a”或“b12”。

 

问2：那如果加括号后，我不用group()获取分组，不也可以吗？

答：语法上没错，但用了括号来捕获字符串，则会占用一定的内存去记录这些捕获组，如果我们实际上不需要这些捕获组，那可以不让内存记录着，提高程序效率 。

 

非捕获组有以下几种情况：

1. (?:)   非捕获组

2. (?=) 肯定式向前查找

3. (?!) 否定式向前查找

4. (?<=) 肯定式向后查找

5. (?

用了非捕获组，如果再用group(int index) 去获取匹配的内容，则会报错。

下面会结合例子进行讲解，例子的场景可能不会很恰当，只是为了说明问题。

 

先讲第1个最简单的： (?:)  

1. (?:)   非捕获组

例子：获取abc或adc字样的字符串。

捕获组的例子如下：

    @Test
    public void testCapture(){
        String regex = "a(b|d)c";
        String content = "adcdddd";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(content);
        if(matcher.find()){
            System.out.println("用group(1)获取第一个括号的内容 ：" + matcher.group(1));
        }
    }

如果我们并不需要获取括号里的内容，那可以把这个括号写成一个非捕获组，如下：

    @Test
    public void testNotCapture(){
        String regex = "a(?:b|d)c";
        String content = "adcdddd";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(content);
        if(matcher.find()){
            System.out.println("匹配到的内容 ：" + matcher.group(1));
        }
    }

注意，运行此程序，会报以下错，表示并没有group1 这个组。这是因为我们用了非捕获组，括号里的内容就不会进行记录，用group(1)自然就获取不到。

java.lang.IndexOutOfBoundsException: No group 1

	at java.util.regex.Matcher.group(Matcher.java:538)
	at regex.RegexTest.testBrackets2(RegexTest.java:44)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:497)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
	at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
	at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
	at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)

2. (?=) 肯定式向前查找

这里所说的向前，是指字符串从左到右的方向。如，查找被  包围着的字符串。

我们可以先查询到字符串，再向前查。

    @Test
    public void testPositiveLookForward() {
        String regex = "\\(.*)(?=\\)";
        String content = " hello world ";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(content);
        if (matcher.find()) {
            System.out.println("match : " + matcher.group(1));
        } else {
            System.out.println("not match ");
        }
    }

运行结果为： match :  hello world 

3. (?!) 否定式向前查找

 跟肯定式向前查找相反，是查找前面没有特定字符串的内容。

比如，查找出现“Java” 字符串且后面没有出现“Python” 的字符串。

    @Test
    public void testNegativeLookForward() {
        String regex = "Java(?!.*Python.*)";
        String content = "Java and Python are both good languages";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(content);
        if (matcher.find()) {
            System.out.println("match");
        } else {
            System.out.println("not match ");
        }
    }

此程序运行的结果是：not match 

如果把字符串换成：Java and C++ are both good languages，则运行结果是 ： match。

 

4. (?<=) 肯定式向后查找

查找前面有一个数字的英文字符串。

 

    @Test
    public void testPositiveLookup(){
        String regex = "(?<=\\d)([a-z]+)";
        String content = "abcd2def";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(content);
        if (matcher.find()) {
            System.out.println("match : " + matcher.group(1));
        } else {
            System.out.println("not match ");
        }
    }

运行结果为：

match : def

 

5. (?

不以end结尾的字符串。

    @Test
    public void testNegativeLookup(){
        String regex = "(.*)(?

运行结果为：

not match 

 

以上即是非捕获组与捕获组的介绍。