# # # 正则
正則很6很強大。最為神奇的是不管你大學選擇那門計算機語言，都沒有關于正則表達式的課程給你修，你只能仰望大師們寫了一串外文字符串替代你的通篇if else代碼來做一些數據校驗。既然喜歡那就學唄！接下來整理一下正則，看過之后希望可以幫到你，不能說你可以寫出多高大上的正則表達式，但再不濟看懂別人寫的正則，那也不錯了。
正則表達式在很多語言中都可以使用，無論是前端的JavaScript還是后端的Java。都有提供相應的接口 \ 函數支持正則表達式。
? 1.元字符
?
萬物皆有緣，正則也如此，元字符是構造正則表達式的一種基本元素。
常用的元字符
| 元字符 | 說明 |
| . | 匹配除換行符以外的任意字符 |
| \w | 匹配字母或者數字或下劃線或漢字 |
| \s | 匹配任意的空白符 |
| \d | 匹配數字 |
| \b | 匹配單詞的開始或結束 |
| ^ | 匹配字符串的開始 |
| $ | 匹配字符串的結束 |
?
?
?
?
?
?
下面我們來寫一些簡單的正則表達式：
匹配有abc開頭的字符串：? ?\babc或^abc
匹配8位數字的QQ號碼：? ?^\d\d\d\d\d\d\d\d$
匹配1開頭11位數字的手機號碼：? ^\d\d\d\d\d\d\d\d\d$
?
? 2.重復限定符
?
可以看的出以上代碼并不簡潔好多重復，下面說一下重復限定符，把重復部分用合適的限定符代替，
| 語法 | 說明 |
| * | 重復零次或更多次 |
| + | 重復一次或更多次 |
| ？ | 重復零次或一次 |
| {n} | 重復n次 |
| {n，} | 重復n次或更多次 |
| {n，m} | 重復n到m次 |
?
?
?
?
?
?
下面我們來簡化一下代碼：
匹配8位數字的QQ號碼：? ^\d{8}$
匹配1開頭的11位數字的手機號碼：? ^1\d{10}$
匹配銀行卡號是14~18位的數字：? ? ^\d{14,18}$
匹配以a開頭的，0個或多個b結尾的字符串：? ?^ab*$
?
? ?? ? ?3.分組
?
如果你想要ab同時限定的話可以用小括號()來做分組，括號中的內容作為一個整體。
譬如：匹配字符串中包含0到多個ab開頭：? ^(ab)*
?
? 4.轉義
?
上面說分組用小括號，如果要匹配的字符串中本身帶有小括號，那不就沖突了嗎？難道就沒辦法了嗎？? No No No?
針對這種情況，正則提供了一個名叫轉義的方式，就是把元字符、限定字符、關鍵字轉義長普通字符，方法就是要在轉義字符前面加個斜杠。
譬如：要匹配以（ab）開頭：? ^(\(ab\))*
?
? ? ?5.條件或
?
?在正則中并列的條件也就是“或”，正則用符號 | 來表示或，也叫做分支條件，當滿足正則里的分支條件的任何一種條件時，都會當成是匹配成功。
匹配一個聯通號碼：^(130|131|132|155|156|185|186|145|176)\d{8}$
?
? ? ?6.區間
正則提供一個元字符中括號[]來表示區間條件。
限定0到9可以寫成[0-9]
限定A-Z寫成[A-Z]
限定某些數字[166]
上面的聯通號碼我們可以改成這樣： ^((13[0-2])|(15[56])|(18[5-6])|145|176)\d{8}$
?
? ?7.零寬斷言
斷言：用我們自己的話來理解就是“我斷定什么”，在正則中，是指正則可以指明在指定的內容的前面或者后面會出現滿足指定規則的內容。
零寬：就是沒有寬度，在正則中斷言只是匹配位置不占字符，就是說匹配結果里是不會返回斷言本身。
我們來舉個栗子：
"<span class="read-cound">閱讀數：666</span>"上面是用爬蟲抓取csdn里的文章的閱讀量，可以知道的是“666”這是一個變量，要想用正則怎么匹配？
下面嘮一下幾種類型的斷言：
正向先行斷言（正前瞻）
語法：（？=pattern）
作用：匹配pattern表達式的前面內容，不返回本身。
剛才那個栗子要取到閱讀量在正則表達式中意味著要能匹配到'</span>'前面是數字內容，(？=</span>)就可以匹配到前面是內容了。
匹配所有內容：
1 String reg=".+(?=</span>)"; 2 3 String test = "<span class=\"read-count\">閱讀數：666</span>"; 4 Pattern pattern = Pattern.compile(reg); 5 Matcher mc= pattern.matcher(test); 6 while(mc.find()){ 7 System.out.println("匹配結果：") 8 System.out.println(mc.group()); 9 } 10 11 //匹配結果： 12 //<span class="read-count">閱讀數：666老哥我只要前面的數字呀，那也簡單，匹配數字\d,這樣寫
1String reg="\\d+(?=</span>)"; 2String test = "<span class=\"read-count\">閱讀數：666</span>"; 3Pattern pattern = Pattern.compile(reg); 4Matcher mc= pattern.matcher(test); 5while(mc.find()){ 6 System.out.println(mc.group()); 7} 8//匹配結果： 9//666正向后行斷言（正后顧）
語法：（?<=pattern）
作用：匹配 pattern 表達式的后面的內容，不返回本身。
?把上面的栗子再煮一遍：
1//(?<=<span class="read-count">閱讀數：)\d+2String reg="(?<=<span class=\"read-count\">閱讀數：)\\d+";34String test = "<span class=\"read-count\">閱讀數：666</span>";5Pattern pattern = Pattern.compile(reg);6Matcher mc= pattern.matcher(test);7 while(mc.find()){8 System.out.println(mc.group());9 } 10//匹配結果： 11//666可以收工了！
負向先行斷言（負前瞻）
語法：(?!pattern)
作用：匹配非 pattern 表達式的前面內容，不返回本身。
舉個栗子："我是小可愛，小可愛是我！"
要找到“是我”前面的小可愛
用正則這樣寫：小可愛(?!是我)
?
?
負向后行斷言（負后顧）
語法：(?<!pattern)
作用：匹配非 pattern 表達式的后面內容，不返回本身。
?? 8.捕獲和非捕獲?
?
單純說到捕獲，他的意思是匹配表達式，但捕獲通常和分組聯系在一起，也就是“捕獲組”。
捕獲組：匹配子表達式的內容，把匹配結果保存到內存中中數字編號或顯示命名的組里，以深度優先進行編號，之后可以通過序號或名稱來使用這些匹配結果。
根據命名方式的不同可以分為兩種組：
數字編號捕獲:
語法：（exp）
解釋：從表達式左側開始，每出現一個左括號和它對應的右括號之間的內容為一個分組，在分組中，第 0 組為整個表達式，第一組開始為分組。
比如固定電話：010-88943223
他的正則表達式為：(0\d{1})-(\d{8})
按照左括號的順序，這個表達式有如下分組：
| 序號 | 編號 | 分組 | 內容 |
| 0 | 0 | (0\d{2})-(\d{8}) | 010-88943223 |
| 1 | 1 | (0\d{1}) | 010 |
| 2 | 2 | (\d{8}) | 88943223 |
?
?
?
用Java驗證一下：
1 String test = "010-88943223";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個為整個表達式本身，因此也一起輸出了。
?
命名編號捕獲組
語法：(?<name>exp)
解釋：分組的命名由表達式中的 name 指定
比如區號也可以這樣寫:(?<quhao>\0\d{1})-(?<haoma>\d{8})，按照左括號的順序，這個表達式有如下分組：
| 序號 | 名稱 | 分組 | 內容 |
| 0 | 0 | (0\d{1})-(\d{8}) | 010-88943223 |
| 1 | quhao | (0\d{1}) | 010 |
| 2 | haoma | (\d{8}) | 88943223 |
?
?
?
?用代碼來驗證一下：
1 String 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,匹配內容為：0103 分組名稱為:haoma,匹配內容為：88943223?
非捕獲組
語法：(?:exp)
解釋：和捕獲組剛好相反，它用來標識那些不需要捕獲的分組，說的通俗一點，就是你可以根據需要去保存你的分組。
| 序號 | 編號 | 分組 | 內容 |
| 0 | 0 | (0\d{1})-(\d{8}) | 010-88943223 |
| 1 | 1 | (\d{8}) | 88943223 |
?
?
?
?
驗證一下：
1 String 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個分組為：010-88943223 3 第1個分組為：88943223? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
? 9.反向引用
?
捕獲會返回一個捕獲組，這個分組是保存在內存中，不僅可以在正則表達式外部通過程序進行引用，也可以在正則表達式內部進行引用，這種引用方式就是反向引用。
根據捕獲組的命名規則，反向引用可分為：
·數字編號組反向引用：\k 或 \number
·命名編號組反向引用：\k 或 \'name'
這樣基本上算是已經說完了，但是我知道你還是不懂。
捕獲組通常是和反向引用一起使用的，上面說到捕獲組是匹配子表達式的內容按序號或者命名保存起來以便使用。劃重點“內容” 和 “使用”！！！
這里的內容說的是匹配結果，而不是子表達式本身，這里是使用它的作用主要是用來查找一些重復的內容或者做替換指定字符。
如：要查找一串字母"?aabbbbgbddesddfiid "里成對的字母。
思路：
1、匹配到一個字母
2、匹配第下一個字母，檢查是否和上一個字母是否一樣（怎么記住上一個字母？利用捕獲把上一個匹配成功的內容用來作為本次匹配的條件）
3、?如果一樣，則匹配成功，否則失敗? ? ?
首先匹配一個字母：\w，我們需要做成分組才能捕獲，因此寫成這樣：(\w)
那這個表達式就有一個捕獲組：（\w）
然后我們要用這個捕獲組作為條件，那就可以：(\w)\1這樣就大功告成了
可能有人不明白了，\1 是什么意思呢？
還記得捕獲組有兩種命名方式嗎，一種是是根據捕獲分組順序命名，一種是自定義命名來作為捕獲組的命名在默認情況下都是以數字來命名，而且數字命名的順序是從 1 開始的。
因此要引用第一個捕獲組，根據反向引用的數字命名規則 就需要 \k<1>或者\1，當然，通常都是是后者。
我們來測試一下：
1 String 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 }輸出結果：
1 aa 2 bb 3 bb 4 dd 5 dd 6 ii? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
?
? ? ? ?10.貪婪和非貪婪?
貪婪匹配：當正則表達式中包含能接受重復的限定符時，通常的行為是（在使整個表達式能得到匹配的前提下）匹配盡可能多的字符，這匹配方式叫做貪婪匹配。
特性：一次性讀入整個字符串進行匹配，每當不匹配就舍棄最右邊一個字符，繼續匹配，依次匹配和舍棄（這種匹配 - 舍棄的方式也叫做回溯），直到匹配成功或者把整個字符串舍棄完為止，因此它是一種最大化的數據返回，能多不會少。
前面我們講過重復限定符，其實這些限定符就是貪婪量詞，比如表達式：\d{3,6}
用來匹配3到6位數字，在這種情況下，它是一種貪婪模式的匹配，也就是假如字符串里有6個個數字可以匹配，那它就是全部匹配到。
如:
1 String reg="\\d{3,6}"; 2 String test="61762828 176 2991 871"; 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 44 871 2 貪婪模式：\d{3,6} 3 匹配結果：617628 4 匹配結果：176 5 匹配結果：2991 6 匹配結果：871多個貪婪詞湊在一起會怎樣？
多個貪婪在一起時，如果字符串能滿足他們各自最大程度的匹配時，就互不干擾，但如果不能滿足時，會根據深度優先原則，也就是從左到右的每一個貪婪量詞，優先最大數量的滿足，剩余再分配下一個量詞匹配。
1 String 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 匹配結果：617628 4 匹配結果：2991 5 匹配結果：87321-
“617628” 是前面的\d{1,2}匹配出了 61，后面的匹配出了 7628
-
"2991" 是前面的\d{1,2}匹配出了 29 ，后面的匹配出了 91
-
"87321"是前面的\d{1,2}匹配出了 87，后面的匹配出了 321
?懶惰（非貪婪）
懶惰匹配：當正則表達式中包含能接受重復的限定符時，通常的行為是（在使整個表達式能得到匹配的前提下）匹配盡可能少的字符，這匹配方式叫做懶惰匹配。
?
特性：從左到右，從字符串的最左邊開始匹配，每次試圖不讀入字符匹配，匹配成功，則完成匹配，否則讀入一個字符再匹配，依此循環（讀入字符、匹配）直到匹配成功或者把字符串的字符匹配完為止。
懶惰量詞是在貪婪量詞后面加個“？”
| 代碼 | 說明 |
| *? | 重復任意次，但盡可能少重復 |
| +? | 重復1次或更多次，但盡可能少重復 |
| ?? | 重復0次或1次，但盡可能少重復 |
| {n,m}? | 重復n到m次，但盡可能少重復 |
| {n,}? | 重復n次以上，但盡可能少重復 |
?
?
?
?
?
1 String 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?
?11.反義
?
| 元字符 | 解釋 |
| \W | 匹配任意不是字母，數字，下劃線，漢字的字符 |
| \S | 匹配任意不是空白符的字符 |
| \D | 匹配任意非數字的字符 |
| \B | 匹配不是單詞開頭或結束的位置 |
| [^x] | 匹配除了x以外的任意字符 |
| [^aeiou] | 匹配除了aeiou這幾個字母以外的任意字符 |
?
?
?
?
?
?
我知道的基本就這么多了，經常研究和使用才能領悟它的博大精深。接下來我們一起學習研究！加油！
轉載于:https://www.cnblogs.com/jstll/p/10284694.html
總結
- 上一篇： 第一节:数据库与数据仓库
- 下一篇： 自我回答，问题3：Scroller的属性