Java正則表達(dá)式API指南
1. 概述
在本教程中，我們將討論 Java 正則表達(dá)式 API，以及如何在 Java 編程語(yǔ)言中使用正則表達(dá)式。
在正則表達(dá)式的世界中，有許多不同的風(fēng)格可供選擇，例如 grep、Perl、Python、PHP、awk 等等。
這意味著在一種編程語(yǔ)言中可以工作的正則表達(dá)式，可能在另一種語(yǔ)言中無法工作。Java 中的正則表達(dá)式語(yǔ)法與 Perl 中的語(yǔ)法最為相似。
2. 設(shè)置
在 Java 中使用正則表達(dá)式，我們不需要任何特殊設(shè)置。JDK 包含了一個(gè)專門用于正則表達(dá)式操作的包，java.util.regex，只需在代碼中導(dǎo)入即可。
此外，java.lang.String 類也內(nèi)置了正則表達(dá)式的支持，通常在我們的代碼中使用。
3. Java 正則表達(dá)式包
java.util.regex 包由三個(gè)類組成：Pattern、Matcher 和 PatternSyntaxException：
Pattern對(duì)象是已編譯的正則表達(dá)式。Pattern類沒有公共構(gòu)造函數(shù)。要?jiǎng)?chuàng)建模式，首先必須調(diào)用其公共靜態(tài)方法compile，該方法返回一個(gè)Pattern對(duì)象。這些方法接受正則表達(dá)式作為第一個(gè)參數(shù)。Matcher對(duì)象解釋模式，并針對(duì)輸入字符串執(zhí)行匹配操作。它也沒有公共構(gòu)造函數(shù)。我們通過在Pattern對(duì)象上調(diào)用matcher方法來獲取Matcher對(duì)象，并傳遞我們想要匹配的文本。PatternSyntaxException對(duì)象是未檢查的異常，表示正則表達(dá)式模式中的語(yǔ)法錯(cuò)誤。
我們將詳細(xì)探討這些類，但首先必須了解如何在 Java 中構(gòu)造正則表達(dá)式。
如果我們已經(jīng)熟悉了其他環(huán)境中的正則表達(dá)式，可能會(huì)發(fā)現(xiàn)一些差異，但它們非常小。
4. 簡(jiǎn)單示例
讓我們從最簡(jiǎn)單的正則表達(dá)式使用案例開始。如前所述，當(dāng)我們將正則表達(dá)式應(yīng)用于字符串時(shí)，它可能會(huì)匹配零次或多次。
最基本的模式匹配形式是對(duì)字符串字面的匹配。例如，如果正則表達(dá)式是 foo 且輸入字符串是 foo，匹配將成功，因?yàn)閮蓚€(gè)字符串是相同的：
@Test
public void givenText_whenSimpleRegexMatches_thenCorrect() {
Pattern pattern = Pattern.compile("foo");
Matcher matcher = pattern.matcher("foo");
assertTrue(matcher.find());
}
我們首先通過調(diào)用其靜態(tài)方法 compile 并傳遞要使用的模式，來創(chuàng)建一個(gè) Pattern 對(duì)象。
然后我們通過調(diào)用 Pattern 對(duì)象的 matcher 方法并傳遞要檢查匹配的文本來創(chuàng)建一個(gè) Matcher 對(duì)象。
最后，我們調(diào)用 Matcher 對(duì)象中的 find 方法。
find 方法在輸入文本中逐步前進(jìn)并為每次匹配返回 true，因此我們可以使用它來計(jì)算匹配的次數(shù)：
@Test
public void givenText_whenSimpleRegexMatchesTwice_thenCorrect() {
Pattern pattern = Pattern.compile("foo");
Matcher matcher = pattern.matcher("foofoo");
int matches = 0;
while (matcher.find()) {
matches++;
}
assertEquals(matches, 2);
}
由于我們將運(yùn)行更多測(cè)試，可以將找到匹配次數(shù)的邏輯抽象為一個(gè)名為 runTest 的方法：
public static int runTest(String regex, String text) {
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(text);
int matches = 0;
while (matcher.find()) {
matches++;
}
return matches;
}當(dāng)我們得到 0 次匹配時(shí)，測(cè)試應(yīng)該失敗；否則，它應(yīng)該通過。
5. 元字符
元字符影響模式的匹配方式；它們?cè)谝欢ǔ潭壬蠟樗阉髂Ｊ教砑恿诉壿?。Java API 支持幾個(gè)元字符，最簡(jiǎn)單的就是點(diǎn)“.”，它匹配任何字符：
@Test
public void givenText_whenMatchesWithDotMetach_thenCorrect() {
int matches = runTest(".", "foo");
assertTrue(matches > 0);
}
讓我們考慮前面的示例，其中正則表達(dá)式 foo 匹配了文本 foo 以及 foofoo，兩次。如果我們?cè)谡齽t表達(dá)式中使用點(diǎn)元字符，在第二種情況下我們不會(huì)得到兩次匹配：
@Test
public void givenRepeatedText_whenMatchesOnceWithDotMetach_thenCorrect() {
int matches = runTest("foo.", "foofoo");
assertEquals(matches, 1);
}
注意正則表達(dá)式中 foo 后面的點(diǎn)。匹配器匹配每個(gè) foo 之后的文本，因?yàn)樽詈蟮狞c(diǎn)部分表示任何字符。所以在找到第一個(gè) foo 后，其余部分被視為任意字符。這就是為什么只有一次匹配的原因。
API 還支持其他元字符 <([{\\^-=$!|]})?*+.>，我們將在本文進(jìn)一步探討。
6. 字符類
瀏覽官方的 Pattern 類規(guī)范時(shí)，我們會(huì)發(fā)現(xiàn)支持的正則表達(dá)式結(jié)構(gòu)的摘要。在字符類下，我們有大約 6 種結(jié)構(gòu)。
6.1 與或類
我們將其構(gòu)造為 [abc]。它匹配集合中的任意一個(gè)元素：
@Test
public void givenORSet_whenMatchesAny_thenCorrect() {
int matches = runTest("[abc]", "b");
assertEquals(matches, 1);
}
如果它們都出現(xiàn)在文本中，將分別匹配每個(gè)元素，而不考慮順序：
@Test
public void givenORSet_whenMatchesAnyAndAll_thenCorrect() {
int matches = runTest("[abc]", "cab");
assertEquals(matches, 3);
}
它們也可以作為字符串的一部分進(jìn)行交替。在下面的示例中，當(dāng)我們通過將集合中的每個(gè)元素與第一個(gè)字母交替創(chuàng)建不同的單詞時(shí)，所有這些都匹配：
@Test
public void givenORSet_whenMatchesAllCombinations_thenCorrect() {
int matches = runTest("[bcr]at", "bat cat rat");
assertEquals(matches, 3);
}
6.2 NOR類
上述集合通過在第一個(gè)元素位置添加插入符進(jìn)行否定：
@Test
public void givenNORSet_whenMatchesNon_thenCorrect() {
int matches = runTest("[^abc]", "g");
assertTrue(matches > 0);
}
這里是另一個(gè)例子：
@Test
public void givenNORSet_whenMatchesAllExceptElements_thenCorrect() {
int matches = runTest("[^bcr]at", "sat mat eat");
assertTrue(matches > 0);
}
6.3 范圍類
我們可以通過使用連字符(-)定義一個(gè)匹配文本應(yīng)落入的范圍。我們也可以對(duì)范圍進(jìn)行否定。
匹配大寫字母：
@Test
public void givenUpperCaseRange_whenMatchesUpperCase_
thenCorrect() {
int matches = runTest(
"[A-Z]", "Two Uppercase alphabets 34 overall");
assertEquals(matches, 2);
}
匹配小寫字母：
@Test
public void givenLowerCaseRange_whenMatchesLowerCase_
thenCorrect() {
int matches = runTest(
"[a-z]", "Two Uppercase alphabets 34 overall");
assertEquals(matches, 26);
}
匹配大寫和小寫字母：
@Test
public void givenBothLowerAndUpperCaseRange_
whenMatchesAllLetters_thenCorrect() {
int matches = runTest(
"[a-zA-Z]", "Two Uppercase alphabets 34 overall");
assertEquals(matches, 28);
}
匹配給定的數(shù)字范圍：
@Test
public void givenNumberRange_whenMatchesAccurately_
thenCorrect() {
int matches = runTest(
"[1-5]", "Two Uppercase alphabets 34 overall");
assertEquals(matches, 2);
}
匹配另一個(gè)數(shù)字范圍：
@Test
public void givenNumberRange_whenMatchesAccurately_
thenCorrect2(){
int matches = runTest(
"3[0-5]", "Two Uppercase alphabets 34 overall");
assertEquals(matches, 1);
}
6.4 聯(lián)合類
聯(lián)合字符類是通過組合兩個(gè)或更多字符類產(chǎn)生的結(jié)果：
@Test
public void givenTwoSets_whenMatchesUnion_thenCorrect() {
int matches = runTest("[1-3[7-9]]", "123456789");
assertEquals(matches, 6);
}
上面的測(cè)試只會(huì)匹配九個(gè)整數(shù)中的六個(gè)，因?yàn)槁?lián)合集跳過了4、5和6。
6.5 交叉點(diǎn)類
類似于聯(lián)合類，這個(gè)類是通過從兩個(gè)或更多集合中挑選公共元素得到的。要應(yīng)用交集，我們使用&&：
@Test
public void givenTwoSets_whenMatchesIntersection_thenCorrect() {
int matches = runTest("[1-6&&[3-9]]", "123456789");
assertEquals(matches, 4);
}
我們會(huì)得到四個(gè)匹配，因?yàn)檫@兩個(gè)集合的交集中只有四個(gè)元素。
6.6 減法類
我們可以使用減法來否定一個(gè)或多個(gè)字符類。例如，我們可以匹配一組奇數(shù)十進(jìn)制數(shù)：
@Test
public void givenSetWithSubtraction_whenMatchesAccurately_thenCorrect() {
int matches = runTest("[0-9&&[^2468]]", "123456789");
assertEquals(matches, 5);
}
只有1、3、5、7、9會(huì)被匹配。
7. 預(yù)定義字符類
Java正則表達(dá)式API還接受預(yù)定義的字符類。上述的一些字符類可以用更簡(jiǎn)短的形式表示，雖然這會(huì)讓代碼不那么直觀。Java正則表達(dá)式的一個(gè)特殊方面是轉(zhuǎn)義字符。
正如我們將看到的，大多數(shù)字符將以反斜杠開頭，這在Java中有特殊的含義。要使這些由Pattern類編譯，前導(dǎo)反斜杠必須被轉(zhuǎn)義，即\\d變?yōu)閈\\\d。
匹配數(shù)字，相當(dāng)于[0-9]：
@Test
public void givenDigits_whenMatches_thenCorrect() {
int matches = runTest("\\\\d", "123");
assertEquals(matches, 3);
}
匹配非數(shù)字，相當(dāng)于[^0-9]：
@Test
public void givenNonDigits_whenMatches_thenCorrect() {
int mathces = runTest("\\\\D", "a6c");
assertEquals(matches, 2);
}
匹配空格：
@Test
public void givenWhiteSpace_whenMatches_thenCorrect() {
int matches = runTest("\\\\s", "a c");
assertEquals(matches, 1);
}
匹配非空格：
@Test
public void givenNonWhiteSpace_whenMatches_thenCorrect() {
int matches = runTest("\\\\S", "a c");
assertEquals(matches, 2);
}
匹配單詞字符，相當(dāng)于[a-zA-Z_0-9]：
@Test
public void givenWordCharacter_whenMatches_thenCorrect() {
int matches = runTest("\\\\w", "hi!");
assertEquals(matches, 2);
}
匹配非單詞字符：
@Test
public void givenNonWordCharacter_whenMatches_thenCorrect() {
int matches = runTest("\\\\W", "hi!");
assertEquals(matches, 1);
}
8. 量詞
Java 正則表達(dá)式 API 也允許我們使用量詞。這使我們可以通過指定匹配的出現(xiàn)次數(shù)來進(jìn)一步調(diào)整匹配的行為。
要匹配文本零次或一次，我們使用?量詞：
@Test
public void givenZeroOrOneQuantifier_whenMatches_thenCorrect() {
int matches = runTest("\\\\a?", "hi");
assertEquals(matches, 3);
}
或者，我們可以使用大括號(hào)語(yǔ)法，Java 正則表達(dá)式 API 也支持這種語(yǔ)法：
@Test
public void givenZeroOrOneQuantifier_whenMatches_thenCorrect2() {
int matches = runTest("\\\\a{0,1}", "hi");
assertEquals(matches, 3);
}
這個(gè)示例引入了零長(zhǎng)度匹配的概念。當(dāng)量詞的匹配閾值為零時(shí)，它總是會(huì)匹配文本中的所有內(nèi)容，包括每個(gè)輸入末尾的空字符串。這意味著即使輸入為空，它也會(huì)返回一個(gè)零長(zhǎng)度的匹配。
這解釋了為什么我們?cè)谏鲜鍪纠械玫搅巳纹ヅ?，盡管字符串的長(zhǎng)度只有兩個(gè)。第三次匹配是零長(zhǎng)度的空匹配。
要匹配文本零次或無限次，我們使用*量詞，它類似于?：
@Test
public void givenZeroOrManyQuantifier_whenMatches_thenCorrect() {
int matches = runTest("\\\\a*", "hi");
assertEquals(matches, 3);
}
支持的替代方案：
@Test
public void givenZeroOrManyQuantifier_whenMatches_thenCorrect2() {
int matches = runTest("\\\\a{0,}", "hi");
assertEquals(matches, 3);
}
有區(qū)別的量詞是+，它的匹配閾值為1。如果所需的字符串根本沒有出現(xiàn)，則不會(huì)有任何匹配，甚至連零長(zhǎng)度的字符串也不會(huì)匹配：
@Test
public void givenOneOrManyQuantifier_whenMatches_thenCorrect() {
int matches = runTest("\\\\a+", "hi");
assertFalse(matches);
}
支持的替代方案：
@Test
public void givenOneOrManyQuantifier_whenMatches_thenCorrect2() {
int matches = runTest("\\\\a{1,}", "hi");
assertFalse(matches);
}
與 Perl 和其他語(yǔ)言一樣，我們可以使用大括號(hào)語(yǔ)法來匹配特定次數(shù)的文本：
@Test
public void givenBraceQuantifier_whenMatches_thenCorrect() {
int matches = runTest("a{3}", "aaaaaa");
assertEquals(matches, 2);
}
在上述示例中，我們得到了兩次匹配，因?yàn)橹挥挟?dāng)a連續(xù)出現(xiàn)三次時(shí)才會(huì)產(chǎn)生匹配。然而，在下一個(gè)測(cè)試中，我們不會(huì)得到匹配，因?yàn)槲谋局贿B續(xù)出現(xiàn)了兩次：
@Test
public void givenBraceQuantifier_whenFailsToMatch_thenCorrect() {
int matches = runTest("a{3}", "aa");
assertFalse(matches > 0);
}
當(dāng)我們?cè)诖罄ㄌ?hào)中使用范圍時(shí)，匹配將是貪婪的，從范圍的高端開始匹配：
@Test
public void givenBraceQuantifierWithRange_whenMatches_thenCorrect() {
int matches = runTest("a{2,3}", "aaaa");
assertEquals(matches, 1);
}
在這里我們指定了至少兩次出現(xiàn)，但不超過三次，所以我們得到了一次匹配，匹配器看到的是一個(gè)aaa和一個(gè)孤立的a，它無法匹配。
然而，API 允許我們指定惰性或非貪婪的方法，使得匹配器可以從范圍的低端開始匹配，匹配兩個(gè)連續(xù)的aa：
@Test
public void givenBraceQuantifierWithRange_whenMatchesLazily_thenCorrect() {
int matches = runTest("a{2,3}?", "aaaa");
assertEquals(matches, 2);
}
9. 捕獲組
API 還允許我們通過捕獲組將多個(gè)字符視為一個(gè)單元。它會(huì)為捕獲組附加編號(hào)，并允許使用這些編號(hào)進(jìn)行反向引用。
在本節(jié)中，我們將看到一些如何在 Java 正則表達(dá)式 API 中使用捕獲組的示例。
讓我們使用一個(gè)捕獲組，僅當(dāng)輸入文本包含兩個(gè)相鄰的數(shù)字時(shí)才進(jìn)行匹配：
@Test
public void givenCapturingGroup_whenMatches_thenCorrect() {
int matches = runTest("(\\\\d\\\\d)", "12");
assertEquals(matches, 1);
}
上面匹配的編號(hào)是1，使用反向引用告訴匹配器我們要匹配文本的另一部分。這樣，輸入不會(huì)有兩個(gè)單獨(dú)的匹配：
@Test
public void givenCapturingGroup_whenMatches_thenCorrect2() {
int matches = runTest("(\\\\d\\\\d)", "1212");
assertEquals(matches, 2);
}
我們可以獲得一次匹配，但通過反向引用將相同的正則表達(dá)式匹配擴(kuò)展到整個(gè)輸入的長(zhǎng)度：
@Test
public void givenCapturingGroup_whenMatchesWithBackReference_thenCorrect() {
int matches = runTest("(\\\\d\\\\d)\\\\1", "1212");
assertEquals(matches, 1);
}
我們必須重復(fù)正則表達(dá)式而不使用反向引用才能實(shí)現(xiàn)相同的效果：
@Test
public void givenCapturingGroup_whenMatches_thenCorrect3() {
int matches = runTest("(\\\\d\\\\d)(\\\\d\\\\d)", "1212");
assertEquals(matches, 1);
}
同樣，對(duì)于任何其他數(shù)量的重復(fù)，反向引用可以使匹配器將輸入視為一次匹配：
@Test
public void givenCapturingGroup_whenMatchesWithBackReference_thenCorrect2() {
int matches = runTest("(\\\\d\\\\d)\\\\1\\\\1\\\\1", "12121212");
assertEquals(matches, 1);
}
但如果我們更改最后一個(gè)數(shù)字，匹配將失敗：
@Test
public void givenCapturingGroupAndWrongInput_whenMatchFailsWithBackReference_thenCorrect() {
int matches = runTest("(\\\\d\\\\d)\\\\1", "1213");
assertFalse(matches > 0);
}
請(qǐng)務(wù)必記住轉(zhuǎn)義反斜杠，它們?cè)?Java 語(yǔ)法中至關(guān)重要。
10. 邊界匹配器
Java 正則表達(dá)式 API 也支持邊界匹配。如果我們關(guān)心匹配應(yīng)該出現(xiàn)在輸入文本的確切位置，那么這就是我們要找的。在前面的示例中，我們關(guān)心的只是是否找到了匹配。
要僅在所需正則表達(dá)式在文本開頭為真時(shí)匹配，我們使用插入符號(hào)^。
由于文本dog可以在開頭找到，這個(gè)測(cè)試將通過：
@Test
public void givenText_whenMatchesAtBeginning_thenCorrect() {
int matches = runTest("^dog", "dogs are friendly");
assertTrue(matches > 0);
}
以下測(cè)試將失?。?/p>
@Test
public void givenTextAndWrongInput_whenMatchFailsAtBeginning_thenCorrect() {
int matches = runTest("^dog", "are dogs are friendly?");
assertFalse(matches > 0);
}
要僅在所需正則表達(dá)式在文本末尾為真時(shí)匹配，我們使用美元符號(hào)$。我們將在以下情況下找到匹配：
@Test
public void givenText_whenMatchesAtEnd_thenCorrect() {
int matches = runTest("dog$", "Man's best friend is a dog");
assertTrue(matches > 0);
}
而在這里我們不會(huì)找到匹配：
@Test
public void givenTextAndWrongInput_whenMatchFailsAtEnd_thenCorrect() {
int matches = runTest("dog$", "is a dog man's best friend?");
assertFalse(matches > 0);
}
如果我們只想在找到所需文本時(shí)進(jìn)行匹配，我們?cè)谡齽t表達(dá)式的開頭和結(jié)尾使用\\b：
空格是一個(gè)單詞邊界：
@Test
public void givenText_whenMatchesAtWordBoundary_thenCorrect() {
int matches = runTest("\\bdog\\b", "a dog is friendly");
assertTrue(matches > 0);
}
而這個(gè)測(cè)試將失?。?/p>
@Test
public void givenTextAndWrongInput_whenMatchFailsAtWordBoundary_thenCorrect() {
int matches = runTest("\\bdog\\b", "snoop dogg is a rapper");
assertFalse(matches > 0);
}
類似地，我們可以匹配整個(gè)文本的邊界，而不僅僅是單詞的邊界：
@Test
public void givenText_whenMatchesAtWordAndTextBoundary_thenCorrect() {
int matches = runTest("^dog$", "dog");
assertTrue(matches > 0);
}
11. Pattern 類方法
之前，我們只用基本方式創(chuàng)建了 Pattern 對(duì)象。然而，這個(gè)類還有一個(gè)編譯方法的變體，它接受一組標(biāo)志以及正則表達(dá)式參數(shù)，這會(huì)影響我們匹配模式的方式。
這些標(biāo)志只是抽象的整數(shù)值。讓我們重載測(cè)試類中的 runTest 方法，使它可以將標(biāo)志作為第三個(gè)參數(shù)：
public static int runTest(String regex, String text, int flags) {
pattern = Pattern.compile(regex, flags);
matcher = pattern.matcher(text);
int matches = 0;
while (matcher.find()){
matches++;
}
return matches;
}
在本節(jié)中，我們將介紹不同支持的標(biāo)志及其用法。
Pattern.CANON_EQ
此標(biāo)志啟用了規(guī)范等效性。指定時(shí)，只有當(dāng)兩個(gè)字符的完整規(guī)范分解匹配時(shí)，它們才被視為匹配。
考慮帶重音符號(hào)的 Unicode 字符é。其復(fù)合代碼點(diǎn)是 u00E9。然而，Unicode 也有其組件字符的獨(dú)立代碼點(diǎn)：e（u0065）和重音符號(hào) u0301。在這種情況下，復(fù)合字符 u00E9 與字符序列 u0065u0301 無法區(qū)分。
默認(rèn)情況下，匹配不考慮規(guī)范等效性：
@Test
public void givenRegexWithoutCanonEq_whenMatchFailsOnEquivalentUnicode_thenCorrect() {
int matches = runTest("\u00E9", "\u0065\u0301");
assertFalse(matches > 0);
}
但如果我們添加了標(biāo)志，則測(cè)試將通過：
@Test
public void givenRegexWithCanonEq_whenMatchesOnEquivalentUnicode_thenCorrect() {
int matches = runTest("\u00E9", "\u0065\u0301", Pattern.CANON_EQ);
assertTrue(matches > 0);
}
Pattern.CASE_INSENSITIVE
此標(biāo)志允許忽略大小寫進(jìn)行匹配。默認(rèn)情況下，匹配時(shí)考慮大小寫：
@Test
public void givenRegexWithDefaultMatcher_whenMatchFailsOnDifferentCases_thenCorrect() {
int matches = runTest("dog", "This is a Dog");
assertFalse(matches > 0);
}
使用此標(biāo)志后，我們可以改變默認(rèn)行為：
@Test
public void givenRegexWithCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() {
int matches = runTest("dog", "This is a Dog", Pattern.CASE_INSENSITIVE);
assertTrue(matches > 0);
}
我們還可以使用等效的嵌入標(biāo)志表達(dá)式來實(shí)現(xiàn)相同的效果：
@Test
public void givenRegexWithEmbeddedCaseInsensitiveMatcher_whenMatchesOnDifferentCases_thenCorrect() {
int matches = runTest("(?i)dog", "This is a Dog");
assertTrue(matches > 0);
}
Pattern.COMMENTS
Java API 允許我們使用 # 在正則表達(dá)式中包含注釋。這有助于為可能對(duì)其他程序員不太明顯的復(fù)雜正則表達(dá)式添加文檔說明。
注釋標(biāo)志使匹配器忽略正則表達(dá)式中的任何空格或注釋，并只考慮模式。在默認(rèn)匹配模式下，以下測(cè)試將失?。?/p>
@Test
public void givenRegexWithComments_whenMatchFailsWithoutFlag_thenCorrect() {
int matches = runTest("dog$ #check for word dog at end of text", "This is a dog");
assertFalse(matches > 0);
}
這是因?yàn)槠ヅ淦鲗⒃谳斎胛谋局胁檎艺麄€(gè)正則表達(dá)式，包括空格和 # 字符。但是，當(dāng)我們使用標(biāo)志時(shí)，它會(huì)忽略多余的空格，并將 # 開頭的所有文本視為注釋，忽略每行的注釋：
@Test
public void givenRegexWithComments_whenMatchesWithFlag_thenCorrect() {
int matches = runTest("dog$ #check end of text", "This is a dog", Pattern.COMMENTS);
assertTrue(matches > 0);
}
還有一個(gè)用于此的替代嵌入標(biāo)志表達(dá)式：
@Test
public void givenRegexWithComments_whenMatchesWithEmbeddedFlag_thenCorrect() {
int matches = runTest("(?x)dog$ #check end of text", "This is a dog");
assertTrue(matches > 0);
}
Pattern.DOTALL
默認(rèn)情況下，當(dāng)我們?cè)谡齽t表達(dá)式中使用點(diǎn)“.”表達(dá)式時(shí)，我們會(huì)匹配輸入字符串中的每個(gè)字符，直到遇到換行符。
使用此標(biāo)志，匹配將包含行終止符。通過以下示例我們將更好地理解這一點(diǎn)。由于我們希望對(duì)匹配的字符串進(jìn)行斷言，我們將使用 matcher 的 group 方法，它返回上一個(gè)匹配項(xiàng)。
首先，讓我們看看默認(rèn)行為：
@Test
public void givenRegexWithLineTerminator_whenMatchFails_thenCorrect() {
Pattern pattern = Pattern.compile("(.*)");
Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line");
matcher.find();
assertEquals("this is a text", matcher.group(1));
}
如我們所見，只有在行終止符之前的輸入部分被匹配。
現(xiàn)在在 dotall 模式中，整個(gè)文本（包括行終止符）將被匹配：
@Test
public void givenRegexWithLineTerminator_whenMatchesWithDotall_thenCorrect() {
Pattern pattern = Pattern.compile("(.*)", Pattern.DOTALL);
Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line");
matcher.find();
assertEquals("this is a text" + System.getProperty("line.separator") + " continued on another line", matcher.group(1));
}
我們還可以使用嵌入標(biāo)志表達(dá)式啟用 dotall 模式：
@Test
public void givenRegexWithLineTerminator_whenMatchesWithEmbeddedDotall_thenCorrect() {
Pattern pattern = Pattern.compile("(?s)(.*)");
Matcher matcher = pattern.matcher("this is a text" + System.getProperty("line.separator") + " continued on another line");
matcher.find();
assertEquals("this is a text" + System.getProperty("line.separator") + " continued on another line", matcher.group(1));
}
Pattern.LITERAL
在此模式下，匹配器不會(huì)給任何元字符、轉(zhuǎn)義字符或正則表達(dá)式語(yǔ)法賦予特殊含義。如果沒有此標(biāo)志，匹配器將匹配以下正則表達(dá)式與任意輸入字符串：
@Test
public void givenRegex_whenMatchesWithoutLiteralFlag_thenCorrect() {
int matches = runTest("(.*)", "text");
assertTrue(matches > 0);
}
這是我們?cè)谒惺纠锌吹降哪J(rèn)行為。但是，使用此標(biāo)志后，我們將找不到匹配，因?yàn)槠ヅ淦鲗⒉檎?(.*) 而不是解釋它：
@Test
public void givenRegex_whenMatchFailsWithLiteralFlag_thenCorrect() {
int matches = runTest("(.*)", "text", Pattern.LITERAL);
assertFalse(matches > 0);
}
現(xiàn)在如果我們添加所需的字符串，測(cè)試將通過：
@Test
public void givenRegex_whenMatchesWithLiteralFlag_thenCorrect() {
int matches = runTest("(.*)", "text(.*)", Pattern.LITERAL);
assertTrue(matches > 0);
}
沒有用于啟用文字解析的嵌入標(biāo)志字符。
Pattern.MULTILINE
默認(rèn)情況下，^ 和 $ 元字符分別絕對(duì)匹配整個(gè)輸入字符串的開始和結(jié)束，匹配器忽略任何行終止符：
@Test
public void givenRegex_whenMatchFailsWithoutMultilineFlag_thenCorrect() {
int matches = runTest("dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox");
assertFalse(matches > 0);
}
通過啟用此標(biāo)志，匹配器將匹配每一行，而不僅僅是整個(gè)輸入文本：
@Test
public void givenRegex_whenMatchesWithMultilineFlag_thenCorrect() {
int matches = runTest("dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox", Pattern.MULTILINE);
assertTrue(matches > 0);
}
我們還可以使用嵌入表達(dá)式來啟用多行模式：
@Test
public void givenRegex_whenMatchesWithEmbeddedMultilineFlag_thenCorrect() {
int matches = runTest("(?m)dog$", "This is a dog" + System.getProperty("line.separator") + "this is a fox");
assertTrue(matches > 0);
}
12. Matcher 類方法
在本節(jié)中，我們將學(xué)習(xí) Matcher 類中的一些有用方法。為了清晰起見，我們將根據(jù)功能對(duì)其進(jìn)行分類。
12.1 索引方法
索引方法提供了有用的索引值，準(zhǔn)確顯示在輸入字符串中找到匹配的位置。在下面的測(cè)試中，我們將確認(rèn)輸入字符串中 "dog" 的匹配起始和結(jié)束索引：
@Test
public void givenMatch_whenGetsIndices_thenCorrect() {
Pattern pattern = Pattern.compile("dog");
Matcher matcher = pattern.matcher("This dog is mine");
matcher.find();
assertEquals(5, matcher.start());
assertEquals(8, matcher.end());
}
12.2 研究方法
研究方法遍歷輸入字符串，并返回一個(gè)布爾值，指示是否找到了模式。常用的方法有 matches 和 lookingAt。
matches 和 lookingAt 方法都嘗試將輸入序列與模式進(jìn)行匹配。區(qū)別在于 matches 要求整個(gè)輸入序列完全匹配，而 lookingAt 不需要。
這兩個(gè)方法都從輸入字符串的開頭開始匹配：
@Test
public void whenStudyMethodsWork_thenCorrect() {
Pattern pattern = Pattern.compile("dog");
Matcher matcher = pattern.matcher("dogs are friendly");
assertTrue(matcher.lookingAt());
assertFalse(matcher.matches());
}
在這種情況下，matches 方法將返回 true：
@Test
public void whenMatchesStudyMethodWorks_thenCorrect() {
Pattern pattern = Pattern.compile("dog");
Matcher matcher = pattern.matcher("dog");
assertTrue(matcher.matches());
}
12.3 替換方法
替換方法用于替換輸入字符串中的文本。常見的方法有 replaceFirst 和 replaceAll。
replaceFirst 和 replaceAll 方法用于替換與給定正則表達(dá)式匹配的文本。顧名思義，replaceFirst 只替換第一次出現(xiàn)的匹配項(xiàng)，replaceAll 替換所有出現(xiàn)的匹配項(xiàng)：
@Test
public void whenReplaceFirstWorks_thenCorrect() {
Pattern pattern = Pattern.compile("dog");
Matcher matcher = pattern.matcher(
"dogs are domestic animals, dogs are friendly");
String newStr = matcher.replaceFirst("cat");
assertEquals(
"cats are domestic animals, dogs are friendly", newStr);
}
替換所有出現(xiàn)的匹配項(xiàng)：
@Test
public void whenReplaceAllWorks_thenCorrect() {
Pattern pattern = Pattern.compile("dog");
Matcher matcher = pattern.matcher(
"dogs are domestic animals, dogs are friendly");
String newStr = matcher.replaceAll("cat");
assertEquals("cats are domestic animals, cats are friendly", newStr);
}
replaceAll 方法允許我們用相同的替換文本替換所有匹配項(xiàng)。如果我們想基于具體情況替換匹配項(xiàng)，則需要使用一種令牌替換技術(shù)。
13. 結(jié)論
在本文中，我們學(xué)習(xí)了如何在 Java 中使用正則表達(dá)式。我們還探討了 java.util.regex 包中的最重要功能。若你想提升Java技能，可關(guān)注我們的Java培訓(xùn)課程。
