正規表示式(程式碼java版)

夢想家haima發表於2020-09-27

重新釋出於2020年09月27日,寫於2016年

看了好些天的正規表示式,終於有時間來寫一篇關於它的部落格了。也是因為前段時間做標籤處理的工作用到,用正則匹配標籤規則,少寫了不少程式碼。在有的地方使用正規表示式確實特別棒。參考博文http://blog.csdn.net/yaerfeng/article/details/28855587 ,文中提到程式設計師的七種基本技能,確實各種語言,系統裡幾乎都有對正則的支援,雖說不用精通,但也要基本運用沒問題。

元字元

元字元標識在正規表示式中有特殊含義的字元,正是由它們,正規表示式才真正存在。JAVA中支援的元字元列表有:([{\^-$|}])?*+.

  • ( ):正則組中使用
  • [ ]:字元類中表示一個字元
  • { }:數量範圍標識
  • \:預定義字元類中使用
  • ^ $:邊界標識
  • -:字元類中表示某個範圍時使用,和"[]"配合使用
  • |:邏輯或
  • ? * +:預定義數量詞
  • ^:邏輯非
  • .:點號匹配除換行符的任意字元 (這個地方任然有點疑問)

這裡要特別說明一個符號&,雖然&&字元類中扮演著邏輯與運算,但卻不在元字元行列中

檢測工具

為了學習簡單,寫了一段測試程式碼做檢測用,當然你也可以使用網上的檢測工具,由於目前各個語言正則的引擎各有取捨,所以線上工具的檢測結果不一定和程式碼檢測結果相同(基本上沒太大出入),但用於理解正則,還是很有用的。

簡單案例:匹配5個連續的數字
正規表示式為[0-9]{5},先用開源中國的線上測試工具測試一下。待匹配的字串為“自由12345飛翔

JAVA檢測程式碼如下

/**
 * 檢測簡單方法
 * @param target //待查詢匹配的字串
 * @param regex  //匹配規則的正規表示式
 */
public static void simpletest(String target,String regex) {
    Pattern p = Pattern.compile(regex);//java.util.regex.Pattern;
    Matcher matcher = p.matcher(target);//java.util.regex.Pattern;
    while (matcher.find()) {
        System.out.println(matcher.group(0));
    }
}  
simpletest("自由12345飛翔", "[0-9]{5}");
//執行結果如下
12345  

普通字元

所謂普通字元即為非元字元,上文中提到的元字元列表,即不是上面列表中的字元,就視為普通字元,普通字元為原樣匹配

案例1,普通字元

simpletest("自123由飛12333翔", "123"); 
 //執行結果如下
123
123  

如上案例中,會去目標字串"自123由飛12333翔"中查詢123,由於123為普通字元,沒有特殊含義,此時原樣匹配,所以匹配到"自123由飛12333翔"中兩組123

案例2,元字元

simpletest("自[]由飛翔", "["); 
//執行結果如下
直接報錯 Exception in thread "main" java.util.regex.PatternSyntaxException: Unclosed character class

如果要讓元字元原樣匹配,則需要用\轉義元字元,JAVA中\\才表示普通字串的\,所以為\\[

simpletest("自[]由飛翔", "\\["); 
//執行結果如下
[  

如上,通過轉義,匹配到 “自[]由飛翔”中的元字元 [
而線上工具可以直接將字元讀入,所以不用\\\[就表示匹配字元[,如下

案例3,普通字元&

simpletest("自&&由飛翔", "&&"); 
//執行結果如下
&&
simpletest("自&由&飛翔", "&");
//執行結果如下
&
&  

案例3可以看出,雖然&&有特殊含義,但單獨用時,不用轉義,和普通字元完全相同

字元類

字元類(character class),這裡這個詞語是個專用名詞,在JAVA API 中的Pattern類中我們可以看到字元類的一個列表。一個[]中的規則叫一個字元類,一個字元類僅匹配一個字元(一個位置)

  • [abc] a、b 或 c(簡單類)
  • [^abc] 任何字元,除了 a、b 或 c(否定)
  • [a-zA-Z] a 到 z 或 A 到 Z,兩頭的字母包括在內(範圍) 數字範圍也能類似表示如[0-9]代表0到9中任意一個數字
  • [a-d[m-p]] a 到 d 或 m 到 p:[a-dm-p](並集) **等同於[a-d|[m-p]] 等同與 [[a-d]|[m-p]] **
  • [a-z&&[def]] d、e 或 f(交集)
  • [a-z&&[^bc]] a 到 z,除了 b 和 c:[ad-z](減去) 差集
  • [a-z&&[^m-p]] a 到 z,而非 m 到 p:[a-lq-z](減去)差集

案例

simpletest("abcd", "[abc]"); 
 //執行結果如下
a
b  
c

simpletest("abcd", "[^abc]"); 
 //執行結果如下
d

simpletest("abcd", "[a-zA-Z]");  
//執行結果如下
a
b
c

simpletest("an", "[a-d[m-p]]");   
 //執行結果如下
a
n  

simpletest("abcd", "[a-z&&[def]]");  
 //執行結果如下
d  

simpletest("abcd", "[a-z&&[^bc]]");   
 //執行結果如下
a
d 

simpletest("an", "[a-z&&[^m-p]]");  
  //執行結果如下
a

現在我們清楚的看出來,一個字元類,也就是[]及中間內容代表一個範圍,表示匹配一個字元,中括號中包含這個字元可能出現的所有情況,由於檢測工具中使用了迴圈查詢匹配,所以輸出結果會查詢到多個字元列印出來

預定義字元類

預定義字元類,是正規表示式中代表一組字元的特殊表示,由\打頭,如下為JAVA API 中Pattern類的預定義字元類列表

.: 任何字元(與行結束符可能匹配也可能不匹配)
\d:數字:[0-9]
\D:非數字: [^0-9]
\s:空白字元:[ \t\n\x0B\f\r]
\S:非空白字元:[^\s]
\w:單詞字元:[a-zA-Z_0-9]
\W:非單詞字元:[^\w]

案例

simpletest("自由12345飛翔", "\\d{5}"); //同理,\d在JAVA中需要轉義
//執行結果如下
12345  

simpletest("自由12345飛翔", "\\D+");  //預定義數量詞稍後再說
//執行結果如下
自由
飛翔

simpletest("自由 \t飛翔", "\\s+");  
//執行結果如下
`       `//此處匹配到一個空格和一個製表符

simpletest("自由 \t飛翔", "\\S+");  
//執行結果如下
自由
飛翔 

simpletest("自由abc飛翔", "\\w+");  
 //執行結果如下
abc

simpletest("自由abc飛翔", "\\W+");  
 //執行結果如下
自由
飛翔 

數量詞

預設數量詞

正則匹配中字元都有要匹配的數量,如果沒有加數量詞,預設數量為1,匹配一個的意思
案例1

simpletest("自由12345飛翔", "\\D");
 //執行結果如下
自
由
飛
翔

simpletest("自由12345飛翔", "\\D+");
 //執行結果如下
自由
飛翔 

如上案例中\\D代表匹配查詢非數字字元,預設數量詞為1,所以查詢到一個非數字字元後直接列印後,便進入下次查詢,結果如上第一段程式碼
如上案例中\\D+中引入+號預定義量詞,代表匹配大於等於1次的連續非數字字元,所以匹配到自由後進入下一次查詢

自定義量詞

使用者希望匹配幾次,就給定匹配次數,我這裡姑且叫它自定義量詞吧。由大括號,上下限數量組成,上限數量可以缺少

  • {n}:恰好n個
  • {n,}:大於等於n個
  • {n,m}:大於等於n個,小於等於m個

注意:並沒有{,m}這種寫法

案例

simpletest("自由12345飛翔", "\\d{2}");  
 //執行結果如下
12 

simpletest("自由12345飛翔", "\\d{2,}");  
 //執行結果如下
12345

simpletest("自由12345飛翔", "\\d{2,4}");  
 //執行結果如下
1234

simpletest("自由12345飛翔", "\\d{,7}");  
 //執行結果如下  
報錯 Exception in thread "main" java.util.regex.PatternSyntaxException: Illegal repetition near index 1
 

從上面案例中我們已經看出,量詞只形容最近字元的數量,大括號中可以指定具體字元的具體數量或者範圍。

預定義量詞

預定義量詞是正則中用?,+,* 三個符號表示特定意思的量詞

  • ?:一次或者零次
  • +:一次或者多次
  • *:零次或者零次以上

案例1

simpletest("自由12345飛翔", "\\d?");  
 //執行結果如下
                        //空行
                        //空行
1
2
3
4
5  
                         //空行
                         //空行

這裡要特別解釋一下兩個空行的產生,正則引擎去自由12345飛翔查詢\\d?時,逐個字元從左到右查詢,由於?表示一個或者零個,所以第一個字元匹配成功得到0個數字,也就是一個空字元,所以列印出來,而後面匹配到1個數字“1”列印出來,在匹配到1個數字“2”列印出來、、

案例2

simpletest("自由12345飛翔", "\\d+");   
 //執行結果如下
12345  

這裡匹配至少一個數字,直接匹配到5個數字“12345”輸出

案例3

simpletest("自由12345飛翔", "\\d*");   
 //執行結果如下
                        //空行
                        //空行
12345  
                        //空行
                        //空行

這裡出現空行的原因和案例1中相同,因為\d*代表0次或者0次以上

邊界識別符號

如下為JAVA API 中Pattern類的邊界識別符號列表
^ :行的開頭
$ :行的結尾
\b :單詞邊界
\B :非單詞邊界
\A :輸入的開頭
\G :上一個匹配的結尾
\Z :輸入的結尾,僅用於最後的結束符(如果有的話)
\z :輸入的結尾

目前並沒完全弄明白所有邊界識別符號的用法,抱歉,僅演示幾個。
案例1

simpletest("自由12345飛翔", "^\\d+");     
simpletest("12345飛翔", "^\\d+");   
 //執行結果如下
12345

^\\d+查詢行開頭緊跟1次或多次數字,顯然自由12345飛翔匹配失敗,因為12345並非行首,而12345飛翔匹配成功得到12345

案例2

simpletest("自由12345飛翔", "^\\d+$");   
simpletest("12345飛翔", "^\\d+$");      
simpletest("自由12345", "^\\d+$");  
simpletest("12345", "^\\d+$");  
//執行結果如下
12345  

\\d+前面加上行首邊界,後面加上行尾邊界後,該正則只能匹配到一串純數字,且數量滿足+量詞

案列3

simpletest("自由12345飛翔", "\\b\\d+"); 
//執行結果如下
//啥也沒有
simpletest("自由 12345飛翔", "\\b\\d+");   
//執行結果如下
12345  

simpletest("自由12345 飛翔", "\\d+\\b");   
//執行結果如下
12345  

simpletest("12345", "\\d+\\b");   
//執行結果如下
12345  

simpletest("12345", "\\b\\d+");   
//執行結果如下
12345 

從案例3中我們可以看出所謂的\b單詞邊界就是指空格或者行首行位(或許還有其他,反正匹配到一個連續的詞的結束或者開始位置)

案例4

simpletest("自由12345飛翔", "\\B\\d+"); 
//執行結果如下
12345 

simpletest("自由 12345飛翔", "\\B\\d+");   
//執行結果如下
2345

\B為非單詞邊界,和\b恰好相反,但案例4中效果卻和案例3中不是相反,不能匹配到12345,因為前面有空格,但2345前面是1,是非單詞邊界,所以匹配成功

正則組

至此前面,基本上把正規表示式簡單運用講完,現在我們來引入一個詞正則組,正則組是用()把一組字元當做一個整體,可以通過方法將這個組匹配到的字元單獨取出,同樣可以通過下標引用之前匹配到的該組的字元

簡單應用

案例

@Test
public void grouptest( ){
    
    String regex="\\d(\\d+)(\\D+)";
    String target="520LiLing";
    
    Pattern p = Pattern.compile(regex);
    Matcher matcher = p.matcher(target);
     while (matcher.find()) {
         System.out.println(matcher.group(0));
         System.out.println(matcher.group(1));
         System.out.println(matcher.group(2));
         System.out.println(matcher.group(3));
     }
}  

//執行結果如下
520LiLing
20
LiLing
Exception in thread "main" java.lang.IndexOutOfBoundsException: No group 3  

從簡單案例中可以看出()中匹配到的數字可以用matcher.group(1)方法取出,1代表第一組,案例中第一組為(\d+),第二組為(\D+),第三組沒找到,報錯。而matcher.group(1)代表整個正規表示式匹配到的內容。

複雜組序

JAVA API 中Pattern類中有關於正則組順序的介紹,當遇到複雜的正則組時,怎麼來確定組的序號。
((A)(B(C)))表示一個正規表示式,A,B,C分別代表隨意一個表示式

  • group(1):((A)(B(C)))
  • group(2):(A)
  • group(3):(B(C))
  • group(4):(C)

從上面的列表說明不難總結出一個規律,將正規表示式從左到右讀過來,依次遇到()中的左括號(依次編號,先遇到哪一組的左括號先編號
案例

@Test
public void grouptest( ){
    
    String regex="((\\d)(\\d+(\\D+)))";
    String target="520LiLing";
    
    Pattern p = Pattern.compile(regex);
    Matcher matcher = p.matcher(target);
     while (matcher.find()) {
         System.out.println(matcher.group(1));
         System.out.println(matcher.group(2));
         System.out.println(matcher.group(3));
         System.out.println(matcher.group(4));
     }
}  

//執行結果如下
520LiLing
5
20LiLing
LiLing  

案例和上文說明完全一致,1組為((\\d)(\\d+(\\D+))),2組為(\\d),3組為(\\d+(\\D+)),4組為(\\D+)

捕獲組

前面已經講過關於正則組的編號,以及引用,但這樣的作用似乎還不夠強大。捕獲組,就是將之前的正則組通過\組序號捕獲,如\1(任然需要轉義\\1),再次利用。(解釋起來太費勁,看案例吧)

@Test
public void grouptest( ){
    
    String regex="(\\d+).+\\1";
    String target="520Li320Ling";
    
    Pattern p = Pattern.compile(regex);
    Matcher matcher = p.matcher(target);
     while (matcher.find()) {
         System.out.println(matcher.group(0));
         System.out.println(matcher.group(1));
      
     }
}  
//執行結果如下
20Li320
20 

上面案例中,正規表示式(\\d+).+\\1 的意思就是先查詢到數字標記為組1,然後跟著任意字元,跟著\\1表示捕獲和組1一模一樣的內容。

相關文章