一文让你掌握正则表达式

基础知识

元字符

元字符是构造正则表达式的一种基本元素。
我们先来记几个常用的元字符：

有了元字符之后，我们就可以利用这些元字符来写一些简单的正则表达式了；
比如：
匹配有abc开头的字符串：

\babc或者^abc

匹配8位数字的QQ号码：

^\d\d\d\d\d\d\d\d$

匹配1开头11位数字的手机号码：

^\d\d\d\d\d\d\d\d\d\d$

重复限定符

有了元字符就可以写不少的正则表达式了，但细心的人会发现：别人写的正则简洁明了，而不是一堆乱七八糟而且重复的元字符组成的。
为了处理这些重复问题，把重复部分用合适的限定符替代，下面我们来看一些限定符：

有了这些限定符之后，我们就可以对之前的正则表达式进行改造了，比如：
匹配8位数字的QQ号码：

^\d{8}$

匹配1开头11位数字的手机号码：

^\d{10}$

匹配银行卡号是14~18位的数字：

^\d{14,18}$

匹配以a开头的，0个或多个b结尾的字符串

^ab*$

分组

从上面的例子（4）中看到，限定符是作用在与他左边最近的一个字符，那么问题来了，如果我想要ab同时被限定那怎么办呢？
正则表达式中用小括号()来做分组，也就是括号中的内容作为一个整体。
因此当我们要匹配多个ab时，我们可以这样，如：匹配字符串中包含0到多个ab开头：

^(ab)*

转义

我们看到正则表达式用小括号来做分组，那么问题来了：
如果要匹配的字符串中本身就包含小括号，那是不是冲突？应该怎么办？
针对这种情况，正则提供了转义的方式，也就是要把这些元字符、限定符或者关键字转义成普通的字符，做法很简答，就是在要转义的字符前面加个斜杠，也就是\即可。
如：要匹配以(ab)开头：

^(\(ab\))*

条件或

回到我们刚才的手机号匹配，国内号码都来自三大网，它们都有属于自己的号段，比如联通有130/131/132/155/156/185/186/145/176等号段，假如让我们匹配一个联通的号码，那按照我们目前所学到的正则，应该无从下手的，因为这里包含了一些并列的条件，也就是“或”，那么在正则中是如何表示“或”呢？
正则用符号 | 来表示或，也叫做分支条件，当满足正则里的分支条件的任何一种条件时，都会当成是匹配成功。
那么我们就可以用或条件来处理这个问题:

^(130|131|132|155|156|185|186|145|176)\d{8}$

区间

看到上面的例子，是不是看到有什么规律？是不是还有一种想要简化的冲动？
正则提供一个元字符中括号 [] 来表示区间条件。
限定0到9 可以写成[0-9]
限定A-Z 写成[A-Z]
限定某些数字 [165]
那上面的正则我们还可以改成这样：

^((13[0-2])|(15[56])|(18[5-6])|145|176)\d{8}$

进阶知识

零宽断言

先解释一下这两个词。
断言：俗话的断言就是“我断定什么什么”，而正则中的断言，就是说正则可以指明在指定的内容的前面或后面会出现满足指定规则的内容。
意思正则也可以像人类那样断定什么什么，比如"ss1aa2bb3",正则可以用断言找出aa2后面有bb3，也可以找出aa2前面有ss1。
零宽：就是没有宽度，在正则中，断言只是匹配位置，不占字符，也就是说，匹配结果里是不会返回断言本身。
举个例子：
假设我们要用爬虫抓取csdn里的文章阅读量，通过查看源代码可以看到文章阅读量这个内容是这样的结构：

<span class="read-count">阅读数：641</span>

其中只有‘641’这个是一个变量，也就是不同文章有不同的值，当我们拿到这个字符串时，需要获得这里边的‘641’有很多种办法，但如果使用正则应该怎么匹配呢？
下面先讲一下几种类型的断言：

• 正向先行断言
  例如对”a regular expression”这个字符串，要想匹配regular中的re，但不能匹配expression中的re，可以用”re(?=gular)”，该表达式限定了re右边的位置，这个位置之后是gular，但并不消耗gular这些字符，将表达式改为”re(?=gular).”，将会匹配reg，元字符.匹配了g，括号这一砣匹配了e和g之间的位置。
  按照上所说的正向先行断言可以匹配表达式前面的内容，那就是:(?=) 就可以匹配到前面的内容了。
  如果要所有内容那就是：

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

可是我们要的只是前面的数字呀，把匹配数字\d，那可以改成：

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

• 正向后行断言
  例如对”regex represents regular expression”这个字符串，有4个单词，要想匹配单词内部的re，但不匹配单词开头的re，可以用”(?<=\w)re”，单词内部的re，在re前面应该是一个单词字符。之所以叫后行断言，是因为正则表达式引擎在匹配字符串和表达式时，是从前向后逐个扫描字符串中的字符，并判断是否与表达式符合，当在表达式中遇到该断言时，正则表达式引擎需要往字符串前端检测已扫描过的字符，相对于扫描方向是向后的。
• 负向先行断言
  例如对”regex represents regular expression”这个字符串，要想匹配除regex和regular之外的re，可以用”re(?!g)”，该表达式限定了re右边的位置，这个位置后面不是字符g。负向和正向的区别，就在于该位置之后的字符能否匹配括号中的表达式。
• 负向后行断言
  例如对”regex represents regular expression”这个字符串，要想匹配单词开头的re，可以用”(?<!\w)re”。单词开头的re，在本例中，也就是指不在单词内部的re，即re前面不是单词字符。当然也可以用”\bre”来匹配。

捕获和非捕获

单纯说到捕获，他的意思是匹配表达式，但捕获通常和分组联系在一起，也就是“捕获组”;
捕获组：匹配子表达式的内容，把匹配结果保存到内存中中数字编号或显示命名的组里，以深度优先进行编号，之后可以通过序号或名称来使用这些匹配结果。
而根据命名方式的不同，又可以分为两种组：
1.捕获组
1.1.数字编号捕获组
语法：(exp)
解释：从表达式左侧开始，每出现一个左括号和它对应的右括号之间的内容为一个分组，在分组中，第0组为整个表达式，第一组开始为分组。
比如固定电话的：020-85653333
他的正则表达式为：(0\d{2})-(\d{8})
按照左括号的顺序，这个表达式有如下分组：

我们用Java来验证一下：

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)); 
    }
}
输出结果：
分组的个数有：2
第0个分组为：020-85653333
第1个分组为：020
第2个分组为：85653333

可见，分组个数是2，但是因为第0个为整个表达式本身，因此也一起输出了。
1.2. 命名编号捕获组
语法：(?exp)
解释：分组的命名由表达式中的name指定
比如区号也可以这样写:(?0\d{2})-(?\d{8})
按照左括号的顺序，这个表达式有如下分组：

用代码来验证一下：

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("分组名称为:quhao,匹配内容为：" + mc.group("quhao"));
    System.out.println("分组名称为:haoma,匹配内容为：" + mc.group("haoma"));
}
输出结果：
分组的个数有：2
分组名称为:quhao,匹配内容为：020
分组名称为:haoma,匹配内容为：85653333

2. 非捕获组
   语法：(?:exp)
   解释：和捕获组刚好相反，它用来标识那些不需要捕获的分组，说通俗一点，就是你可以根据需要去保存你的分组。
   比如上面的正则表达式，程序不需要用到第一个分组，那就可以这样写：

(?:\0\d{2})-(\d{8})

例子：

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

反向引用

上面讲到捕获，我们知道：捕获会返回一个捕获组，这个分组是保存在内存中，不仅可以在正则表达式外部通过程序进行引用，也可以在正则表达式内部进行引用，这种引用方式就是反向引用。
对于普通捕获组和命名捕获组的引用，语法如下：
普通捕获组反向引用：\k，通常简写为\number
命名捕获组反向引用：\k或者\k’name’
在默认情况下都是以数字来命名，而且数字命名的顺序是从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

例子2：
String test = "aabbbbgbddesddfiid";
Pattern pattern = Pattern.compile("(?<zu>\\w)\\k<zu>");
Matcher mc= pattern.matcher(test);
while(mc.find()){
    System.out.println(mc.group());
}
输出结果：
aa
bb
bb
dd
dd
ii

贪婪和非贪婪

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

String reg="\\d{3,6}";        
String test="61762828 176 2991 871";
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 44 871
贪婪模式：\d{3,6}
匹配结果：617628
匹配结果：176
匹配结果：2991
匹配结果：871

由结果可见：本来字符串中的“61762828”这一段，其实只需要出现3个（617）就已经匹配成功了的，但是他并不满足，而是匹配到了最大能匹配的字符，也就是6个。
例子2:

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

例子：

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

反义

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

例子：

String reg="[^aeiou]";        
String test="aeio1us 是？";
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));
}
输出结果：
文本：aeio1us 是？
贪婪模式：[^aeiou]
匹配结果:1
匹配结果:s
匹配结果: 
匹配结果:是
匹配结果:？

常见案例

1.匹配用户名：

^[a-z0-9_-]{3,16}$

2.匹配密码：

^[a-z0-9_-]{6,18}$

3.匹配一个Email：

^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$

4.匹配一个URL：

^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$

5.匹配IP地址：

^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

6.匹配HTML Tag：

^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$