正規表示式在Java中的使用

炭燒生蠔發表於2019-04-18
Java

介紹

  • 正規表示式一般用於字串匹配, 字串查詢和字串替換. 別小看它的作用, 在工作學習中靈活運用正規表示式處理字串能夠大幅度提高效率, 程式設計的快樂來得就是這麼簡單.
  • 一下子給出一堆匹配的規則可能會讓人恐懼, 下面將由淺入深講解正規表示式的使用. 附帶實戰案例.

從簡單例子認識正規表示式匹配

  • 先上程式碼
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("liuyj24@126.com".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());
        }
    }
}
//輸出結果
2819531636@qq.com
2819531636@qq.com
2405059759@qq.com
2405059759@qq.com
1013376804@qq.com
...
複製程式碼

實戰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個字元, 然後判斷後一個是否是數字, 不管是否匹配成功它都不會繼續吞或者吐出一個字元.

結束

  • 願正規表示式給你帶來更愉快的程式設計體驗.

相關文章