正则表达式（进阶篇）

一、零宽断言
解释一下这是个什么鬼。

1、断言：可以理解为一个标记，断点，假如"aa1bb2cc3"，我可以利用断言，即bb2作为标记，一个断点，匹配bb2前的内容或后面的内容；
2、零宽：在正则表达式中，断言只匹配位置，不占字符，匹配字符结果不会返回断言，即结果不包含标记或者断点

那零宽断言有什么用？举个栗子：
假设要在CSDN中爬取文章的阅读量。需要爬取的资料如下：

<span class ="read-count">阅读数:557</span>

那样，如何利用正则来匹配呢？
以下介绍几种类型的断言：

1、正向断言：
语法：(?=pattern)
作用：匹配pattern表达式的前面内容，不返回断言（pattern）本身
例如：

String reg =".+(\\d=</span>)"
String test = "<span class ="read-count">阅读数:557</span>"
Pattern pattern = Pattern.compile(reg);
Matcher mc = pattern.matcher(test);
if(mc.find()){
    System.out.println(mc.group());
}
//结果：557

2、正向后行断言:
语法：（?<=pattern）
作用：匹配pattern表达式的后面的内容，不返回本身

String reg="(?<=<span class=\"read-count\">阅读数：)\\d+";
.......

//结果是：557

负向先行断言
语法：(?!pattern)
作用：匹配非pattern表达式的前面内容，不返回本身。

负向即是非，找到不在pattern前面的匹配内容

负向后行断言
语法：(?<!pattern)
作用：匹配非pattern表达式的后面内容，不返回本身。

同理

二、捕获与非捕获
单纯地捕获其实就是匹配，捕获通常与分组一起

捕获组：即将匹配的内容进行分组并且编号，利用编号来使用捕获的内容

根据命名，有两种分组
1、数字编号捕获组：

语法：(exp)
解释：从表达式左侧开始，每出现一个左括号和它对应的右括号之间的内容为一个分组，在分组中，第0组为整个表达式，第一组开始为分组。
比如固定电话的：020-85653333
他的正则表达式为：(0\d{2})-(\d{8})
按照左括号的顺序，这个表达式有如下分组：

序号	编号	分组	内容
0	0	(0\d{2})-(\d{8})	020-85653333
1	2	(0\d{2})	020
1	2	(\d{8})	85653333

使用方式：

String test = "020-85653333";
String reg="(0\\d{2})-(\\d{8})";
Pattern pattern = Pattern.compile(reg);
Matcher mc= pattern.matcher(test);

2、命名编号捕获组：

语法：(?exp)
解释：分组的命名由表达式中的name指定
比如区号也可以这样写:(?\0\d{2})-(?\d{8})
按照左括号的顺序，这个表达式有如下分组：

序号	编号	分组	内容
0	0	(0\d{2})-(\d{8})	020-85653333
1	h	(0\d{2})	020
1	g	(\d{8})	85653333

代码验证：

String test = "020-85653333";
String reg="(?<quhao>0\\d{2})-(?<haoma>\\d{8})";
Pattern pattern = Pattern.compile(reg);
Matcher mc= pattern.matcher(test);
     if(mc.find()){
     System.out.println("分组的个数有："+mc.groupCount());
     System.out.println(mc.group("q"));
     System.out.println(mc.group("g"));
   }

3、非捕获组：

语法：(?:exp)
解释：和捕获组刚好相反，它用来标识那些不需要捕获的分组，说的通俗一点，就是你可以根据需要去保存你的分组。

比如上面的正则表达式，程序不需要用到第一个分组，那就可以这样写：

序号	编号	分组	内容
0	0	(0\d{2})-(\d{8})	020-85653333
1	1	(0\d{2})	020

String test = "020-85653333";
String reg="(?:0\\d{2})-(\\d{8})";
Pattern pattern = Pattern.compile(reg);
Matcher mc= pattern.matcher(test);
if(mc.find()){
           System.out.println("分组的个数有："+mc.groupCount());
           for(int i=0;i<=mc.groupCount();i++){
           System.out.println("第"+i+"个分组为："+mc.group(i));
       }
 }

输出：

分组的个数有：1
第0个分组为：020-85653333
第1个分组为：85653333

三、反向引用
上面讲到捕获，我们知道：捕获会返回一个捕获组，这个分组是保存在内存中，不仅可以在正则表达式外部通过程序进行引用，也可以在正则表达式内部进行引用，这种引用方式就是反向引用。

根据捕获组的命名规则，反向引用可分为：

1、数字编号组反向引用：\k
或\number
2、命名编号组反向引用：\k
或者’name’

已经说完了，好吧，看到这，我想你们还是不懂的；蛮正常的，因为捕获组通常是和反向引用一起使用的。
上面说到捕获组是匹配子表达式的内容按序号或者命名保存起来以便使用
注意两个字眼：“内容” 和 “使用”
这里所说的“内容”，是匹配结果，而不是子表达式本身，强调这个有什么用？嗯，先记住
那这里所说的“使用”是怎样使用呢？

因为它的作用主要是用来查找一些重复的内容或者做替换指定字符。

还是举栗子吧：
比如要查找一串字母"aabbbbgbddesddfiid"里成对的字母
如果按照我们之前学到的正则，什么区间啊限定啊断言啊可能是办不到的，
现在我们先用程序思维理一下思路：

1）匹配到一个字母
2）匹配第下一个字母，检查是否和上一个字母是否一样
3）如果一样，则匹配成功，否则失败

这里的思路2中匹配下一个字母时，需要用到上一个字母，那怎么记住上一个字母呢？？？
这下子捕获就有用处啦，我们可以利用捕获把上一个匹配成功的内容用来作为本次匹配的条件
好了，有思路就要实践
首先匹配一个字母：\w
我们需要做成分组才能捕获，因此写成这样：(\w)

那这个表达式就有一个捕获组：（\w）
然后我们要用这个捕获组作为条件，那就可以：(\w)\1
这样就大功告成了
可能有人不明白了，\1是什么意思呢？
还记得捕获组有两种命名方式吗，一种是是根据捕获分组顺序命名，一种是自定义命名来作为捕获组的命名
在默认情况下都是以数字来命名，而且数字命名的顺序是从1开始的
因此要引用第一个捕获组，根据反向引用的数字命名规则 就需要 \k<1>或者\1
当然，通常都是是后者。
我们来测试一下：

String test = "aabbbbgbddesddfiid";
Pattern pattern = Pattern.compile("(\\w)\\1");
Matcher mc= pattern.matcher(test);
while(mc.find()){
     System.out.println(mc.group());
 }

输出结果：

aa
bb
bb
dd
dd
ii

再举个替换的例子，假如想要把字符串中abc换成a

String test = "abcbbabcbcgbddesddfiid";
String reg="(a)(b)c";
System.out.println(test.replaceAll(reg, "$1"));

结果：

abbabcgbddesddfiid

四、贪婪与非贪婪
1、贪婪
贪婪就是不满足，尽可能多的要。在正则中，贪婪也是差不多的意思:

贪婪匹配：当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符，这匹配方式叫做贪婪匹配。
特性：一次性读入整个字符串进行匹配，每当不匹配就舍弃最右边一个字符，继续匹配，依次匹配和舍弃（这种匹配-舍弃的方式也叫做回溯），直到匹配成功或者把整个字符串舍弃完为止，因此它是一种最大化的数据返回，能多不会少。

前面讲过重复限定符，其实这些限定符就是贪婪量词。单我讲的是单个贪婪量词的情况，若多个贪婪量词呢？

是这样的，多个贪婪在一起时，如果字符串能满足他们各自最大程度的匹配时，就互不干扰，但如果不能满足时，会根据深度优先原则，也就是从左到右的每一个贪婪量词，优先满足能够贪婪最大量的条件，剩余再分配下一个量词匹配。

估计还是懵，看看下面的代码吧：

String reg="(\\d{1,2})(\\d{3,4})";        
String test="61762828 176 2991 87321";
System.out.println("文本："+test);
System.out.println("贪婪模式："+reg);
Pattern p1 =Pattern.compile(reg);
Matcher m1 = p1.matcher(test);
  while(m1.find()){
      System.out.println("匹配结果："+m1.group(0));
    }

结果：

文本：61762828 176 2991 87321
贪婪模式：(\d{1,2})(\d{3,4})
匹配结果：617628
匹配结果：2991
匹配结果：87321

仔细体会一下第二个匹配结果，便有结论了。

“617628” 是前面的\d{1,2}匹配出了61，后面的匹配出了7628
“2991” 是前面的\d{1,2}匹配出了29 ，后面的匹配出了91
"87321"是前面的\d{1,2}匹配出了87，后面的匹配出了321

2、懒惰（非贪婪）

懒惰匹配：当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能少的字符，这匹配方式叫做懒惰匹配。
特性：从左到右，从字符串的最左边开始匹配，每次试图不读入字符匹配，匹配成功，则完成匹配，否则读入一个字符再匹配，依此循环（读入字符、匹配）直到匹配成功或者把字符串的字符匹配完为止。

懒惰量词是在贪婪量词后面加个“？”

代码	说明
*?	重复任意次，但尽可能少重复
+?	重复1次或更多次，但尽可能少重复
??	重复0次或1次，但尽可能少重复
{n,m}?	重复n到m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

String reg="(\\d{1,2}?)(\\d{3,4})";        
String test="61762828 176 2991 87321";
System.out.println("文本："+test);
System.out.println("贪婪模式："+reg);
Pattern p1 =Pattern.compile(reg);
Matcher m1 = p1.matcher(test);
while(m1.find()){
   System.out.println("匹配结果："+m1.group(0));
 }

结果：

文本：61762828 176 2991 87321
贪婪模式：(\d{1,2}?)(\d{3,4})
匹配结果：61762
匹配结果：2991
匹配结果：87321

解释：

“61762” 是左边的懒惰匹配出6，右边的贪婪匹配出1762
“2991” 是左边的懒惰匹配出2，右边的贪婪匹配出991
“87321” 左边的懒惰匹配出8，右边的贪婪匹配出7321

五、反义
前面说到元字符的都是要匹配什么什么，当然如果你想反着来，不想匹配某些字符，正则也提供了一些常用的反义元字符（斜杠与元字符相反）：

元字符	解释
\W	匹配任意不是字母，数字，下划线，汉字的字符
\S	匹配任意不是空白符的字符
\D	匹配任意非数字的字符
\B	匹配不是单词开头或结束的位置
[^x]	匹配除了x以外的任意字符
[^aeiou]	匹配除了aeiou这几个字母以外的任意字符

公众号持续更新