前面我們學習了正則表示式的基礎部分，現在我們來學習正則表示式的進階部分。
學習連結（轉載連結）：https://www.zhihu.com/question/48219401/answer/742444326

1.零寬斷言

無論是零寬還是斷言，聽起來都古古怪怪的，那先解釋一下這兩個詞。
1.斷言：俗話的斷言就是“我斷定什麼什麼”，而正則中的斷言，就是說正則可以指明在指定的內容的前面或後面會出現滿足指定規則的內容，
意思正則也可以像人類那樣斷定什麼什麼，比如"ss1aa2bb3",正則可以用斷言找出aa2前面有bb3，也可以找出aa2後面有ss1.
2.零寬：就是沒有寬度，在正則中，斷言只是匹配位置，不佔字元，也就是說，匹配結果裡是不會返回斷言本身。

意思是講明白了，那他有什麼用呢？
我們來舉個栗子：
假設我們要用爬蟲抓取csdn裡的文章閱讀量。通過檢視原始碼可以看到文章閱讀量這個內容是這樣的結構

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

其中也就‘641’這個是變數，也就是說不同文章不同的值，當我們拿到這個字串時，需要獲得這裡邊的‘641’有很多種辦法，但如果正則應該怎麼匹配呢？
下面先來講幾種型別的斷言：

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

語法：（?=pattern）
作用：匹配pattern表示式的前面內容，不返回本身。

這樣子說，還是一臉懵逼，好吧，迴歸剛才那個栗子，要取到閱讀量，在正則表示式中就意味著要能匹配到‘’前面的數字內容
按照上所說的正向先行斷言可以匹配表示式前面的內容，那意思就是:(?=) 就可以匹配到前面的內容了。
匹配什麼內容呢？如果要所有內容那就是：

    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(mc.group());
   }
   //匹配結果：
   //641

大功告成！

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

語法：（?<=pattern）
作用：匹配pattern表示式的後面的內容，不返回本身。
有先行就有後行，先行是匹配前面的內容，那後行就是匹配後面的內容啦。
上面的栗子，我們也可以用後行斷言來處理.

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

就這麼簡單。

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

語法：(?!pattern)
作用：匹配非pattern表示式的前面內容，不返回本身。
有正向也有負向，負向在這裡其實就是非的意思。
舉個栗子：比如有一句 “我愛祖國，我是祖國的花朵”
現在要找到不是'的花朵'前面的祖國
用正則就可以這樣寫：
祖國(?!的花朵)

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

語法：(?<!pattern)
作用：匹配非pattern表示式的後面內容，不返回本身。

2. 捕獲和非捕獲

單純說到捕獲，他的意思是匹配表示式，但捕獲通常和分組聯絡在一起，也就是“捕獲組”
捕獲組：匹配子表示式的內容，把匹配結果儲存到記憶體中中數字編號或顯示命名的組裡，以深度優先進行編號，之後可以通過序號或名稱來使用這些匹配結果。
而根據命名方式的不同，又可以分為兩種組：

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個為整個表示式本身，因此也一起輸出了。

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(mc.group("quhao"));
            System.out.println(mc.group("haoma"));
        }

輸出結果：
分組的個數有：2
分組名稱為:quhao,匹配內容為：020
分組名稱為:haoma,匹配內容為：85653333

3. 非捕獲組：

語法：(?: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

3. 反向引用

上面講到捕獲，我們知道：捕獲會返回一個捕獲組，這個分組是儲存在記憶體中，不僅可以在正則表示式外部通過程式進行引用，也可以在正則表示式內部進行引用，這種引用方式就是反向引用。
根據捕獲組的命名規則，反向引用可分為：

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

4. 貪婪和非貪婪

1.貪婪

我們都知道，貪婪就是不滿足，儘可能多的要。
在正則中，貪婪也是差不多的意思:
貪婪匹配：當正則表示式中包含能接受重複的限定符時，通常的行為是（在使整個表示式能得到匹配的前提下）匹配儘可能多的字元，這匹配方式叫做貪婪匹配。
特性：一次性讀入整個字串進行匹配，每當不匹配就捨棄最右邊一個字元，繼續匹配，依次匹配和捨棄（這種匹配-捨棄的方式也叫做回溯），直到匹配成功或者把整個字串捨棄完為止，因此它是一種最大化的資料返回，能多不會少。
前面我們講過重複限定符，其實這些限定符就是貪婪量詞，比如表示式：

\d{3,6}

用來匹配3到6位數字，在這種情況下，它是一種貪婪模式的匹配，也就是假如字串裡有6個個數字可以匹配，那它就是全部匹配到。
如:

   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個。
一個量詞就如此貪婪了，
那有人會問，如果多個貪婪量詞湊在一起，那他們是如何支配自己的匹配權的呢？
是這樣的，多個貪婪在一起時，如果字串能滿足他們各自最大程度的匹配時，就互不干擾，但如果不能滿足時，會根據深度優先原則，也就是從左到右的每一個貪婪量詞，優先最大數量的滿足，剩餘再分配下一個量詞匹配。

   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

1.“617628” 是前面的\d{1,2}匹配出了61，後面的匹配出了7628
2."2991" 是前面的\d{1,2}匹配出了29 ，後面的匹配出了91
3."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

5. 反義

前面說到元字元的都是要匹配什麼什麼，當然如果你想反著來，不想匹配某些字元，正則也提供了一些常用的反義元字元：

正則進階知識就講到這裡，正則是一門博大精深的語言，其實學會它的一些語法和知識點還算不太難，但想要做到真正學以致用能寫出非常6的正則，還有很遠的距離，只有真正對它感興趣的，並且經常研究和使用它，才會漸漸的理解它的博大精深之處，我就帶你們走到這，剩下的，靠自己啦。