JAVA學習筆記--正則表達式

　　正則表達式是一種強大而靈活的文本處理工具。使用正則表達式，可讓咱們以編程的方式構造複雜的文本，並對輸入的字符串進行搜索。

1、基礎正則表達式語法（表格來自J2SE6_API）

字符
x	字符 x
\\	反斜線字符
\0n	帶有八進制值 0 的字符 n (0 <= n <= 7)
\0nn	帶有八進制值 0 的字符 nn (0 <= n <= 7)
\0mnn	帶有八進制值 0 的字符 mnn（0 <= m <= 三、0 <= n <= 7）
\xhh	帶有十六進制值 0x 的字符 hh
\uhhhh	帶有十六進制值 0x 的字符 hhhh
\t	製表符 ('\u0009')
\n	新行（換行）符 ('\u000A')
\r	回車符 ('\u000D')
\f	換頁符 ('\u000C')
\a	報警 (bell) 符 ('\u0007')
\e	轉義符 ('\u001B')
\cx	對應於 x 的控制符
字符類
[abc]	包含a、b和c的任何字符
[^abc]	任何字符，除了 a、b 或 c（否認）
[a-zA-Z]	a 到 z 或 A 到 Z，兩頭的字母包括在內（範圍）
[a-d[m-p]]	a 到 d 或 m 到 p：[a-dm-p]（並集）
[a-z&&[def]]	d、e 或 f（交集）
[a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（減去）
[a-z&&[^m-p]]	a 到 z，而非 m 到 p：[a-lq-z]（減去）
預約義字符類
.	任何字符（與行結束符可能匹配也可能不匹配）
\d	數字：[0-9]
\D	非數字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	單詞字符：[a-zA-Z_0-9]
\W	非單詞字符：[^\w]
POSIX 字符類（僅 US-ASCII）
\p{Lower}	小寫字母字符：[a-z]
\p{Upper}	大寫字母字符：[A-Z]
\p{ASCII}	全部 ASCII：[\x00-\x7F]
\p{Alpha}	字母字符：[\p{Lower}\p{Upper}]
\p{Digit}	十進制數字：[0-9]
\p{Alnum}	字母數字字符：[\p{Alpha}\p{Digit}]
\p{Punct}	標點符號：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}	可見字符：[\p{Alnum}\p{Punct}]
\p{Print}	可打印字符：[\p{Graph}\x20]
\p{Blank}	空格或製表符：[ \t]
\p{Cntrl}	控制字符：[\x00-\x1F\x7F]
\p{XDigit}	十六進制數字：[0-9a-fA-F]
\p{Space}	空白字符：[ \t\n\x0B\f\r]
java.lang.Character 類（簡單的 java 字符類型）
\p{javaLowerCase}	等效於 java.lang.Character.isLowerCase()
\p{javaUpperCase}	等效於 java.lang.Character.isUpperCase()
\p{javaWhitespace}	等效於 java.lang.Character.isWhitespace()
\p{javaMirrored}	等效於 java.lang.Character.isMirrored()
Unicode 塊和類別的類
\p{InGreek}	Greek 塊（簡單塊）中的字符
\p{Lu}	大寫字母（簡單類別）
\p{Sc}	貨幣符號
\P{InGreek}	全部字符，Greek 塊中的除外（否認）
[\p{L}&&[^\p{Lu}]]	全部字母，大寫字母除外（減去）
邊界匹配器
^	行的開頭
$	行的結尾
\b	單詞邊界
\B	非單詞邊界
\A	輸入的開頭
\G	上一個匹配的結尾
\Z	輸入的結尾，僅用於最後的結束符（若是有的話）
\z	輸入的結尾
Greedy 數量詞
X?	X，一次或一次也沒有
X*	X，零次或屢次
X+	X，一次或屢次
X{n}	X，剛好 n 次
X{n,}	X，至少 n 次
X{n,m}	X，至少 n 次，可是不超過 m 次
Reluctant 數量詞
X??	X，一次或一次也沒有
X*?	X，零次或屢次
X+?	X，一次或屢次
X{n}?	X，剛好 n 次
X{n,}?	X，至少 n 次
X{n,m}?	X，至少 n 次，可是不超過 m 次
Possessive 數量詞
X?+	X，一次或一次也沒有
X*+	X，零次或屢次
X++	X，一次或屢次
X{n}+	X，剛好 n 次
X{n,}+	X，至少 n 次
X{n,m}+	X，至少 n 次，可是不超過 m 次
Logical 運算符
XY	X 後跟 Y
X|Y	X 或 Y
(X)	X，做爲捕獲組
Back 引用
\n	任何匹配的 nth 捕獲組
引用
\	Nothing，可是引用如下字符
\Q	Nothing，可是引用全部字符，直到 \E
\E	Nothing，可是結束從 \Q 開始的引用
特殊構造（非捕獲）
(?:X)	X，做爲非捕獲組
(?idmsux-idmsux)	Nothing，可是將匹配標誌i d m s u x on - off
(?idmsux-idmsux:X)	X，做爲帶有給定標誌 i d m s u x on - off
(?=X)	X，經過零寬度的正 lookahead
(?!X)	X，經過零寬度的負 lookahead
(?<=X)	X，經過零寬度的正 lookbehind
(?<!X)	X，經過零寬度的負 lookbehind
(?>X)	X，做爲獨立的非捕獲組

 

 

　　

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 　　　　　　

2、String類中經常使用的正則表達式工具

　一、String.matches()方法：匹配字符串

　　　　String.matches(regex);　　　　　　　　　　　　　　　　　　　　　//告知字符串是否匹配給定的正則表達式，返回boolean類型

　二、String.split()方法：拆分字符串

 　　　   String.split(regex);　　　　　　　　　　　　　　　　　　　　　　　// 根據匹配給定的正則表達式來拆分字符串

　三、String.replace()方法：替換字符串

　　　　String.replace(char oldChar,char newChar);　　　　　　　　　　　　// 用newChar替換oldChar，並返回newChar

　　　　String.replaceFirst(String regex,String replacement);　　　　　　　　// 使用給定的replacement替換此字符串中與給定正則表達式匹配的第一個子字符串

　　　　String.replaceAll(String regex,String replacement);　　　　　　　　　// 使用給定的replacement替換此字符串中與給定正則表達式匹配的全部子字符串

 如下是一個簡單的例子，用到上述三種工具：

package com.tongye.regular;

import java.util.Arrays;

public class RegularExpression {
    
    public static void main(String[] args){
        String s1 = "123456";
        String s2 = "What is your name? My name is tongye.";
        String s3 = "abc11ddd+123-456defdefdef";
        
        System.out.println(s1.matches("\\d*"));                    // 正則表達式"\\d*"表示0個或多個數字
        System.out.println(Arrays.toString(s2.split("\\W")));    // 用非單詞字符對字符串進行劃分
        System.out.println(s3.replace(s3, "newchar"));            // 用心的字符串替換舊的字符串並返回新字串
        System.out.println(s3.replaceFirst("\\w+", "ABC"));        
        System.out.println(s3.replaceFirst("(def)+", "DEF"));
        System.out.println(s3.replaceAll("\\d+", "XXX"));
    }    
}
/* * output：
true
[What, is, your, name, , My, name, is, tongye]
newchar
ABC+123-456defdefdef
abc11ddd+123-456DEF
abcXXXddd+XXX-XXXdefdefdef
* */

 

3、Pattern和Matcher

　　Pattern類是正則表達式的編譯表示形式，能夠用Pattern.compile(regex)來編譯正則表達式，從而生成一個Pattern對象；Matches類是執行匹配操做的引擎，Matches類有許多用於字符串匹配操做。Pattern和Matcher結合起來使用能夠使正則表達式的匹配操做變得更加簡單，功能也更強大。

一、Pattern：

方法摘要：

1）Pattern.compile(regex);　　　　　　　　　　// 編譯正則表達式regex,並將返回一個Pattern對象

2）Pattern.pattern();　　　　　　　　　　　　　// 返回編譯過的正則表達式

3）Pattern.split(CharSequence input);　　　　　 // 根據模式匹配拆分給定的輸入字串

4）Pattern.matcher(CharSequence input);　　　 // 建立匹配給定輸入和此模式的匹配器

代碼示例：

package com.tongye.regular;

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

public class ReguarExpression {
    
    public static void main(String[] args){
        Pattern p = Pattern.compile("(abc)+");　　　　　　　　// 編譯正則表達式"(abc)+"並返回一個Pattern對象
        System.out.println(p.pattern());　　　　　　　　　　　 // 返回編譯過的正則表達式 
        System.out.println(Arrays.toString(p.split("123abcabcabc123-abc456abc-fgh")));　　// 根據編譯過的正則表達式（p）來匹配拆分給定的輸入字符串
    }
}
/*
(abc)+
[123, 123-, 456, -fgh]
 * */

 

二、Matcher:

　　經過調用Pattern的matcher方法生成一個Matcher對象，Matcher有許多用於匹配操做的方法。

方法摘要：

1）Matcher.matches();　　　　　　　　// 嘗試將整個區域與模式進行匹配

2）Matcher.group();　　　　　　　　　 // 返回由之前匹配操做所匹配的輸入子序列

3）Matcher.find();　　　　　　　　　　 // 嘗試查找與該模式匹配的輸入序列的下一個子序列

4）Matcher.start();　　　　　　　　　　// 返回之前匹配的初始索引

5）Matcher.end();　　　　　　　　　　 // 返回最後匹配字符以後的偏移量

下面舉一個簡單的例子，將用到以上方法：

package com.tongye.regular;

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

public class ReguarExpression {
    
    public static void main(String[] args){
        Pattern p1 = Pattern.compile("abc");    
        Pattern p2 = Pattern.compile("\\w+-?\\w+");    
        Matcher m1 = p1.matcher("abc123abc-defabc456");
        Matcher m2 = p2.matcher("abc123abc-defabc456");
        System.out.println(m1.matches());        // 將整個區域與模式匹配，這裏匹配的是"abc"和"abc123abc-defabc456"
        System.out.println(m2.matches());
        while(m1.find()){
            System.out.println(m1.group() + " " + m1.start() + " " + (m1.end() - 1));
        }
    }
}
/*
false
true
abc 0 2
abc 6 8
abc 13 15
 * */