正則表達式一般用于字符串匹配, 字符串查找和字符串替換. 別小看它的作用, 在工作學習中靈活運用正則表達式處理字符串能夠大幅度提高效率, 編程的快樂來得就是這麽簡單。
一下子給出一堆匹配的規則可能會讓人恐懼, 下面將由淺入深講解正則表達式的使用。
從簡單例子認識正則表達式匹配
先上代碼
public class Demo1 { public static void main(String[] args) { //字符串abc匹配正則表達式”…”, 其中”.”表示一個字符 //”…”表示三個字符 System.out.println(“abc”.matches(“…”));
System.out.println(“abcd”.matches(“…”)); } } //輸出結果 true false
String類中有個matches(String regex)方法, 返回值爲布爾類型, 用于告訴這個字符串是否匹配給定的正則表達式。
在本例中我們給出的正則表達式爲…, 其中每個.表示一個字符, 整個正則表達式的意思是三個字符, 顯然當匹配abc的時候結果爲true, 匹配abcd時結果爲false。
Java中對正則表達式的支持(各種語言有相應的實現)
在java.util.regex包下有兩個用于正則表達式的類, 一個是Matcher類, 另一個Pattern。
Java官方文檔中給出對這兩個類的典型用法, 代碼如下:
public class Demo2 { public static void main(String[] args) { //[a-z]表示a~z之間的任何一個字符, {3}表示3個字符, 意思是匹配一個長度爲3, 並且每個字符屬于a~z的字符串 Pattern p = Pattern.compile(“[a-z]{3}”); Matcher m = p.matcher(“abc”); System.out.println(m.matches()); } } //輸出結果 true
如果要深究正則表達式背後的原理, 會涉及編譯原理中自動機等知識, 此處不展開描述. 爲了達到通俗易懂, 這裏用較爲形象的語言描述。
Pattern可以理解爲一個模式, 字符串需要與某種模式進行匹配. 比如Demo2中, 我們定義的模式是一個長度爲3的字符串, 其中每個字符必須是a~z中的一個。
我們看到創建Pattern對象時調用的是Pattern類中的compile方法, 也就是說對我們傳入的正則表達式編譯後得到一個模式對象. 而這個經過編譯後模式對象, 會使得正則表達式使用效率會大大提高, 並且作爲一個常量, 它可以安全地供多個線程並發使用。
Matcher可以理解爲模式匹配某個字符串後産生的結果. 字符串和某個模式匹配後可能會産生很多個結果, 這個會在後面的例子中講解。
最後當我們調用m.matches()時就會返回完整字符串與模式匹配的結果。
上面的三行代碼可以簡化爲一行代碼
System.out.println(“abc”.matches(“[a-z]{3}”));
但是如果一個正則表達式需要被重複匹配, 這種寫法效率較低。
初步認識 . + * ?
在介紹之前首先要說明的是, 正則表達式的具體含義不用強背, 各個符號的含義在Java官方文檔的Pattern類描述中或網上有詳細的定義. 當然能熟用就更好了。
public class Demo3 { /** * 爲了省略每次寫打印語句, 這裏把輸出語句封裝起來 * @param o */ private static void p(Object o){ System.out.println(o); }
/** * . Any character (may or may not match line terminators), 任意字符 * X? X, once or not at all 零個或一個 * X* X, zero or more times 零個或多個 * X+ X, one or more times 一個或多個 * X{n} X, exactly n times x出現n次 * X{n,} X, at least n times x出現至少n次 * X{n,m} X, at least n but not more than m times 出現n~m次 * @param args */ public static void main(String[] args) { p(“a”.matches(“.”)); p(“aa”.matches(“aa”)); p(“aaaa”.matches(“a*”)); p(“aaaa”.matches(“a+”)); p(“”.matches(“a*”)); p(“a”.matches(“a?”));
// \d A digit: [0-9], 表示數字, 但是在java中對”\”這個符號需要使用\進行轉義, 所以出現\d p(“2345”.matches(“\d{2,5}”)); // \.用于匹配”.” p(“192.168.0.123”.matches(“\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}”)); // [0-2]指必須是0~2中的一個數字 p(“192”.matches(“[0-2][0-9][0-9]”)); } } //輸出結果 //全爲true 範圍
[]用于描述一個字符的範圍, 下面是一些例子：
public class Demo4 { private static void p(Object o){ System.out.println(o); }
public static void main(String[] args) { //[abc]指abc中的其中一個字母 p(“a”.matches(“[abc]”)); //[^abc]指除了abc之外的字符 p(“1”.matches(“[^abc]”)); //a~z或A~Z的字符, 以下三個均是或的寫法 p(“A”.matches(“[a-zA-Z]”)); p(“A”.matches(“[a-z|A-Z]”)); p(“A”.matches(“[a-z[A-Z]]”)); //[A-Z&&[REQ]]指A~Z中並且屬于REQ其中之一的字符 p(“R”.matches(“[A-Z&&[REQ]]”)); } } //輸出結果 全部爲true 認識\s \w \d \
下面介紹數字和字母的正則表達, 這是編程中使用最多的字符了.
關于\
這裏重點介紹最不好理解的\. 在Java中的字符串中, 如果要用到特殊字符, 必須通過在前面加\進行轉義。
舉個例子, 考慮這個字符串”老師大聲說:”同學們,快交作業!””. 如果我們沒有轉義字符, 那麽開頭的雙引號的結束應該在說:”這裏, 但是我們的字符串中需要用到雙引號, 所以需要用轉義字符。
使用轉義字符後的字符串爲”老師大聲說:\”同學們,快交作業!\””, 這樣我們的原意才能被正確識別。
同理如果我們要在字符串中使用\, 也應該在前面加一個\, 所以在字符串中表示爲”\\”。
那麽如何在正則表達式中表示要匹配\呢, 答案爲”\\\\”。
我們分開考慮: 由于正則式中表示\同樣需要轉義, 所以前面的\\表示正則表達式中的轉義字符\, 後面的\\表示正則表達式中\本身, 合起來在正則表達式中表示\.
如果感覺有點繞的話請看下面代碼：
public class Demo5 { private static void p(Object o){ System.out.println(o); }
public static void main(String[] args) { /** * \d A digit: [0-9] 數字 * \D A non-digit: [^0-9] 非數字 * \s A whitespace character: [ \t\n\x0B\f\r] 空格 * \S A non-whitespace character: [^\s] 非空格 * \w A word character: [a-zA-Z_0-9] 數字字母和下劃線 * \W A non-word character: [^\w] 非數字字母和下劃線 */ // \s{4}表示4個空白符 p(” \n\r\t”.matches(“\s{4}”)); // \S表示非空白符 p(“a”.matches(“\S”)); // \w{3}表示數字字母和下劃線 p(“a_8”.matches(“\w{3}”)); p(“abc888&^%”.matches(“[a-z]{1,3}\d+[%^&*]+”)); // 匹配 \ p(“\”.matches(“\\”)); } } //輸出結果 全部爲true 邊界處理
^在中括號內表示取反的意思[^], 如果不在中括號裏則表示字符串的開頭
public class Demo6 { private static void p(Object o){ System.out.println(o); }
public static void main(String[] args) { /** * ^ The beginning of a line 一個字符串的開始 * $ The end of a line 字符串的結束 * \b A word boundary 一個單詞的邊界, 可以是空格, 換行符等 */ p(“hello sir”.matches(“^h.*”)); p(“hello sir”.matches(“.*r$”)); p(“hello sir”.matches(“^h[a-z]{1,3}o\b.*”)); p(“hellosir”.matches(“^h[a-z]{1,3}o\b.*”)); } }
練習:匹配空白行合email地址
拿到一篇文章, 如何判斷裏面有多少個空白行? 用正則表達式能方便地進行匹配, 注意空白行中可能包括空格, 制表符等。
p(” \n”.matches(“^[\s&&[^\n]]*\n$”));
解釋: ^[\\s&&[^\n]]*是空格符號但不是換行符, \\n$最後以換行符結束
下面是匹配郵箱：
p(“[email protected]”.matches(“[\w[.-]]+@[\w[.-]]+\.[\w]+”));
解釋: [\\w[.-]]+以一個或多個數字字母下劃線.或-組成, @接著是個@符號, 然後同樣是[\\w[.-]]+, 接著\\.匹配., 最後同樣是[\\w]+
Matcher類的matches(),find()和lookingAt()
matches()方法會將整個字符串與模板進行匹配.
find()則是從當前位置開始進行匹配, 如果傳入字符串後首先進行find(), 那麽當前位置就是字符串的開頭, 對當前位置的具體分析可以看下面的代碼示例
lookingAt()方法會從字符串的開頭進行匹配.
public class Demo8 { private static void p(Object o){ System.out.println(o); }
public static void main(String[] args) { Pattern pattern = Pattern.compile(“\d{3,5}”); String s = “123-34345-234-00”; Matcher m = pattern.matcher(s);
//先演示matches(), 與整個字符串匹配. p(m.matches()); //結果爲false, 顯然要匹配3~5個數字會在-處匹配失敗
//然後演示find(), 先使用reset()方法把當前位置設置爲字符串的開頭 m.reset(); p(m.find());//true 匹配123成功 p(m.find());//true 匹配34345成功 p(m.find());//true 匹配234成功 p(m.find());//false 匹配00失敗
//下面我們演示不在matches()使用reset(), 看看當前位置的變化 m.reset();//先重置 p(m.matches());//false 匹配整個字符串失敗, 當前位置來到- p(m.find());// true 匹配34345成功 p(m.find());// true 匹配234成功 p(m.find());// false 匹配00始邊 p(m.find());// false 沒有東西匹配, 失敗
//演示lookingAt(), 從頭開始找 p(m.lookingAt());//true 找到123, 成功 } } Matcher類中的start()和end()
如果一次匹配成功的話start()用于返回匹配開始的位置, end()用于返回匹配結束字符的後面一個位置
public class Demo9 { private static void p(Object o){ System.out.println(o); }
public static void main(String[] args) { Pattern pattern = Pattern.compile(“\d{3,5}”); String s = “123-34345-234-00”; Matcher m = pattern.matcher(s);
p(m.find());//true 匹配123成功 p(“start: ” + m.start() + ” – end:” + m.end()); p(m.find());//true 匹配34345成功 p(“start: ” + m.start() + ” – end:” + m.end()); p(m.find());//true 匹配234成功 p(“start: ” + m.start() + ” – end:” + m.end()); p(m.find());//false 匹配00失敗 try { p(“start: ” + m.start() + ” – end:” + m.end()); }catch (Exception e){ System.out.println(“報錯了…”); } p(m.lookingAt()); p(“start: ” + m.start() + ” – end:” + m.end()); } } //輸出結果 true start: 0 – end:3 true start: 4 – end:9 true start: 10 – end:13 false 報錯了… true start: 0 – end:3 替換字符串
想要替換字符串首先要找到被替換的字符串, 這裏要新介紹Matcher類中的一個方法group(), 它能返回匹配到的字符串.
下面我們看一個例子, 把字符串中的java轉換爲大寫.
public class Demo10 { private static void p(Object o){ System.out.println(o); }
public static void main(String[] args) { Pattern p = Pattern.compile(“java”); Matcher m = p.matcher(“java Java JAVA JAva I love Java and you”); p(m.replaceAll(“JAVA”));//replaceAll()方法會替換所有匹配到的字符串 } } //輸出結果 JAVA Java JAVA JAva I love Java and you
升級: 不區分大小寫查找並替換字符串
爲了在匹配的時候不區分大小寫, 我們要在創建模板模板時指定大小寫不敏感
public static void main(String[] args) { Pattern p = Pattern.compile(“java”, Pattern.CASE_INSENSITIVE);//指定爲大小寫不敏感的 Matcher m = p.matcher(“java Java JAVA JAva I love Java and you”); p(m.replaceAll(“JAVA”)); } //輸出結果 JAVA JAVA JAVA JAVA I love JAVA and you
再升級: 不區分大小寫, 替換查找到的指定字符串
這裏演示把查找到第奇數個字符串轉換爲大寫, 第偶數個轉換爲小寫
這裏會引入Matcher類中一個強大的方法appendReplacement(StringBuffer sb, String replacement), 它需要傳入一個StringBuffer進行字符串拼接.
public static void main(String[] args) { Pattern p = Pattern.compile(“java”, Pattern.CASE_INSENSITIVE); Matcher m = p.matcher(“java Java JAVA JAva I love Java and you ?”); StringBuffer sb = new StringBuffer(); int index = 1; while(m.find()){ //m.appendReplacement(sb, (index++ & 1) == 0 ? “java” : “JAVA”); 較爲簡潔的寫法 if((index & 1) == 0){//偶數 m.appendReplacement(sb, “java”); }else{ m.appendReplacement(sb, “JAVA”); } index++; } m.appendTail(sb);//把剩余的字符串加入 p(sb); } //輸出結果 JAVA java JAVA java I love JAVA and you ? 分組
先從一個問題引入, 看下面這段代碼
public static void main(String[] args) { Pattern p = Pattern.compile(“\d{3,5}[a-z]{2}”); String s = “123aa-5423zx-642oi-00”; Matcher m = p.matcher(s); while(m.find()){ p(m.group()); } } //輸出結果 123aa 5423zx 642oi
其中正則表達式”\\d{3,5}[a-z]{2}”表示3~5個數字跟上兩個字母, 然後打印出每個匹配到的字符串
如果想要打印每個匹配串中的數字, 如何操作呢.
首先你可能想到把匹配到的字符串再進行匹配, 但是這樣太麻煩了, 分組機制可以幫助我們在正則表達式中進行分組.
規定使用()進行分組, 這裏我們把字母和數字各分爲一組”(\\d{3,5})([a-z]{2})”
然後在調用m.group(int group)方法時傳入組號即可
注意, 組號從0開始, 0組代表整個正則表達式, 從0之後, 就是在正則表達式中從左到右每一個左括號對應一個組. 在這個表達式中第1組是數字, 第2組是字母.
public static void main(String[] args) { Pattern p = Pattern.compile(“(\d{3,5})([a-z]{2})”);//正則表達式爲3~5個數字跟上兩個字母 String s = “123aa-5423zx-642oi-00”; Matcher m = p.matcher(s); while(m.find()){ p(m.group(1)); } } //輸出結果 123 5423 642 實戰1: 抓取網頁中的email地址(爬蟲)
假設我們手頭上有一些優質的資源, 打算分享給網友, 于是便到貼吧上發出一個留郵箱發資源的帖子. 沒想到網友熱情高漲, 留下了近百個郵箱. 但逐個複制發送太累了, 我們考慮用程序實現.
這裏不展開講發郵件部分, 重點應用已經學到的正則表達式從網頁中截取所有的郵箱地址.
首先獲取一個帖子的html代碼隨便找了一個, 點擊跳轉, 在浏覽器中點擊右鍵保存html文件
接下來看代碼:
public class Demo12 { public static void main(String[] args) { BufferedReader br = null; try { br = new BufferedReader(new FileReader(“C:\emailTest.html”)); String line = “”; while((line = br.readLine()) != null){//讀取文件的每一行 parse(line);//解析其中的email地址 } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally { if(br != null){ try { br.close(); br = null; } catch (IOException e) { e.printStackTrace(); } } } }
private static void parse(String line){ Pattern p = Pattern.compile(“[\w[.-]]+@[\w[.-]]+\.[\w]+”); Matcher m = p.matcher(line); while(m.find()){ System.out.println(m.group()); } } } //輸出結果 [email protected] [email protected] [email protected] [email protected] [email protected] … 實戰2: 代碼統計小程序
最後的一個實戰案例: 統計一個項目中一共有多少行代碼, 多少行注釋, 多少個空白行. 不妨對自己做過的項目進行統計, 發現不知不覺中也是個寫過成千上萬行代碼的人了…
我在github上挑選了一個項目, 是純java寫的小項目, 方便統計. 點擊跳轉
下面是具體的代碼, 除了判斷空行用了正則表達式外, 判斷代碼行和注釋行用了String類的api
public class Demo13 { private static long codeLines = 0; private static long commentLines = 0; private static long whiteLines = 0; private static String filePath = “C:\TankOnline”;
public static void main(String[] args) { process(filePath); System.out.println(“codeLines : ” + codeLines); System.out.println(“commentLines : ” + commentLines); System.out.println(“whiteLines : ” + whiteLines); }
/** * 遞歸查找文件 * @param pathStr */ public static void process(String pathStr){ File file = new File(pathStr); if(file.isDirectory()){//是文件夾則遞歸查找 File[] fileList = file.listFiles(); for(File f : fileList){ String fPath = f.getAbsolutePath(); process(fPath); } }else if(file.isFile()){//是文件則判斷是否是.java文件 if(file.getName().matches(“.*\.java$”)){ parse(file); } } }
private static void parse(File file) { BufferedReader br = null; try { br = new BufferedReader(new FileReader(file)); String line = “”; while((line = br.readLine()) != null){ line = line.trim();//清空每行首尾的空格 if(line.matches(“^[\s&&[^\n]]*$”)){//注意不是以\n結尾, 因爲在br.readLine()會去掉\n whiteLines++; }else if(line.startsWith(“/*”) || line.startsWith(“*”) || line.endsWith(“*/”)){ commentLines++; }else if(line.startsWith(“//”) || line.contains(“//”)){ commentLines++; }else{ if(line.startsWith(“import”) || line.startsWith(“package”)){//導包不算 continue; } codeLines++; } } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { if(null != br){ try { br.close(); br = null; } catch (IOException e) { e.printStackTrace(); } } } } } //輸出結果 codeLines : 1139 commentLines : 124 whiteLines : 172 貪婪模式與非貪婪模式
經過兩個實戰後, 相信大家已經掌握了正則表達式的基本使用了, 下面介紹貪婪模式與非貪婪模式.
通過查看官方api我們發現Pattern類中有如下定義:
Greedy quantifiers 貪婪模式 X? X, once or not at all X* X, zero or more times X+ X, one or more times X{n} X, exactly n times X{n,} X, at least n times X{n,m} X, at least n but not more than m times Reluctant quantifiers 非貪婪模式(勉強的, 不情願的) X?? X, once or not at all X*? X, zero or more times X+? X, one or more times X{n}? X, exactly n times X{n,}? X, at least n times X{n,m}? X, at least n but not more than m times Possessive quantifiers 獨占模式 X?+ X, once or not at all X*+ X, zero or more times X++ X, one or more times X{n}+ X, exactly n times X{n,}+ X, at least n times X{n,m}+ X, at least n but not more than m times
這三種模式表達的意思是一樣的, 在前面的講解中我們全部使用的是貪婪模式. 那麽其他兩種模式的寫法有什麽區別呢? 通過下面的代碼示例進行講解.
public static void main(String[] args) { Pattern p = Pattern.compile(“.{3,10}[0-9]”); String s = “aaaa5bbbb6″;//10個字符 Matcher m = p.matcher(s); if(m.find()){ System.out.println(m.start() + ” – ” + m.end()); }else { System.out.println(“not match!”); } } //輸出結果 0 – 10
正則表達式的意思是3~10個字符加一個數字. 在貪婪模式下匹配時, 系統會先吞掉10個字符, 這時檢查最後一個是否時數字, 發現已經沒有字符了, 于是吐出來一個字符, 再次匹配數字, 匹配成功, 得到0-10.
下面是非貪婪模式演示(勉強的, 不情願的)
public static void main(String[] args) { Pattern p = Pattern.compile(“.{3,10}?[0-9]”);//添加了一個? String s = “aaaa5bbbb6″; Matcher m = p.matcher(s); if(m.find()){ System.out.println(m.start() + ” – ” + m.end()); }else { System.out.println(“not match!”); } } //輸出結果 0 – 5
在非貪婪模式下, 首先只會吞掉3個(最少3個), 然後判斷後面一個是否是數字, 結果不是, 在往後吞一個字符, 繼續判斷後面的是否數字, 結果是, 輸出0-5
最後演示獨占模式, 通常只在追求效率的情況下這麽做, 用得比較少
public static void main(String[] args) { Pattern p = Pattern.compile(“.{3,10}+[0-9]”);//多了個+ String s = “aaaa5bbbb6″; Matcher m = p.matcher(s); if(m.find()){ System.out.println(m.start() + ” – ” + m.end()); }else { System.out.println(“not match!”); } } //輸出結果 not match!
獨占模式會一下吞進10個字符, 然後判斷後一個是否是數字, 不管是否匹配成功它都不會繼續吞或者吐出一個字符.
結束
願正則表達式給你帶來更愉快的編程體驗.