前言
一節正則表達式的學習記錄,大部分內容來自網上和稍微看了點api文檔
基本說明
- Pattern 類
pattern 對象是一個正則表達式的編譯表示。Pattern 類沒有公共構造方法。要創建一個 Pattern 對象,你必須首先調用其公共靜態編譯方法,它返回一個 Pattern 對象。該方法接受一個正則表達式作爲它的第一個參數。
- Matcher 類
Matcher 對象是對輸入字符串進行解釋和匹配操作的引擎。與Pattern 類一樣,Matcher 也沒有公共構造方法。你需要調用 Pattern 對象的 matcher 方法來獲得一個 Matcher 對象。
基本使用
Pattern pattern()
Pattern p = Pattern.compile("\\w+");
//p.pattern() 返回正則表達式的字符串形式
print("-> " + p.pattern());
結果如下
E/-s-: -> \w+
Pattern split(String)
p = Pattern.compile("\\d+");
//按數字將字符串拆分
String[] strs = p.split("電話:123QQ:789郵箱:[email protected]");
for (String str : strs) {
print(str);
}
結果如下
E/-s-: 電話:
E/-s-: --------------------------------
E/-s-: QQ:
E/-s-: --------------------------------
E/-s-: 郵箱:[email protected]
E/-s-: --------------------------------
Pattern matches(String, String)
//判斷字符串是否全是數字
print("-> " + Pattern.matches("\\d+", "2333"));
print("-> " + Pattern.matches("\\d+", "23aa33"));
print("-> " + Pattern.matches("\\d+", "2b333b"));
結果如下
E/-s-: -> true
E/-s-: --------------------------------
E/-s-: -> false
E/-s-: --------------------------------
E/-s-: -> false
E/-s-: --------------------------------
Pattern matches()
//判斷字符串是否全是數字
p = Pattern.compile("\\d+");
m = p.matcher("2333a3b3");
print("-> " + m.matches());
m = p.matcher("2333");
print("-> " + m.matches());
結果如下
E/-s-: -> false
E/-s-: --------------------------------
E/-s-: -> true
E/-s-: --------------------------------
注:按照上面 matches(String, String)和matches()可以知道
Pattern.matches("\d+", “2333”)
等價於
Pattern.compile("\d+").matcher(“2333”).matches()
Matcher pattern()
p = Pattern.compile("\\d+");
Matcher m = p.matcher("2333a3b3");
//m.pattern() 返回的就是對象p
print("-> " + m.pattern().pattern());
結果如下
E/-s-: -> \d+
Matcher lookingAt()
//判斷是否數字開頭
p = Pattern.compile("\\d+");
m = p.matcher("22bb23");
print("-> " + m.lookingAt());
m = p.matcher("aa2223");
print("-> " + m.lookingAt());
結果
E/-s-: -> true
E/-s-: --------------------------------
E/-s-: -> false
E/-s-: --------------------------------
Matcher find()
//判斷是否有數字
p = Pattern.compile("\\d+");
m = p.matcher("22bb23");
print("-> " + m.find());
m = p.matcher("aa2223");
print("-> " + m.find());
m = p.matcher("aa2223bb");
print("-> " + m.find());
m = p.matcher("aabb");
print("-> " + m.find());
結果
E/-s-: -> true
E/-s-: --------------------------------
E/-s-: -> true
E/-s-: --------------------------------
E/-s-: -> true
E/-s-: --------------------------------
E/-s-: -> false
E/-s-: --------------------------------
Matcher start() end() group()
//多次判斷結果
p = Pattern.compile("\\d+");
m = p.matcher("aaa2223bb");
print("-> " + m.find()); //判斷是否有數字
print("-> " + m.start()); //第一次碰到數字的位置 3
print("-> " + m.end()); //start之後連接的多個數字的最後一個數字後一位的位置 7
print("-> " + m.group()); //把start碰到的那段數字全部取出來
m = p.matcher("aa23a33b3b");
print("-> " + m.find());
print("-> " + m.start());
print("-> " + m.end());
print("-> " + m.group());
結果
E/-s-: -> true
E/-s-: --------------------------------
E/-s-: -> 3
E/-s-: --------------------------------
E/-s-: -> 7
E/-s-: --------------------------------
E/-s-: -> 2223
E/-s-: --------------------------------
E/-s-: -> true
E/-s-: --------------------------------
E/-s-: -> 2
E/-s-: --------------------------------
E/-s-: -> 4
E/-s-: --------------------------------
E/-s-: -> 23
E/-s-: --------------------------------
Matcher start(int) end(int) group(int)
//尋找小寫字母+數字的組合
p = Pattern.compile("([a-z]+)(\\d+)");
m = p.matcher("aaa2223bb");
print("-> " + m.find()); //aaa2223符合
print("-> " + m.groupCount()); //分段的多個數字數組
for (int i = 0; i < m.groupCount() + 1; i++) {
print("start-> " + m.start(i));
print("end-> " + m.end(i));
print("group-> " + m.group(i));
}
/**
* 0
* start找到 aaa2223 的第一個開頭 = 0
* end找到 aaa2223 的結尾+1 = 7
* group就是找到的 aaa2223
* 1
* start找到 aaa 的第一個開頭 = 0
* end找到 aaa 的結尾+1 = 3
* group就是找到的 aaa
* 2
* start找到 2223 的第一個開頭 = 3
* end找到 2223 的結尾+1 = 7
* group就是找到的 2223
*/
結果
E/-s-: -> true
E/-s-: --------------------------------
E/-s-: -> 2
E/-s-: --------------------------------
E/-s-: start-> 0
E/-s-: --------------------------------
E/-s-: end-> 7
E/-s-: --------------------------------
E/-s-: group-> aaa2223
E/-s-: --------------------------------
E/-s-: start-> 0
E/-s-: --------------------------------
E/-s-: end-> 3
E/-s-: --------------------------------
E/-s-: group-> aaa
E/-s-: --------------------------------
E/-s-: start-> 3
E/-s-: --------------------------------
E/-s-: end-> 7
E/-s-: --------------------------------
E/-s-: group-> 2223
E/-s-: --------------------------------
Matcher find() start() end() group()補充說明
我們可以直接點開源碼發現所有的以上方法就是調用的默認的 start(0)
end(0)
group(0)
,而且find調用之後會對已有的字符串進行分塊,我們做如下實驗
//當多次調用find start end group的時候
//會去除已經被檢索過的部位
p = Pattern.compile("\\d+");
m = p.matcher("我的電話:1354111111,我的QQ:777777777,我的郵箱:[email protected]");
while (m.find()){
print(m.group());
}
結果
E/-s-: 1354111111
E/-s-: --------------------------------
E/-s-: 777777777
E/-s-: --------------------------------
E/-s-: 777777777
E/-s-: --------------------------------
至此大概都瞭解了大部分的正則表達式方法的簡單使用。我們之後要看以下表格進行自己編寫正則表達式
正則表達式語法
字符 | 說明 |
---|---|
\ |
將下一字符標記爲特殊字符、文本、反向引用或八進制轉義符。例如,“n"匹配字符"n”。"\n"匹配換行符。序列"\\“匹配”\","\(“匹配”("。 |
^ |
匹配輸入字符串開始的位置。如果設置了 RegExp 對象的 Multiline 屬性,^ 還會與"\n"或"\r"之後的位置匹配。 |
$ |
匹配輸入字符串結尾的位置。如果設置了 RegExp 對象的 Multiline 屬性,$ 還會與"\n"或"\r"之前的位置匹配。 |
* |
零次或多次匹配前面的字符或子表達式。例如,zo* 匹配"z"和"zoo"。* 等效於 {0,}。 |
+ |
一次或多次匹配前面的字符或子表達式。例如,"zo+"與"zo"和"zoo"匹配,但與"z"不匹配。+ 等效於 {1,}。 |
? |
零次或一次匹配前面的字符或子表達式。例如,"do(es)?“匹配"do"或"does"中的"do”。? 等效於 {0,1}。 |
{n} |
n 是非負整數。正好匹配 n 次。例如,"o{2}"與"Bob"中的"o"不匹配,但與"food"中的兩個"o"匹配。 |
{n,} |
n 是非負整數。至少匹配 n 次。例如,"o{2,}“不匹配"Bob"中的"o”,而匹配"foooood"中的所有 o。"o{1,}“等效於"o+”。"o{0,}“等效於"o*”。 |
{n,m} |
m 和 n 是非負整數,其中 n <= m。匹配至少 n 次,至多 m 次。例如,"o{1,3}"匹配"fooooood"中的頭三個 o。‘o{0,1}’ 等效於 ‘o?’。注意:您不能將空格插入逗號和數字之間。 |
? |
當此字符緊隨任何其他限定符(*、+、?、{n}、{n,}、{n,m})之後時,匹配模式是"非貪心的"。"非貪心的"模式匹配搜索到的、儘可能短的字符串,而默認的"貪心的"模式匹配搜索到的、儘可能長的字符串。例如,在字符串"oooo"中,"o+?“只匹配單個"o”,而"o+“匹配所有"o”。 |
. |
匹配除"\r\n"之外的任何單個字符。若要匹配包括"\r\n"在內的任意字符,請使用諸如"[\s\S]"之類的模式。 |
(pattern) |
匹配 pattern 並捕獲該匹配的子表達式。可以使用 $0…$9 屬性從結果"匹配"集合中檢索捕獲的匹配。若要匹配括號字符 ( ),請使用"(“或者”)"。 |
(?:pattern) |
匹配 pattern 但不捕獲該匹配的子表達式,即它是一個非捕獲匹配,不存儲供以後使用的匹配。這對於用"or"字符 ( |
(?=pattern) |
執行正向預測先行搜索的子表達式,該表達式匹配處於匹配 pattern 的字符串的起始點的字符串。它是一個非捕獲匹配,即不能捕獲供以後使用的匹配。例如,'Windows (?=95 |
(?!pattern) |
執行反向預測先行搜索的子表達式,該表達式匹配不處於匹配 pattern 的字符串的起始點的搜索字符串。它是一個非捕獲匹配,即不能捕獲供以後使用的匹配。例如,'Windows (?!95 |
x|y |
匹配 x 或 y。例如,'z |
[xyz] |
字符集。匹配包含的任一字符。例如,"[abc]“匹配"plain"中的"a”。 |
[^xyz] |
反向字符集。匹配未包含的任何字符。例如,"[^abc]“匹配"plain"中"p”,“l”,“i”,“n”。 |
[a-z] |
字符範圍。匹配指定範圍內的任何字符。例如,"[a-z]"匹配"a"到"z"範圍內的任何小寫字母。 |
[^a-z] |
反向範圍字符。匹配不在指定的範圍內的任何字符。例如,"[^a-z]"匹配任何不在"a"到"z"範圍內的任何字符。 |
\b |
匹配一個字邊界,即字與空格間的位置。例如,“er\b"匹配"never"中的"er”,但不匹配"verb"中的"er"。 |
\B |
非字邊界匹配。“er\B"匹配"verb"中的"er”,但不匹配"never"中的"er"。 |
\cx |
匹配 x 指示的控制字符。例如,\cM 匹配 Control-M 或回車符。x 的值必須在 A-Z 或 a-z 之間。如果不是這樣,則假定 c 就是"c"字符本身。 |
\d |
數字字符匹配。等效於 [0-9]。 |
\D |
非數字字符匹配。等效於 [^0-9]。 |
\f |
換頁符匹配。等效於 \x0c 和 \cL。 |
\n |
換行符匹配。等效於 \x0a 和 \cJ。 |
\r |
匹配一個回車符。等效於 \x0d 和 \cM。 |
\s |
匹配任何空白字符,包括空格、製表符、換頁符等。與 [ \f\n\r\t\v] 等效。 |
\S |
匹配任何非空白字符。與 [^ \f\n\r\t\v] 等效。 |
\t |
製表符匹配。與 \x09 和 \cI 等效。 |
\v |
垂直製表符匹配。與 \x0b 和 \cK 等效。 |
\w |
匹配任何字類字符,包括下劃線。與"[A-Za-z0-9_]"等效。 |
\W |
與任何非單詞字符匹配。與"[^A-Za-z0-9_]"等效。 |
\xn |
匹配 n,此處的 n 是一個十六進制轉義碼。十六進制轉義碼必須正好是兩位數長。例如,"\x41"匹配"A"。"\x041"與"\x04"&"1"等效。允許在正則表達式中使用 ASCII 代碼。 |
\num |
匹配 num,此處的 num 是一個正整數。到捕獲匹配的反向引用。例如,"(.)\1"匹配兩個連續的相同字符。 |
\n |
標識一個八進制轉義碼或反向引用。如果 \n 前面至少有 n 個捕獲子表達式,那麼 n 是反向引用。否則,如果 n 是八進制數 (0-7),那麼 n 是八進制轉義碼。 |
\nm |
標識一個八進制轉義碼或反向引用。如果 \nm 前面至少有 nm 個捕獲子表達式,那麼 nm 是反向引用。如果 \nm 前面至少有 n 個捕獲,則 n 是反向引用,後面跟有字符 m。如果兩種前面的情況都不存在,則 \nm 匹配八進制值 nm,其中 n 和 m 是八進制數字 (0-7)。 |
\nml |
當 n 是八進制數 (0-3),m 和 l 是八進制數 (0-7) 時,匹配八進制轉義碼 nml。 |
\un |
匹配 n,其中 n 是以四位十六進制數表示的 Unicode 字符。例如,\u00A9 匹配版權符號 (©)。 |
字符串多段說明格子填充用請無視這格 |
根據 Java Language Specification 的要求,Java 源代碼的字符串中的反斜線被解釋爲 Unicode 轉義或其他字符轉義。因此必須在字符串字面值中使用兩個反斜線,表示正則表達式受到保護,不被 Java 字節碼編譯器解釋。例如,當解釋爲正則表達式時,字符串字面值 “\b” 與單個退格字符匹配,而 “\b” 與單詞邊界匹配。字符串字面值 “(hello)” 是非法的,將導致編譯時錯誤;要與字符串 (hello) 匹配,必須使用字符串字面值 “\(hello\)”。
進階使用
我們拿檢索一段字符串獲取裏面的手機號碼爲例
String phone = "xxx電話:0177-1234567\n" +
"xxx手機:17712345678\n" +
"緊急電話:(0544) 4331234\n" +
"備註:(0741) - 1288562";
List<String> phones = new ArrayList<>();
String regex1 = "\\d{4}\\s?-\\s?\\d{7,9}";
String regex2 = "[\\(|(]\\d{4}[)|\\)]\\s*-?\\s*\\d{7,9}";
p = Pattern.compile(regex1);
m = p.matcher(phone);
while (m.find()){
phones.add(m.group());
}
p = Pattern.compile(regex2);
m = p.matcher(phone);
while (m.find()){
phones.add(m.group());
}
for (String s : phones) {
print(s);
}
結果
E/-s-: 0177-1234567
E/-s-: --------------------------------
E/-s-: (0544) 4331234
E/-s-: --------------------------------
E/-s-: (0741) - 1288562
E/-s-: --------------------------------
我們來看下regex1 和regex2
regex1\\d{4}\\s?-\\s?\\d{7,9}
可以看出來是需要獲取一個0000-0000000
這樣的字符串
regex2[\\(|(]\\d{4}[)|\\)]\\s*-?\\s*\\d{7,9}
可以看出來是需要獲取一個(0000) 0000000
、(0000)- 0000000
、(0000)- 0000000
、(0000) 0000000
這四種類型
開始我寫了一個是"[\\(|(]?\\d{4}[)|\\)]?\\s*-?\\s*\\d+"
實際效果其實包含了\\d{11,12}
導致我獲取的號碼也有手機號和我只想要獲取電話號碼有衝突,我就改成了判斷2種。
當然這只是一個例子,實現使用的時候可以先對用戶輸入的格式要有需求,然後在用正則表達式進行獲取才比較方便