Java 正則表達式的總結和一些小例子

字符串處理是許多程序中非常重要的一部分,它們可以用於文本顯示,數據表示,查找鍵和很多目的.在Unix下,用戶可以使用正則表達式的強健功能實現這些 目的,從Java1.4起,Java核心API就引入了java.util.regex程序包,它是一種有價值的基礎工具,可以用於很多類型的文本處理, 如匹配,搜索,提取和分析結構化內容.

java.util.regex是一個用正則表達式所訂制的模式來對字符串進行匹配工作的類庫包。它包括兩個類：Pattern和Matcher.
Pattern是一個正則表達式經編譯后的表現模式。 在java中,通過適當命名的Pattern類可以容易確定String是否匹配某種模式.模式可以象匹配某個特定的String那樣簡單,也可以很復 雜,需要采用分組和字符類,如空白,數字,字母或控制符.因為Java字符串基於統一字符編碼(Unicode),正則表達式也適用於國際化的應用程序. 

Pattern類的方法簡介

方法	說明
static Pettern compile(String regex,int flag)	編譯模式,參數regex表示輸入的正則表達式,flag表示模式類型(Pattern.CASE_INSENSITIVE 表示不區分大小寫)
Matcher match(CharSequence input)	獲取匹配器,input時輸入的待處理的字符串
static boolean matches(String regex, CharSequence input)	快速的匹配調用,直接根據輸入的模式regex匹配input
String[] split(CharSequence input,int limit)	分隔字符串input,limit參數可以限制分隔的次數

Matcher 一個Matcher對象是一個狀態機器，它依據Pattern對象做為匹配模式對字符串展開匹配檢查。首先一個Pattern實例訂制了一個所用語法與 PERL的類似的正則表達式經編譯后的模式，然后一個Matcher實例在這個給定的Pattern實例的模式控制下進行字符串的匹配工作。

Matcher類的方法簡述

方法	說明
boolean matches()	對整個輸入字符串進行模式匹配.
boolean lookingAt()	從輸入字符串的開始處進行模式匹配
boolean find(int start)	從start處開始匹配模式
int groupCount()	返回匹配后的分組數目
String replaceAll(String replacement)	用給定的replacement全部替代匹配的部分
String repalceFirst(String replacement)	用給定的replacement替代第一次匹配的部分
Matcher appendReplacement(StringBuffer sb,String replacement)	根據模式用replacement替換相應內容,並將匹配的結果添加到sb當前位置之后
StringBuffer appendTail(StringBuffer sb)	將輸入序列中匹配之后的末尾字串添加到sb當前位置之后.

正則表達式中常見通配符:

對於單字符串比較而言,使用正則表達式沒有什么優勢.Regex的真正強大之處在於體現在包括字符類和量詞( * , + , ? )的更復雜的模式上.
字符類包括:
\d  數字
\D  非數字
\w  單字字符( 0 - 9 ,A - Z,a - z)
\W 非單字字符
\s  空白(空格符,換行符,回車符,制表符)
\S 非空白
[]  由方括號內的一個字符列表創建的自定義字符類
.   匹配任何單個字符
下面的字符將用於控制將一個子模式應用到匹配次數的過程.
?   重復前面的子模式0次到一次
*   重復前面的子模式0次或多次
+  重復前面的子模式一次到多次

以下是實例部分:

實例一:

正則式是最簡單的能准確匹配一個給定String的模式,模式與要匹配的文本是等價的.靜態的Pattern.matches方法用於比較一個String是否匹配一個給定模式.例程如下:
String data = " java " ;
boolean  result = Pattern.matches( " java " ,data);

實例二:

 String[] dataArr  =  {  " moon " ,  " mon " ,  " moon " ,  " mono "  };

     for  (String str : dataArr) {
      String patternStr = " m(o+)n " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失敗 " );
      }     
    }

模式是”m(o + )n”,它表示mn中間的o可以重復一次或多次,因此moon,mon,mooon能匹配成功,而mono在n后多了一個o,和模式匹配不上.

注:
+ 表示一次或多次; ? 表示0次或一次; * 表示0次或多次.

實例三:

 String[] dataArr  =  {  " ban " ,  " ben " ,  " bin " ,  " bon "  , " bun " , " byn " , " baen " };

     for  (String str : dataArr) {
      String patternStr = " b[aeiou]n " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失敗 " );
      }     
    }

注:方括號中只允許的單個字符,模式“b[aeiou]n”指定,只有以b開頭,n結尾,中間是a,e,i,o,u中任意一個的才能匹配上,所以數組的前五個可以匹配,后兩個元素無法匹配.

方括號[]表示只有其中指定的字符才能匹配.

實例四:

 String[] dataArr  =  {  " been " ,  " bean " ,  " boon " ,  " buin "  , " bynn " };

     for  (String str : dataArr) {
      String patternStr = " b(ee|ea|oo)n " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失敗 " );
      }     
    }

如果需要匹配多個字符,那么[]就不能用上了,這里我們可以用()加上 | 來代替,()表示一組, | 表示或的關系,模式b(ee | ea | oo)n就能匹配been,bean,boon等.
因此前三個能匹配上,而后兩個不能.

實例五:

 String[] dataArr  =  {  " 1 " ,  " 10 " ,  " 101 " ,  " 1010 "  , " 100+ " };

     for  (String str : dataArr) {
      String patternStr = " \d+ " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失敗 " );
      }     
    }

注:從前面可以知道,\d表示的是數字,而 + 表示一次或多次,所以模式\d + 就表示一位或多位數字.
因此前四個能匹配上,最后一個因為 + 號是非數字字符而匹配不上.

實例六:

String[] dataArr  =  {  " a100 " ,  " b20 " ,  " c30 " ,  " df10000 "  , " gh0t " };

     for  (String str : dataArr) {
      String patternStr = " \w+\d+ " ;
      
       boolean  result  =  Pattern.matches(patternStr, str);
       if  (result) {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 成功 " );
      }
       else {
        System.out.println( " 字符串 " + str + " 匹配模式 " + patternStr + " 失敗 " );
      }     
    }

模式\w + \d + 表示的是以多個單字字符開頭,多個數字結尾的字符串,因此前四個能匹配上,最后一個因為數字后還含有單字字符而不能匹配.

實例七:

 String str = " 薪水,職位 姓名;年齡 性別 " ;
    String[] dataArr  = str.split( " [,\s;] " );
     for  (String strTmp : dataArr) {
      System.out.println(strTmp); 
    }

String類的split函數支持正則表達式,上例中模式能匹配”,”,單個空格,”;”中的一個,split函數能把它們中任意一個當作分隔符,將一個字符串劈分成字符串數組.

實例八:

String str = " 2007年12月11日 " ;
Pattern p  =  Pattern.compile( " [年月日] " ); 
String[] dataArr  = p.split(str);
for  (String strTmp : dataArr) {
System.out.println(strTmp);
}

Pattern是一個正則表達式經編譯后的表現模式 ,它的split方法能有效劈分字符串.
注意其和String.split()使用上的不同.

實例九:

String str = " 10元 1000人民幣 10000元 100000RMB " ;
str = str.replaceAll( " (\d+)(元|人民幣|RMB) " ,  " ￥ " );
System.out.println(str);

上例中,模式“(\d + )(元 | 人民幣 | RMB)”按括號分成了兩組,第一組\d + 匹配單個或多個數字,第二組匹配元,人民幣,RMB中的任意一個,替換部分表示第一個組匹配的部分不變,其余組替換成￥.

替換后的str為￥ 10  ￥ 1000  ￥ 10000  ￥ 100000

實例十:

Pattern p  =  Pattern.compile( " m(o+)n " ,Pattern.CASE_INSENSITIVE);

//  用Pattern類的matcher()方法生成一個Matcher對象
Matcher m  =  p.matcher( " moon mooon Mon mooooon Mooon " );
StringBuffer sb  =   new  StringBuffer();

//  使用find()方法查找第一個匹配的對象
boolean  result  =  m.find();

//  使用循環找出模式匹配的內容替換之,再將內容加到sb里
while  (result) {
m.appendReplacement(sb,  " moon " );
result  =  m.find();
}
//  最后調用appendTail()方法將最后一次匹配后的剩余字符串加到sb里；
m.appendTail(sb);

System.out.println( " 替換后內容是 "   +  sb.toString());

實例十一:

除了用 + 表示一次或多次, * 表示0次或多次, ? 表示0次或一次外,還可以用{}來指定精確指定出現的次數,X{ 2 , 5 }表示X最少出現2次,最多出現5次;X{ 2 ,}表示X最少出現2次,多則不限;X{ 5 }表示X只精確的出現5次.
例程:
String[] dataArr  =  {  " google " ,  " gooogle " ,  " gooooogle " ,  " goooooogle " , " ggle " };

for  (String str : dataArr) {
    String patternStr  =   " g(o{2,5})gle " ;

     boolean  result  =  Pattern.matches(patternStr, str);
     if  (result) {
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  patternStr  +   " 成功 " );
    }  else  {
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  patternStr  +   " 失敗 " );
    }
}

實例十二:

- 表示從..到…,如[a - e]等同於[abcde]
 String[] dataArr  =  {  " Tan " ,  " Tbn " ,  " Tcn " ,  " Ton " , " Twn " };

     for  (String str : dataArr) {
      String regex  =   " T[a-c]n " ;

       boolean  result  =  Pattern.matches(regex, str);
       if  (result) {
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  regex  +   " 成功 " );
      }  else  {
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  regex  +   " 失敗 " );
      }
    }

實例十三:不區分大小寫匹配.

正則表達式默認都是區分大小寫的,使用了Pattern.CASE_INSENSITIVE則不對大小寫進行區分.

 String patternStr = " ab " ;
    Pattern pattern = Pattern.compile(patternStr, Pattern.CASE_INSENSITIVE);
    
    String[] dataArr  =  {  " ab " ,  " Ab " ,  " AB " };
    
     for  (String str : dataArr) {
      Matcher matcher = pattern.matcher(str);
      
       if (matcher.find()){
        System.out.println( " 字符串 "   +  str  +   " 匹配模式 "   +  patternStr  +   " 成功 " );
      }
    }

實例十四:使用正則表達式劈分字符串.

 注意這里要把復雜的模式寫在前面,否則簡單模式會先匹配上.

String input = " 職務=GM 薪水=50000 , 姓名=職業經理人 ; 性別=男  年齡=45  " ;
    String patternStr = " (\s*,\s*)|(\s*;\s*)|(\s+) " ;
    Pattern pattern = Pattern.compile(patternStr);
    
    String[] dataArr = pattern.split(input);
    
     for  (String str : dataArr) {
      System.out.println(str);
    }

實例十五:解析正則表達式中的文字,對應第一個小括號括起來的group1.

String regex = " <(\w+)>(\w+)</> " ;
Pattern pattern = Pattern.compile(regex);
    
String input = " <name>Bill</name><salary>50000</salary><title>GM</title> " ;
    
Matcher matcher = pattern.matcher(input);
    
while (matcher.find()){
      System.out.println(matcher.group( 2 ));
}

實例十六:將單詞數字混合的字符串的單詞部分大寫.
    String regex="([a-zA-Z]+[0-9]+)";   
    Pattern pattern=Pattern.compile(regex);
    
    String input="age45 salary500000 50000 title";
    
    Matcher matcher=pattern.matcher(input);
    
    StringBuffer sb=new StringBuffer();
    
    while(matcher.find()){
      String replacement=matcher.group(1).toUpperCase();
      matcher.appendReplacement(sb, replacement);
    }
    matcher.appendTail(sb);
    
    System.out.println("替換完的字串為"+sb.toString());

 

本文摘自：http://www.rsky.com.cn/Article/java/201005/11809.html