在工作中，经常会用到正则表达式，这篇文章并不是讲正则表达式的基本使用，则是侧重讲正则表达式的捕获组与非捕获组。
所用语言均为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. (?=) 肯定式向前查找
这里所说的向前，是指字符串从左到右的方向。如，查找被<html> </html> 包围着的字符串。
我们可以先查询到字符串<html>，再向前查</html>。
@Test
public void testPositiveLookForward() {
String regex = "\\<html\\>(.*)(?=\\</html\\>)";
String content = "<html> hello world </html>";
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 = "(.*)(?<!end)$";
String content = "python language end";
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 ");
}
}运行结果为：
not match
以上即是非捕获组与捕获组的介绍。
920
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
