騷氣十足的正則表達式（二）

1. 零寬斷言

不管是零寬仍是斷言，聽起來都古古怪怪的，
那先解釋一下這兩個詞。

1. 斷言：俗話的斷言就是「我判定什麼什麼」，而正則中的斷言，就是說正則能夠指明在指定的內容的前面或後面會出現知足指定規則的內容，
   意思正則也能夠像人類那樣判定什麼什麼，好比"ss1aa2bb3",正則能夠用斷言找出aa2前面有ss1，也能夠找出aa2後面有bb3.
2. 零寬：就是沒有寬度，在正則中，斷言只是匹配位置，不佔字符，也就是說，匹配結果裏是不會返回斷言自己。

意思是講明白了，那他有什麼用呢？
咱們來舉個栗子：
假設咱們要用爬蟲抓取csdn裏的文章閱讀量。經過查看源代碼能夠看到文章閱讀量這個內容是這樣的結構

1"<span class="read-count">閱讀數：641</span>"

其中也就‘641’這個是變量，也就是說不一樣文章不一樣的值，當咱們拿到這個字符串時，須要得到這裏邊的‘641’有不少種辦法，但若是正則應該怎麼匹配呢？

下面先來說幾種類型的斷言：

1. 正向先行斷言（正前瞻）：

• 語法：（?=pattern）
• 做用：匹配pattern表達式的前面內容，不返回自己。

這樣子說，仍是一臉懵逼，好吧，迴歸剛纔那個栗子，要取到閱讀量，在正則表達式中就意味着要能匹配到‘</span>’前面的數字內容
按照上所說的正向先行斷言能夠匹配表達式前面的內容，那意思就是:(?=</span>) 就能夠匹配到前面的內容了。
匹配什麼內容呢？若是要全部內容那就是：

 1String reg=".+(?=</span>)";
 2
 3String test = "<span class=\"read-count\">閱讀數：641</span>";
 4Pattern pattern = Pattern.compile(reg);
 5Matcher mc=    pattern.matcher(test);
 6while(mc.find()){
 7  System.out.println("匹配結果：")
 8  System.out.println(mc.group());
 9}
10
11//匹配結果：
12//<span class="read-count">閱讀數：641

但是老哥咱們要的只是前面的數字呀，那也簡單咯，匹配數字 \d,那能夠改爲：

1String reg="\\d+(?=</span>)";
2String test = "<span class=\"read-count\">閱讀數：641</span>";
3Pattern pattern = Pattern.compile(reg);
4Matcher mc=    pattern.matcher(test);
5while(mc.find()){
6  System.out.println(mc.group());
7}
8//匹配結果：
9//641

大功告成！

1. 正向後行斷言（正後顧）:

• 語法：（?<=pattern）
• 做用：匹配pattern表達式的後面的內容，不返回自己。

有先行就有後行，先行是匹配前面的內容，那後行就是匹配後面的內容啦。
上面的栗子，咱們也能夠用後行斷言來處理.

 1//(?<=<span class="read-count">閱讀數：)\d+
 2String reg="(?<=<span class=\"read-count\">閱讀數：)\\d+";
 3
 4String test = "<span class=\"read-count\">閱讀數：641</span>";
 5Pattern pattern = Pattern.compile(reg);
 6Matcher mc=    pattern.matcher(test);
 7        while(mc.find()){
 8            System.out.println(mc.group());
 9        }
10//匹配結果：
11//641

就這麼簡單。

1. 負向先行斷言（負前瞻）

• 語法：(?!pattern)
• 做用：匹配非pattern表達式的前面內容，不返回自己。

有正向也有負向，負向在這裏其實就是非的意思。
舉個栗子：好比有一句 「我愛祖國，我是祖國的花朵」
如今要找到不是'的花朵'前面的祖國
用正則就能夠這樣寫：

1祖國(?!的花朵)

1. 負向後行斷言（負後顧）

• 語法：(?<!pattern)
• 做用：匹配非pattern表達式的後面內容，不返回自己。

2. 捕獲和非捕獲

單純說到捕獲，他的意思是匹配表達式，但捕獲一般和分組聯繫在一塊兒，也就是「捕獲組」

捕獲組：匹配子表達式的內容，把匹配結果保存到內存中中數字編號或顯示命名的組裏，以深度優先進行編號，以後能夠經過序號或名稱來使用這些匹配結果。

而根據命名方式的不一樣，又能夠分爲兩種組：

1. 數字編號捕獲組：
   語法：(exp)
   解釋：從表達式左側開始，每出現一個左括號和它對應的右括號之間的內容爲一個分組，在分組中，第0組爲整個表達式，第一組開始爲分組。
   好比固定電話的：020-85653333
   他的正則表達式爲：(0\d{2})-(\d{8})
   按照左括號的順序，這個表達式有以下分組：

序號	編號	分組	內容
0	0	(0\d{2})-(\d{8})	020-85653333
1	1	(0\d{2})	020
2	2	(\d{8})	85653333

咱們用Java來驗證一下：

 1String test = "020-85653333";
 2        String reg="(0\\d{2})-(\\d{8})";
 3        Pattern pattern = Pattern.compile(reg);
 4        Matcher mc= pattern.matcher(test);
 5        if(mc.find()){
 6            System.out.println("分組的個數有："+mc.groupCount());
 7            for(int i=0;i<=mc.groupCount();i++){
 8                System.out.println("第"+i+"個分組爲："+mc.group(i));
 9            }
10        }

輸出結果：

1分組的個數有：2
2第0個分組爲：020-85653333
3第1個分組爲：020
4第2個分組爲：85653333

可見，分組個數是2，可是由於第0個爲整個表達式自己，所以也一塊兒輸出了。

1. 命名編號捕獲組：
   語法：(?<name>exp)
   解釋：分組的命名由表達式中的name指定
   好比區號也能夠這樣寫:(?<quhao>\0\d{2})-(?<haoma>\d{8})
   按照左括號的順序，這個表達式有以下分組：

序號	名稱	分組	內容
0	0	(0\d{2})-(\d{8})	020-85653333
1	quhao	(0\d{2})	020
2	haoma	(\d{8})	85653333

用代碼來驗證一下：

1String test = "020-85653333";
2        String reg="(?<quhao>0\\d{2})-(?<haoma>\\d{8})";
3        Pattern pattern = Pattern.compile(reg);
4        Matcher mc= pattern.matcher(test);
5        if(mc.find()){
6            System.out.println("分組的個數有："+mc.groupCount());
7            System.out.println(mc.group("quhao"));
8            System.out.println(mc.group("haoma"));
9        }

輸出結果：

1分組的個數有：2
2分組名稱爲:quhao,匹配內容爲：020
3分組名稱爲:haoma,匹配內容爲：85653333

1. 非捕獲組：
   語法：(?:exp)
   解釋：和捕獲組恰好相反，它用來標識那些不須要捕獲的分組，說的通俗一點，就是你能夠根據須要去保存你的分組。

好比上面的正則表達式，程序不須要用到第一個分組，那就能夠這樣寫：

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

序號	編號	分組	內容
0	0	(0\d{2})-(\d{8})	020-85653333
1	1	(\d{8})	85653333

驗證一下：

 1String test = "020-85653333";
 2        String reg="(?:0\\d{2})-(\\d{8})";
 3        Pattern pattern = Pattern.compile(reg);
 4        Matcher mc= pattern.matcher(test);
 5        if(mc.find()){
 6                System.out.println("分組的個數有："+mc.groupCount());
 7                for(int i=0;i<=mc.groupCount();i++){
 8                    System.out.println("第"+i+"個分組爲："+mc.group(i));
 9                }
10        }

輸出結果：

1分組的個數有：1
2第0個分組爲：020-85653333
3第1個分組爲：85653333

3. 反向引用

上面講到捕獲，咱們知道：捕獲會返回一個捕獲組，這個分組是保存在內存中，不只能夠在正則表達式外部經過程序進行引用，也能夠在正則表達式內部進行引用，這種引用方式就是反向引用。

根據捕獲組的命名規則，反向引用可分爲：

1. 數字編號組反向引用：\k

或\number

1. 命名編號組反向引用：\k

或者\'name'

好了 講完了，懂嗎？不懂！！！
可能連前面講的捕獲有什麼用都還不懂吧？
其實只是看完捕獲不懂不會用是很正常的！
由於捕獲組一般是和反向引用一塊兒使用的

上面說到捕獲組是匹配子表達式的內容按序號或者命名保存起來以便使用
注意兩個字眼：「內容」 和 「使用」
這裏所說的「內容」，是匹配結果，而不是子表達式自己，強調這個有什麼用？嗯，先記住
那這裏所說的「使用」是怎樣使用呢？

由於它的做用主要是用來查找一些重複的內容或者作替換指定字符。

仍是舉栗子吧：
好比要查找一串字母"aabbbbgbddesddfiid"裏成對的字母
若是按照咱們以前學到的正則，什麼區間啊限定啊斷言啊多是辦不到的，
如今咱們先用程序思惟理一下思路：

• 1）匹配到一個字母
• 2）匹配第下一個字母，檢查是否和上一個字母是否同樣
• 3）若是同樣，則匹配成功，不然失敗

這裏的思路2中匹配下一個字母時，須要用到上一個字母，那怎麼記住上一個字母呢？？？
這下子捕獲就有用處啦，咱們能夠利用捕獲把上一個匹配成功的內容用來做爲本次匹配的條件
好了，有思路就要實踐
首先匹配一個字母：\w
咱們須要作成分組才能捕獲，所以寫成這樣：(\w)

那這個表達式就有一個捕獲組：（\w）
而後咱們要用這個捕獲組做爲條件，那就能夠：(\w)\1
這樣就大功告成了
可能有人不明白了，\1是什麼意思呢？
還記得捕獲組有兩種命名方式嗎，一種是是根據捕獲分組順序命名，一種是自定義命名來做爲捕獲組的命名
在默認狀況下都是以數字來命名，並且數字命名的順序是從1開始的
所以要引用第一個捕獲組，根據反向引用的數字命名規則 就須要 \k<1>或者\1
固然，一般都是是後者。
咱們來測試一下：

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

輸出結果：

1aa
2bb
3bb
4dd
5dd
6ii

嗯，這就是咱們想要的了。
在舉個替換的例子，假如想要把字符串中abc換成a

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

輸出結果：

1abbabcgbddesddfiid

4. 貪婪和非貪婪

1.貪婪

咱們都知道，貪婪就是不知足，儘量多的要。
在正則中，貪婪也是差很少的意思:

貪婪匹配：當正則表達式中包含能接受重複的限定符時，一般的行爲是（在使整個表達式能獲得匹配的前提下）匹配儘量多的字符，這匹配方式叫作貪婪匹配。
特性：一次性讀入整個字符串進行匹配，每當不匹配就捨棄最右邊一個字符，繼續匹配，依次匹配和捨棄（這種匹配-捨棄的方式也叫作回溯），直到匹配成功或者把整個字符串捨棄完爲止，所以它是一種最大化的數據返回，能多不會少。

前面咱們講太重複限定符，其實這些限定符就是貪婪量詞，好比表達式：

1\d{3,6}

用來匹配3到6位數字，在這種狀況下，它是一種貪婪模式的匹配，也就是假如字符串裏有6個個數字能夠匹配，那它就是所有匹配到。
如

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

輸出結果：

1文本：61762828 176 2991 44 871
2貪婪模式：\d{3,6}
3匹配結果：617628
4匹配結果：176
5匹配結果：2991
6匹配結果：871

由結果可見：原本字符串中的「61762828」這一段，其實只須要出現3個（617）就已經匹配成功了的，可是他並不知足，而是匹配到了最大能匹配的字符，也就是6個。
一個量詞就如此貪婪了，
那有人會問，若是多個貪婪量詞湊在一塊兒，那他們是如何支配本身的匹配權的呢？

是這樣的，多個貪婪在一塊兒時，若是字符串能知足他們各自最大程度的匹配時，就互不干擾，但若是不能知足時，會根據深度優先原則，也就是從左到右的每個貪婪量詞，優先最大數量的知足，剩餘再分配下一個量詞匹配。

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

輸出結果：

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

1. 「617628」 是前面的\d{1,2}匹配出了61，後面的匹配出了7628
2. "2991" 是前面的\d{1,2}匹配出了29 ，後面的匹配出了91
3. "87321"是前面的\d{1,2}匹配出了87，後面的匹配出了321

2. 懶惰（非貪婪）

懶惰匹配：當正則表達式中包含能接受重複的限定符時，一般的行爲是（在使整個表達式能獲得匹配的前提下）匹配儘量少的字符，這匹配方式叫作懶惰匹配。
特性：從左到右，從字符串的最左邊開始匹配，每次試圖不讀入字符匹配，匹配成功，則完成匹配，不然讀入一個字符再匹配，依此循環（讀入字符、匹配）直到匹配成功或者把字符串的字符匹配完爲止。

懶惰量詞是在貪婪量詞後面加個「？」

代碼	說明
*?	重複任意次，但儘量少重複
+?	重複1次或更屢次，但儘量少重複
??	重複0次或1次，但儘量少重複
{n,m}?	重複n到m次，但儘量少重複
{n,}?	重複n次以上，但儘量少重複

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

輸出結果：

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

解答：

「61762」 是左邊的懶惰匹配出6，右邊的貪婪匹配出1762
"2991"  是左邊的懶惰匹配出2，右邊的貪婪匹配出991
"87321" 左邊的懶惰匹配出8，右邊的貪婪匹配出7321

5. 反義

前面說到元字符的都是要匹配什麼什麼，固然若是你想反着來，不想匹配某些字符，正則也提供了一些經常使用的反義元字符：

元字符	解釋
\W	匹配任意不是字母，數字，下劃線，漢字的字符
\S	匹配任意不是空白符的字符
\D	匹配任意非數字的字符
\B	匹配不是單詞開頭或結束的位置
[^x]	匹配除了x之外的任意字符
[^aeiou]	匹配除了aeiou這幾個字母之外的任意字符