Java中正則表達式的使用

 在Java中，我們為了查找某個給定字符串中是否有需要查找的某個字符或者子字串、或者對字符串進行分割、或者對字符串一些字符進行替換/刪除，一般會通過if-else、for 的配合使用來實現這些功能 。如下所示：

 

 public class Test{
   public static void main(String args[]) {
          String str="@Shang Hai Hong Qiao Fei Ji Chang";
          boolean rs = false;
          for(int i=0;i<str.length();i++){
                 char z=str.charAt(i);
                 if('a' == z || 'F' == z) {
                        rs  = true;
                        break;
                 }else{
                        rs= false;
                 }
          }
          System.out.println(rs);
        }
 }

      這種方法使用簡單直觀，但是 難以解決復雜的工作，而且代碼量也會增加很多，不利於維護。

 

      這時，我們可以使用正則表達式來實現這些功能，而且代碼簡單易維護。下面就來介紹了Java中對字符串的正則表達式的幾個常用的功能，具體情況如下所示（其中用到了java.util.regex包）：

 

1.Java中在某個字符串中查詢某個字符或者某個子字串

 String s = "@Shang Hai Hong Qiao Fei Ji Chang";
 String regEx = "a|F"; //表示a或F
 Pattern pat = Pattern.compile(regEx);
 Matcher mat = pat.matcher(s);
 boolean rs = mat.find();

    如果s中有regEx，那么rs為true，否則為flase。

    如果想在查找時忽略大小寫，則可以寫成Pattern pat=Pattern.compile(regEx,Pattern.CASE_INSENSITIVE);

 

2.在某個文件中獲取一段字符串

 String regEx = ".+\(.+)$";
 String s = "c:\test.txt";
 Pattern pat = Pattern.compile(regEx);
 Matcher mat = pat.matcher(s);
 boolean rs = mat.find();
 for(int i=1;i<=mat.groupCount();i++){
 　　System.out.println(mat.group(i));
 }

 　以上的執行結果為test.txt，提取的字符串儲存在mat.group(i)中，其中i最大值為mat.groupCount();

 

3.對字符串的分割

 String regEx=":";
 Pattern pat = Pattern.compile(regEx);
 String[] rs = pat.split("aa:bb:cc");

 　執行后，r就是{"aa","bb","cc"}

    如果用正則表達式分割就如上所示，一般我們都會使用下面更簡單的方法：

 String s = "aa:bb:cc";
 String[] rs=s.split(":");

 

4.字符串的替換/刪除

 String regEx="@+"; //表示一個或多個@
 Pattern pat=Pattern.compile(regEx);
 Matcher mat=pat.matcher("@@aa@b cc@@");
 String s=mat.replaceAll("#");

　結果為"##aa#b cc##"
　　
　如果要把字符串中的@都給刪除，只用要空字符串替換就可以了：

 String s=mat.replaceAll("");

 　結果為"aab cc"

 

 

注：對Pattern類的說明： 
      1.public final class java.util.regex.Pattern是正則表達式編譯后的表達法。

      下面的語句將創建一個Pattern對象並賦值給句柄pat：Pattern pat = Pattern.compile(regEx);
      有趣的是，Pattern類是final類，而且它的構造器是private。也許有人告訴你一些設計模式的東西，或者你自己查有關資料。這里的結論是：Pattern類不能被繼承，我們不能通過new創建Pattern類的對象。
       因此在Pattern類中，提供了2個重載的靜態方法，其返回值是Pattern對象（的引用）。如：

 public static Pattern compile(String regex) {
         return new Pattern(regex, 0);
 }

       當然，我們可以聲明Pattern類的句柄，如Pattern pat = null；

 

    2.pat.matcher(str)表示以用Pattern去生成一個字符串str的匹配器，它的返回值是一個Matcher類的引用。
       我們可以簡單的使用如下方法：boolean rs = Pattern.compile(regEx).matcher(str).find();

 

 正則表達式以過濾特殊字符:

Java代碼  

 // 過濾特殊字符
     public   static   String StringFilter(String   str)   throws   PatternSyntaxException   {
                 // 只允許字母和數字
                 // String   regEx  =  "[^a-zA-Z0-9]";
                    // 清除掉所有特殊字符
           String regEx="[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";
           Pattern   p   =   Pattern.compile(regEx);
           Matcher   m   =   p.matcher(str);
           return   m.replaceAll("").trim();
           }
     @Test
     public    void   testStringFilter()   throws   PatternSyntaxException   {
           String   str   =   "*adCVs*34_a _09_b5*[/435^*&城池()^$$&*).{}+.|.)%%*(*.中國}34{45[]12.fd'*&999下面是中文的字符￥……{}【】。，；’“‘”？";
           System.out.println(str);
           System.out.println(StringFilter(str));
           }

拋開空泛的概念，下面寫出幾個簡單的Java正則用例： 

◆比如，在字符串包含驗證時 

//查找以Java開頭,任意結尾的字符串 
Pattern pattern = Pattern.compile("^Java.*"); 
Matcher matcher = pattern.matcher("Java不是人"); 
boolean b= matcher.matches(); 
//當條件滿足時，將返回true，否則返回false 
System.out.println(b); 


◆以多條件分割字符串時 
Pattern pattern = Pattern.compile("[, |]+"); 
String[] strs = pattern.split("Java Hello World Java,Hello,,World|Sun"); 
for (int i=0;i<strs.length;i++) { 
    System.out.println(strs[i]); 
} 

◆文字替換（首次出現字符） 
Pattern pattern = Pattern.compile("正則表達式"); 
Matcher matcher = pattern.matcher("正則表達式 Hello World,正則表達式 Hello World"); 
//替換第一個符合正則的數據 
System.out.println(matcher.replaceFirst("Java")); 

◆文字替換（全部） 
Pattern pattern = Pattern.compile("正則表達式"); 
Matcher matcher = pattern.matcher("正則表達式 Hello World,正則表達式 Hello World"); 
//替換第一個符合正則的數據 
System.out.println(matcher.replaceAll("Java")); 


◆文字替換（置換字符） 
Pattern pattern = Pattern.compile("正則表達式"); 
Matcher matcher = pattern.matcher("正則表達式 Hello World,正則表達式 Hello World "); 
StringBuffer sbr = new StringBuffer(); 
while (matcher.find()) { 
    matcher.appendReplacement(sbr, "Java"); 
} 
matcher.appendTail(sbr); 
System.out.println(sbr.toString()); 

◆驗證是否為郵箱地址 

String str="[e-mail]"; 
Pattern pattern = Pattern.compile("[\\w\\.\\-]+@([\\w\\-]+\\.)+[\\w\\-]+",Pattern.CASE_INSENSITIVE); 
Matcher matcher = pattern.matcher(str); 
System.out.println(matcher.matches()); 

◆去除html標記 
Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL); 
Matcher matcher = pattern.matcher("<a href=\"index.html\">主頁</a>"); 
String string = matcher.replaceAll(""); 
System.out.println(string); 

◆查找html中對應條件字符串 
Pattern pattern = Pattern.compile("href=\"(.+?)\""); 
Matcher matcher = pattern.matcher("<a href=\"index.html\">主頁</a>"); 
if(matcher.find()) 
System.out.println(matcher.group(1)); 
} 

◆截取http://地址 
//截取url 
Pattern pattern = Pattern.compile("(http://|https://){1}[\\w\\.\\-/:]+"); 
Matcher matcher = pattern.matcher("dsdsds<http://dsds//gfgffdfd>fdf"); 
StringBuffer buffer = new StringBuffer(); 
while(matcher.find()){              
    buffer.append(matcher.group());        
    buffer.append("\r\n");              
System.out.println(buffer.toString()); 
} 
        
◆替換指定{}中文字 

String str = "Java目前的發展史是由{0}年-{1}年"; 
String[][] object={new String[]{"\\{0\\}","1995"},new String[]{"\\{1\\}","2007"}}; 
System.out.println(replace(str,object)); 

public static String replace(final String sourceString,Object[] object) { 
            String temp=sourceString;    
            for(int i=0;i<object.length;i++){ 
                      String[] result=(String[])object[i]; 
               Pattern    pattern = Pattern.compile(result[0]); 
               Matcher matcher = pattern.matcher(temp); 
               temp=matcher.replaceAll(result[1]); 
            } 
            return temp; 
} 


◆以正則條件查詢指定目錄下文件 

//用於緩存文件列表 
        private ArrayList files = new ArrayList(); 
        //用於承載文件路徑 
        private String _path; 
        //用於承載未合並的正則公式 
        private String _regexp; 
        
        class MyFileFilter implements FileFilter { 

            /** 
               * 匹配文件名稱 
               */ 
            public boolean accept(File file) { 
                try { 
                  Pattern pattern = Pattern.compile(_regexp); 
                  Matcher match = pattern.matcher(file.getName());                
                  return match.matches(); 
                } catch (Exception e) { 
                  return true; 
                } 
            } 
            } 
        
        /** 
        * 解析輸入流 
        * @param inputs 
        */ 
        FilesAnalyze (String path,String regexp){ 
            getFileName(path,regexp); 
        } 
        
        /** 
        * 分析文件名並加入files 
        * @param input 
        */ 
        private void getFileName(String path,String regexp) { 
            //目錄 
              _path=path; 
              _regexp=regexp; 
            File directory = new File(_path); 
            File[] filesFile = directory.listFiles(new MyFileFilter()); 
            if (filesFile == null) return; 
            for (int j = 0; j < filesFile.length; j++) { 
                files.add(filesFile[j]); 
            } 
            return; 
            } 
    
        /** 
         * 顯示輸出信息 
         * @param out 
         */ 
        public void print (PrintStream out) { 
            Iterator elements = files.iterator(); 
            while (elements.hasNext()) { 
                File file=(File) elements.next(); 
                    out.println(file.getPath());    
            } 
        } 

        public static void output(String path,String regexp) { 

            FilesAnalyze fileGroup1 = new FilesAnalyze(path,regexp); 
            fileGroup1.print(System.out); 
        } 
    
        public static void main (String[] args) { 
            output("C:\\","[A-z|.]*"); 
        } 

附 ： 常用的正則表達式：

匹配特定數字：
^[1-9]d*$　 　 //匹配正整數
^-[1-9]d*$ 　 //匹配負整數
^-?[1-9]d*$　　 //匹配整數
^[1-9]d*|0$　 //匹配非負整數（正整數 + 0）
^-[1-9]d*|0$　　 //匹配非正整數（負整數 + 0）
^[1-9]d*.d*|0.d*[1-9]d*$　　 //匹配正浮點數
^-([1-9]d*.d*|0.d*[1-9]d*)$　 //匹配負浮點數
^-?([1-9]d*.d*|0.d*[1-9]d*|0?.0+|0)$　 //匹配浮點數
^[1-9]d*.d*|0.d*[1-9]d*|0?.0+|0$　　 //匹配非負浮點數（正浮點數 + 0）
^(-([1-9]d*.d*|0.d*[1-9]d*))|0?.0+|0$　　//匹配非正浮點數（負浮點數 + 0）
評注：處理大量數據時有用，具體應用時注意修正

匹配特定字符串：
^[A-Za-z]+$　　//匹配由26個英文字母組成的字符串
^[A-Z]+$　　//匹配由26個英文字母的大寫組成的字符串
^[a-z]+$　　//匹配由26個英文字母的小寫組成的字符串
^[A-Za-z0-9]+$　　//匹配由數字和26個英文字母組成的字符串
^w+$　　//匹配由數字、26個英文字母或者下划線組成的字符串

在使用RegularExpressionValidator驗證控件時的驗證功能及其驗證表達式介紹如下:

只能輸入數字：“^[0-9]*$”
只能輸入n位的數字：“^d{n}$”
只能輸入至少n位數字：“^d{n,}$”
只能輸入m-n位的數字：“^d{m,n}$”
只能輸入零和非零開頭的數字：“^(0|[1-9][0-9]*)$”
只能輸入有兩位小數的正實數：“^[0-9]+(.[0-9]{2})?$”
只能輸入有1-3位小數的正實數：“^[0-9]+(.[0-9]{1,3})?$”
只能輸入非零的正整數：“^+?[1-9][0-9]*$”
只能輸入非零的負整數：“^-[1-9][0-9]*$”
只能輸入長度為3的字符：“^.{3}$”
只能輸入由26個英文字母組成的字符串：“^[A-Za-z]+$”
只能輸入由26個大寫英文字母組成的字符串：“^[A-Z]+$”
只能輸入由26個小寫英文字母組成的字符串：“^[a-z]+$”
只能輸入由數字和26個英文字母組成的字符串：“^[A-Za-z0-9]+$”
只能輸入由數字、26個英文字母或者下划線組成的字符串：“^w+$”
驗證用戶密碼:“^[a-zA-Z]w{5,17}$”正確格式為：以字母開頭，長度在6-18之間，

只能包含字符、數字和下划線。
驗證是否含有^%&’,;=?$”等字符：“[^%&’,;=?$x22]+”
只能輸入漢字：“^[u4e00-u9fa5],{0,}$”
驗證Email地址：“^w+[-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$”
驗證InternetURL：“^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$”
驗證電話號碼：“^((d{3,4})|d{3,4}-)?d{7,8}$”

正確格式為：“XXXX-XXXXXXX”，“XXXX-XXXXXXXX”，“XXX-XXXXXXX”，

“XXX-XXXXXXXX”，“XXXXXXX”，“XXXXXXXX”。
驗證身份證號（15位或18位數字）：“^d{15}|d{}18$”
驗證一年的12個月：“^(0?[1-9]|1[0-2])$”正確格式為：“01”-“09”和“1”“12”
驗證一個月的31天：“^((0?[1-9])|((1|2)[0-9])|30|31)$”

正確格式為：“01”“09”和“1”“31”。

匹配中文字符的正則表達式： [u4e00-u9fa5]
匹配雙字節字符(包括漢字在內)：[^x00-xff]
匹配空行的正則表達式：n[s| ]*r
匹配HTML標記的正則表達式：/< (.*)>.*|< (.*) />/
匹配首尾空格的正則表達式：(^s*)|(s*$)
匹配Email地址的正則表達式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
匹配網址URL的正則表達式：http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?