Java的正則表達式深入分析

更新時間：2013年04月25日 15:50:47 作者：

本篇文章介紹了，Java的正則表達式深入分析。需要的朋友參考下

一.regex（正則表達式）：RegularExpressions（代替了StringTokenizer）；字符串處理利器；在unix流行，perl使用regex更牛。
主要用在字符串匹配、查找和替換。例如：匹配IP（范圍小于256）使用正則很好搞；從網(wǎng)頁中揪出大量email地址發(fā)送垃圾郵件；從網(wǎng)頁里揪出鏈接。包含Matcher（用模式匹配字符串后產(chǎn)生的結(jié)果）和pattern。

復制代碼代碼如下:

/*
          * 告知此字符串是否匹配給定的正則表達式(也是一個字符串)。
          */
         System.out.println("abc".matches("..."));//每個"."表示一個字符

復制代碼代碼如下:

 /*
          * 把字符串里的所有數(shù)字替換成"-"，普通方法需要charAt逐個判斷;
          * "\\d"表示任意一個數(shù)字或者換成"[0-9]";
          * "\\D"表示任意一個非數(shù)字或者換成"[^0-9]"
          */
         System.out.println("ab54564654sbg48746bshj".replaceAll("[0-9]", "-"));//每個"."表示一個字符

二、

復制代碼代碼如下:

/*
          * compile將給定的正則表達式編譯到模式中(每次編譯需要費時間);{3}表示恰好三次。
          *     X{n} X，恰好 n 次 
          *    X{n,} X，至少 n 次 
          *    X{n,m} X，至少 n 次，但是不超過 m 次 
          */
         Pattern p = Pattern.compile("[a-z]{3}");
         Matcher m = p.matcher("ggs");//創(chuàng)建匹配給定輸入與此模式的匹配器。內(nèi)部實際上是創(chuàng)建了一個優(yōu)先狀態(tài)的自動機(編譯原理)
         //matcher和matches里待匹配的字符串實際上是CharSequence（接口）,不過String實現(xiàn)了該接口，存在多態(tài)
         System.out.println(m.matches());//若是"ggss"就不匹配了
         //可一直接"ggs".matches("[a-z]{3}"),不過上面的有好處，至少效率高了，而且Pattern和Matcher提供了很多功能

三、在regex“. * +”中叫Meta Character；ctrl + shift + "/"表示注釋，換成"\"表示去掉注釋。

復制代碼代碼如下:

"a".matches(".");//true,"."表示任意一個字符,漢字也行
         "aa".matches("aa");//true,也就是說普通字符串也可以作為正則表達式
         /*
          * true,"*"表示0或者多個字符,不過后面的要和第一個相同，
          * 否則false，也就是判斷字符串是否是單一字符組成的字符串
          */
         "aaaa".matches("a*");
         "".matches("a*");//true
         "aaa".matches("a?");//true，一次或者0次
         "".matches("a?");//true
         "a".matches("a?");//true
         "544848154564113".matches("\\d{3,100}");//true
         //這個是最簡單的IP判斷，不過若是超過255則判斷不出來
         "192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\d{1,3}");
         "192".matches("[0-2][0-9][0-9]");

四、[abc]表示匹配任意一個字符；[^abc]表示出了abc以外的其他字母（必須還是字母，若是空串也返回false）字符;[a-zA-Z]等價于"[a-z]|[A-Z]"是否是某個大小寫字母；[A-Z&&[ABS]]表示大寫字母中取ABS中任一個。

復制代碼代碼如下:

//發(fā)現(xiàn)|和||沒區(qū)別，&和&&有區(qū)別，不知道這么理解對不對
         System.out.println("C".matches("[A-Z&&[ABS]]"));//false
         System.out.println("C".matches("[A-Z&[ABS]]"));//true
         System.out.println("A".matches("[A-Z&&[ABS]]"));//true
         System.out.println("A".matches("[A-Z&[ABS]]"));//true
         System.out.println("C".matches("[A-Z|[ABS]]"));//true
         System.out.println("C".matches("[A-Z||[ABS]]"));//true

五、\w 單詞字符：[a-zA-Z_0-9] 進行用戶名匹配時;\s 空白字符：[ \t\n\x0B\f\r]； \S 非空白字符：[^\s] ；\W 非單詞字符：[^\w] 。

復制代碼代碼如下:

" \n\t\r".matches("\\s{4}");//true
         " ".matches("\\S");//false
         "a_8".matches("\\w{3}");//true
         //“+”表示一次或者多次
         "abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+");//true
         /*
          * 待匹配字符也只是一個反斜線,不過不可寫成"\"那么和后面的"組合了，
          * 前面的"無法匹配就會CE。
          * 后面不可寫成"\\",那么會運行錯誤（編譯沒問題），必須寫成"\\\\"
          */
         System.out.println("\\".matches("\\\\"));//true

六、POSIX 字符類（僅 US-ASCII）

復制代碼代碼如下:

　\p{Lower} 小寫字母字符：[a-z] ;\p{Upper} 大寫字母字符：[A-Z] ;\p{ASCII} 所有 ASCII：[\x00-\x7F] ;\p{Alpha} 字母字符：[\p{Lower}\p{Upper}] ;\p{Digit} 十進制數(shù)字：[0-9] 。

七、邊界匹配器
^ 行的開頭
　　$ 行的結(jié)尾
　　\b 單詞邊界
　　\B 非單詞邊界
　　\A 輸入的開頭
　　\G 上一個匹配的結(jié)尾
　　\Z 輸入的結(jié)尾，僅用于最后的結(jié)束符（如果有的話）
　　\z 輸入的結(jié)尾

復制代碼代碼如下:

"hello world".matches("^h.*");//^行的開頭
         "hello world".matches(".*ld$");//$行的結(jié)尾
         "hello world".matches("^h[a-z]{1,3}o\\b.*");//\b單詞邊界
         "helloworld".matches("^h[a-z]{1,3}o\\b.*");

" \n".matches("^[\\s&&[^\\n]]*\\n$");//判斷空白行，空白行開頭是空白符

八、還可以在find方法下使用m.start()和m.end()返回開始位置和結(jié)束位置的下一個；若是找不到則出錯。

復制代碼代碼如下:

Pattern p = Pattern.compile("\\d{3,5}");
         String s = "133-34444-333-00";
         Matcher m = p.matcher(s);
         m.matches();//matches匹配全部字符串
         m.reset();
         /*
          * 下面若是先調(diào)用了reset方法則輸出true，true，true，false.
          * 否則倒數(shù)第二個find也輸出false。
          * 原因如下：
          * matches匹配到第一個"-"發(fā)現(xiàn)不匹配了，但是這四個字符已經(jīng)被吃掉啦，再次匹配就從
          * 34444開始了,第二個find從333，因為find匹配的是下一個子序列。
          * reset方法讓matches吃掉的字符串再吐出來。
          * 綜上：matches和find之間要使用reset，因為二者相互影響
          * 
          */
         m.find();
         m.find();
         m.find();//嘗試查找與該模式匹配的輸入序列的下一個子序列
         m.find();
         /*
          * 嘗試將從區(qū)域開頭開始的輸入序列與該模式匹配。
          * Thinking in java的作者狠狠滴批評了這個方法，因為從字面看不出來到底從哪開始匹配。
          * 下面全部是true，因為每次都從頭開始
          */
         m.lookingAt();
         m.lookingAt();
         m.lookingAt();
         m.lookingAt();

九、字符串替換

復制代碼代碼如下:

import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 public class TestRegexReplacement {

     public static void main(String[] args) {

         Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//后面的參數(shù)是整形,表示“大小寫不敏感”
         Matcher m = p.matcher("Java java hxsyl Ilovejava java JaVaAcmer");
         while(m.find()) {
             System.out.println(m.group());//m.group會輸出所有的java（忽略大小寫）

         }

         
         String s = m.replaceAll("Java");//String也有該方法
         System.out.println(s);

         m.reset();//一定要加，因為find和matcher相互影響
         StringBuffer sb = new StringBuffer();
         int i = 0;
         /*
          * 下面的方法是把找到的奇數(shù)個java替換為“Java”，偶數(shù)個替換成"java"
          */
         while(m.find()) {
             i++;
             //不能直接寫成i&1必須轉(zhuǎn)化為boolean
             if((i&1)==1) {
                 m.appendReplacement(sb, "Java");
             }else {
                 m.appendReplacement(sb, "java");
             }
         }

         m.appendTail(sb);//把找到的最后一個java后邊的剩余字符串加上
         System.out.println(sb);//不加reset的話只輸出了Acmer
     }
 }

十、分組

復制代碼代碼如下:

/*
          * 分別加上小括號，不算最外邊的大括號，第一個左括號便是第一組
          */
         Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");
         String s = "123aaa-77878bb-646dd-00";
         Matcher m = p.matcher(s);
         while(m.find()) {
             System.out.println(m.group());
             System.out.println(m.group(1));//輸出每對符合的 數(shù)字
             System.out.println(m.group(2));//輸出每對符合的 字母
         }

十一、抓取網(wǎng)頁中的email

復制代碼代碼如下:

import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 /*
  * 需要什么養(yǎng)的方法的話先些方法名
  * 然后ctrl + 1列出推薦，系統(tǒng)創(chuàng)建該方法
  */
 public class EmailSpider {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         try {
             BufferedReader br = new BufferedReader(new FileReader("F:\\regex.html"));
             String line = "";
             try {
                 while((line=br.readLine())!=null) {
                     solve(line);
                 }
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

 
     }

     private static void solve(String line) {
         // TODO Auto-generated method stub
         //正則表達式要是不滿足相應功能的話不會出錯，因為他是字符串
         Pattern p = Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");
         Matcher m = p.matcher(line);

         while(m.find()) {
             System.out.println(m.group());
         }

     }

 }

十二、代碼統(tǒng)計

復制代碼代碼如下:

View Code 
 /*
  * 統(tǒng)計代碼里多少空行，注釋行，程序行
  * 實際上使用String里的startsWith和endsWith也行.
  * 若是項目經(jīng)理用的話還要統(tǒng)計每行的字符數(shù)是否以{；結(jié)尾，防止偷懶
  */
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;

 public class CoderCount {

     static long normalLines = 0;
     static long commentLines = 0;
     static long whiteLines = 0;

     public static void main(String[] args) {
         File f = new File("D:\\share\\src");
         File[] codeFiles = f.listFiles();
         for(File child : codeFiles){
             if(child.getName().matches(".*\\.java$")) {
                 solve(child);
             }
         }

         System.out.println("normalLines:" + normalLines);
         System.out.println("commentLines:" + commentLines);
         System.out.println("whiteLines:" + whiteLines);

     }

     private static void solve(File f) {
         BufferedReader br = null;
         boolean comment = false;
         try {
             br = new BufferedReader(new FileReader(f));
             String line = "";
             while((line = br.readLine()) != null) {
                 /*
                  * //有的注釋行前面有一個tab
                  * 不可寫在readLine后
                  * 最后一行的話會空指針
                  */
                 line = line.trim();
                 //readLine讀出字符串后就把后面的換行去掉啦
                 if(line.matches("^[\\s&&[^\\n]]*$")) {
                     whiteLines ++;
                 } else if (line.startsWith("/*") && !line.endsWith("*/")) {
                     commentLines ++;
                     comment = true;    
                 } else if (line.startsWith("/*") && line.endsWith("*/")) {
                     commentLines ++;
                 } else if (true == comment) {
                     commentLines ++;
                     if(line.endsWith("*/")) {
                         comment = false;
                     }
                 } else if (line.startsWith("http://")) {
                     commentLines ++;
                 } else {
                     normalLines ++;
                 }
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if(br != null) {
                 try {
                     br.close();
                     br = null;
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }

 }

十三、Quantifiers
包括？*+；默認全是Greedy，還有Reluctant和Possessive(獨占性的)。

復制代碼代碼如下:

//加上分組是為了看得更清晰一些
     Pattern p = Pattern.compile("(.{3,10})+[0-9]");
     String s = "aaaa5bbbb6";//長度是10
     Matcher m = p.matcher(s);
     /*
      * 現(xiàn)在輸出0-10，默認是Greedy，先吞進10個字符，發(fā)現(xiàn)不匹配，吐出來一個，發(fā)現(xiàn)匹配了；
      * 若是Pattern.compile("(.{3,10}?)+[0-9]")則成了Reluctant，那么是先吞進三個字符,發(fā)現(xiàn)不匹配，繼續(xù)吞入 知道匹配，輸出0到5；
      * 若是Pattern.compile("(.{3,10}++)+[0-9]")則是Possessive（獨占式），也是先吞入10個字符，但是不向外吐，那么就不匹配了，
      * 這種方式主要用在需要高效率的地方（會有誤差）。
      */
     if(m.find()) {
         System.out.println(m.start() + "----" + m.end());
     }else {
         System.put.println("Not match!");
     }

十四、補充（非捕獲組）

復制代碼代碼如下:

//非捕獲組的意思和字面相反，意思是若是符合則捕獲
     Pattern p = Pattern.compile("(?=a).{3}");
     /*
      * 輸出a66，相當于要求以a開頭,也可以這么寫Pattern.compile("[a].{2}");
      * 若是Pattern.compile(".{3}(?!=a)")不是不以a結(jié)尾{2}[^a]，而是下一個字符不是a(lookahead)，輸出44a,66b,所以這種用法不常用；
      * 若是Pattern.compile(".{3}(?=a)")則輸出444(因為?=a是lookahead),放在前面則包含在組內(nèi)，后面則不包含在組內(nèi)；
      * 
      * 
      */
     String s = "444a66b";
     Matcher m = p.matcher(s);
     while(m.find()) {
         System.out.println(m.group());
     }

十五、Back Reference

復制代碼代碼如下:

Pattern p = Pattern.compile("(\\d\\d)\\1");
     /*
      * 輸出true，\\1表示和第一個組的一樣，若改成1213就不對了;
      * 若是Pattern.compile("(\\d(\\d))\\2")則需改成122才對
      * 
      */
     String s = "1212";
     Matcher m = p.matcher(s);
     System.out.println(m.matches());

十六、flags的簡寫
"."是不匹配換行的，記住CASE_INSENSITIVE就行了，簡寫“通過嵌入式標志表達式 (?i) 也可以啟用不區(qū)分大小寫的匹配”。

您可能感興趣的文章: