Java最高

开始使用Spring 5和Spring Boot 2,通过学习的春天课程:

>>看看这个课程

1.概述

在本文中,我们将讨论Java Regex API以及Java编程语言中如何使用正则表达式。

在正则表达式的世界中,有许多不同的风格可供选择,例如grep、Perl、Python、PHP、awk等等。

这意味着在一种编程语言中工作的正则表达式可能不能在另一种编程语言中工作。Java中的正则表达式语法与Perl中的非常相似。

2.设置

要在Java中使用正则表达式,我们不需要任何特殊设置。JDK包含一个特殊的包java.util.regex完全致力于正则表达式操作。我们只需要将其导入我们的代码。

此外,类还具有内置的Regex支持,我们通常在我们的代码中使用。

3. Java Regex包

java.util.regex包由三个类组成:模式,匹配器PatternSyntaxException

  • 模式对象是编译的正则表达式。这模式类不提供公共构造函数。要创建一个模式,我们必须首先调用它的一个公共静态编译方法,然后返回模式对象。这些方法接受正则表达式作为第一个参数。
  • 匹配对象将图案解释并对输入执行匹配操作细绳.它也没有定义公共构造函数。我们获得一个匹配对象调用匹配器方法模式对象。
  • PatternSyntaxException对象是一个未检查的异常,该异常指示正则表达式模式中的语法错误。

我们将详细探讨这些课程;但是,我们必须首先了解Java中的Regex如何。

如果您已经熟悉来自不同环境的正则表达式,则可能会发现某些差异,但它们是最小的。

4.简单的例子

让我们从最简单的正则表达式用例开始。正如我们之前注意的那样,当正则表达式应用于字符串时,它可能会匹配零个或多次。

支持的最基本形式的模式匹配java.util.regexAPI是匹配A.细绳文字.例如,如果正则表达式为喷火和输入细绳喷火,比赛将成功,因为字符串是相同的:

@Test public void giventext_whensimpleregexmatches_threct () {Pattern Pattern = Pattern.compile("foo");match = pattern.matcher("foo");assertTrue (matcher.find ());}

我们首先创建一个模式对象的静态编译方法,并将其传递给我们想要使用的模式。

然后我们创建一个匹配对象调用模式对象的匹配器方法并将其传递给我们要检查匹配的文本。

之后,我们调用该方法找到在Matcher对象中

找到方法在输入文本中继续前进,并为每个匹配返回true,因此我们也可以使用它来查找匹配计数:

@Test public void giventext_whensimpleregexmatchestwice_threct () {Pattern Pattern = Pattern.compile("foo");match = pattern.matcher("foofoo");Int匹配= 0;While (matcher.find()) {matches++;} assertequal(比赛,2);}

因为我们将运行更多的测试,所以我们可以在调用的方法中抽象查找匹配数的逻辑小牛

public static int runtest(String Regex,String Text){Pattern Pattern = Pattern.Compile(正则表达式);匹配器匹配器= pattern.matcher(文本);Int匹配= 0;While (matcher.find()) {matches++;}返回比赛;}

当我们获得0匹配时,测试应失败,否则,它应该通过。

5.元字符

元字符以向搜索模式添加逻辑的方式影响模式匹配的方式。Java API支持几个元字符,最简单的就是点“。”匹配任何字符:

@Test public void giventext_whenmatcheswithdotmetach_threct () {int matches = runTest(".", "foo");assertTrue(匹配> 0);}

考虑前面的示例,正​​则表达式喷火匹配的文本喷火以及foofoo两次。如果我们在正则表达式中使用点元字符,我们将不会在第二种情况下得到两个匹配:

@Test public void givenrepeatedtext_whenmatchesoncewithdotmetach_thcorrect () {int matches= runTest("foo.", "foofoo");assertequal(比赛,1);}

注意。后面的点喷火在正则表达式。匹配器匹配前面的每个文本喷火因为最后一个点表示后面的任何字符。在找到第一个之后喷火,其余的被视为任何角色。这就是为什么只有一个匹配项。

该API支持其他几个元字符<([{\ ^ - = $!|]})?* +。>我们将在本文中进一步研究。

6.字符类

浏览官方模式类规范,我们将发现支持的正则表达式构造的摘要。在字符类中,我们大约有6种结构。金宝搏官网188be

6.1。

构造成[ABC].匹配集合中的任何元素:

@test public voidedorset_whenmatchesany_thencorrect(){int matches = luntest(“[abc]”,“b”);assertequal(比赛,1);}

如果它们都出现在文本中,每个都单独匹配,不分顺序:

@Test public void givenorset_whenmatchesanyandall_threct () {int matches = runTest("[abc]", "cab");assertequal(比赛,3);}

它们也可以作为a的一部分交替细绳.在下面的例子中,当我们通过交替使用集合中的每个元素的第一个字母来创建不同的单词时,它们都是匹配的:

@test public voidedorset_whenmatchesallcombinations_thencorrect(){int matches = runtest(“[bcr]在”,“蝙蝠猫大鼠”);assertequal(比赛,3);}

6.2。也不

通过添加插入件作为第一个元素来否定上述组:

@Test public void givennorset_whenmatchesnon_threct () {int matches = runTest("[^abc]", "g");assertTrue(匹配> 0);}

另一种情况:

@Test public void givennorset_whenmatchesallexceptelements_threct () {int matches = runTest("[^bcr]at", " sit mat eat");assertTrue(匹配> 0);}

6.3。范围类

我们可以用连字符(-)来定义一个指定匹配文本应该落在其中的范围的类,同样,我们也可以对一个范围取反。

匹配大写字母:

@test public void gendpercaserange_whenmatchesuppercase_ thencorrect(){int matches = luntest(“[a-z]”,“两个大写字母34总体上”);assertequal(比赛,2);}

匹配小写字母:

@Test public void givenLowerCaseRange_whenMatchesLowerCase_ thecorrect () {int matches = runTest(“[a-z]”,“两个大写字母34 overall”);assertequal(匹配,26);}

大小写字母匹配:

@Test public void givenBothLowerAndUpperCaseRange_ whenmatchesallletters_thcorrect () {int matches = runTest("[a-z -z]", "两个大写字母34 overall");assertequal(匹配,28);}

匹配给定的数字范围:

@Test public void givenNumberRange_whenMatchesAccurately_ thecorrect () {int matches = runTest(“[1-5]”,“两个大写字母34 overall”);assertequal(比赛,2);}

匹配另一个数字范围:

@test public void gendnumberrange_whenmatchesAccuration_ thencorRect2(){int matches = luntest(“[30-35]”,“两个大写字母34总体上”);assertequal(比赛,1);}

6.4。联盟类

联合字符类是组合两个或更多字符类的结果:

@test public viventwosets_whenmatchesunion_thencorrect(){int matches = runtest(“[1-3 [7-9]],”123456789“);assertequals(比赛,6);}

上面的测试将只匹配9个整数中的6个,因为并集跳过4、5和6。

6.5。交叉类

与Union类类似,此类摘要从两个或多个集合之间采摘常见元素。要申请交叉点,我们使用&&

@Test public void giventwosets_whenmatchesintersection_thcorrect () {int matches = runTest("[1-6&&[3-9]]", "123456789");assertequal(匹配,4);}

我们获得4场比赛,因为两组的交点只有4个元素。

6.6。减法类

我们可以使用减法来否定一个或多个字符类,例如匹配一组奇数小数:

@test public vivensetwithsubtraction_whenmatchesAcculations_thencorrect(){int matches = runtest(“[0-9 && [^ 2468]],”123456789“);assertequals(比赛,5);}

只有1、3、5、7、9将匹配。

7.预定义的字符类

Java正则表达式API也接受预定义的字符类。上面的一些字符类可以用更短的形式表示,但这会使代码不那么直观。这个正则表达式的Java版本的一个特殊方面是转义字符。

正如我们将看到的,大多数字符将以反斜杠开头,这在Java中有特殊含义。以便由模式类——开头的反斜杠必须转义,即\ d就变成了\ \ d

匹配的数字,相当于[0 - 9]

@Test public void givendigits_whenmatches_thcorrect () {int matches = runTest("\\d", "123");assertequal(比赛,3);}

匹配的非数字,相当于(^ 0 - 9)

@Test public void givennondigits_whenmatches_thcorrect () {int mathces = runTest("\\D", "a6c");assertequal(比赛,2);}

匹配空格:

@Test public void givenwhitespace_whenmatches_thcorrect () {int matches = runTest("\\s", "a c");assertequal(比赛,1);}

匹配非白人空间:

@Test public void givennonwhitespace_whenmatches_thcorrect () {int matches = runTest("\\S", "a \ c");assertequal(比赛,2);}

匹配单词字符,相当于(a-zA-Z_0-9)

@test public voidedwordcharacter_whenmatches_thencorrect(){int matches = runtest(“\\ w”,“hi!”);assertequal(比赛,2);}

匹配非单词字符:

@Test public void givennonwordcharacter_whenmatches_thcorrect () {int matches = runTest("\\W", "hi!");assertequal(比赛,1);}

8.量词

Java Regex API还允许我们使用量词。这些使我们能够通过指定匹配的匹配次数来进一步调整匹配的行为。

为零次或一次匹配文本,我们使用量词:

@test公共voidedzeroore quantifier_whenmatches_thencorrect(){int matches = runtest(“\\ a?”,“hi”);assertequal(比赛,3);}

或者,我们可以使用BRACE语法,也支持Java Regex API:

@Test public void givenZeroOrOneQuantifier_whenMatches_thenCorrect2() {int matches = runTest("\\a{0,1}", "hi");assertequal(比赛,3);}

这个例子介绍了零长度匹配的概念。如果一个量词的匹配阈值是零,那么它总是匹配文本中的所有内容,包括一个空的细绳在每次输入结束时。这意味着即使输入为空,也会返回一个零长度匹配。

这解释了为什么我们在上面的例子中获得3场比赛,尽管有一个s练习长度的两个。第三匹配是零长度空细绳

匹配一个文本0次或无限次,我们*量词,它只是类似于?:

@Test public void givenzeroormanyquantifier_whenmatches_thcorrect () {int matches = runTest("\\a*", "hi");assertequal(比赛,3);}

支持选择:

@test public void gendzeroormanyquantifier_whenmatches_thencorRectifer2(){int matches = runtest(“\\ a {0,}”,“hi”);assertequal(比赛,3);}

具有差异的量词是+,它具有匹配的阈值1.如果需要的细绳根本没有发生,不会匹配,甚至没有零长度细绳

@Test public void givenoneormanyquantifier_whenmatches_thcorrect () {int matches = runTest("\\a+", "hi");assertFalse(匹配);}

支持选择:

@test public voidedoneormany quantifier_whenmatches_thengorct2(){int matches = runtest(“\\ a {1,}”,“hi”);assertFalse(匹配);}

正如在Perl和其他语言中一样,大括号语法可以多次用于匹配给定的文本:

@Test public void givenbracequantifier_whenmatches_thcorrect () {int matches = runTest("a{3}", "aaaaaa");assertequal(比赛,2);}

在上面的例子中,我们获得了两个匹配,因为只有当匹配才会发生一种连续三次出现三次。但是,在下一个测试中,我们将无法获得匹配,因为文本只出现两次连续两次:

@Test public void givenbracequantifier_whenfailstomatch_thcorrect () {int matches = runTest("a{3}", "aa");assertFalse(匹配> 0);}

当我们在括号中使用范围时,比赛将贪婪,从范围的较高端匹配:

@test public void gendbracequantifierwithrange_whenmatches_thencorrect(){int matches = runtest(“a {2,3}”,“aaaa”);assertequal(比赛,1);}

我们已经指定了至少两次但不超过三次,所以我们得到的是一个匹配,而匹配器看到的是一个匹配AAA.一种孤独的一个不能匹配的。

但是,API允许我们指定懒惰或不情愿的方法,使得匹配器可以从范围的下端开始,在这种情况下匹配两个出现AA.AA.

@Test public void givenbracequantifierwithrange_whenmatcheslazily_threct () {int matches = runTest("a{2,3}?", "aaaa");assertequal(比赛,2);}

9.捕获团体

API也允许我们通过捕获组将多个字符视为一个单元

它将将数字连接到捕获组,并允许返回使用这些数字引用。

在本节中,我们将看到一些关于如何在Java Regex API中使用捕获组的示例。

让我们使用一个只匹配输入文本中相邻两个数字的捕获组:

@Test public void givencapturinggroup_whenmatches_thcorrect () {int maches = runTest("(\\d\ d)", "12");assertequal(比赛,1);}

附于上述比赛的号码是1,使用反向引用来告诉匹配器我们想要匹配文本的匹配部分的另一个出现。这样,而不是:

@test public vioid givencapturinggroup_whenmatches_thengorct2(){int matches = luntest(“(\\ d \\ d)”,“1212”);assertequal(比赛,2);}

当输入有两个单独的匹配时,我们可以有一个匹配,但使用回引用将相同的正则表达式匹配传播到输入的整个长度:

@test public vioid givencapturinggroup_whenmatcheswithbackreference_ thencorrect(){int matches = runtest(“(\\ d \\ d)\\ 1”,“1212”);assertequal(比赛,1);}

如果我们必须重复正则表达式,而无需背部引用以实现相同的结果:

@Test public void givenCapturingGroup_whenMatches_thenCorrect3() {int matches = runTest("(\\d\ d)(\\d\ d)", "1212");assertequal(比赛,1);}

类似地,对于任何其他次数的重复,反向引用可以使匹配器将输入视为单个匹配:

@Test public void givenCapturingGroup_whenMatchesWithBackReference_ theencorrect2 () {int matches = runTest("(\\d\ d)\\1\ 1\ 1", "12121212");assertequal(比赛,1);}

但是如果你改变最后一个数字,匹配就会失败:

@Test public void givenCapturingGroupAndWrongInput_ whenmatchfailswithbackreference_thcorrect () {int matches = runTest("(\\d\ d)\\1", "1213");assertFalse(匹配> 0);}

重要的是不要忘记逃避反斜杠,这在Java语法中至关重要。

10.边界匹配器

Java Regex API还支持边界匹配。如果我们关心在输入文本金宝搏官网188be恰好匹配的位置,那么这就是我们正在寻找的。通过前面的例子,我们所关心的只是是否找到了匹配。金宝搏官网188be

为了仅在必需的正则表达式在文本开头为真时匹配,我们使用插入符号^.

这个测试将失败,因为文本可以在开头找到:

@Test public void giventext_whenmatchesatbeginning_threct () {int matches = runTest("^狗","狗是友好的");assertTrue(匹配> 0);}

以下测试将失败:

@Test public void givenTextAndWrongInput_whenMatchFailsAtBeginning_ thecorrect_() {int matches = runTest("^狗","狗是友好的吗?");assertFalse(匹配> 0);}

只有在文本末尾所需的正则表达式时才匹配,我们使用美元字符$。在以下情况下将找到匹配:

@test public viventext_whenmatchesatend_thencorrect(){int matches = runtest(“狗$”,“男人最好的朋友是狗”);assertTrue(匹配> 0);}

没有匹配将在这里找到:

@test public viventextandwonginput_whenmatchfailsatend_thencorrect(){int matches = runtest(“狗$”,“是一个狗男人最好的朋友?”);assertFalse(匹配> 0);}

如果只希望在单词边界找到所需文本时进行匹配,则使用\ \ b在正则表达式的开头和结尾的正则表达式:

空间是一个词的边界:

@Test public void giventext_whenmatchesatworddboundary_threct () {int matches = runTest("\\bdog\ b", "一只狗是友好的");assertTrue(匹配> 0);}

一行开头的空字符串也是单词边界:

@Test public void giventext_whenmatchesatworddboundary_thencorrect2 () {int matches = runTest("\\bdog\ b", "狗是人类最好的朋友");assertTrue(匹配> 0);}

这些测试通过了因为a的开头细绳,以及一个文本和另一个文本之间的空格,标记单词边界,但是,下面的测试显示相反的:

@Test public void givenwrongtext_whenmatchfailsatworddboundary_thcorrect () {int matches = runTest("\\bdog\\b", "snoop dogg是一个说唱歌手");assertFalse(匹配> 0);}

在一行中出现两个单词的字符并不表示单词边界,但是我们可以通过改变正则表达式的结尾来寻找非单词边界来传递它:

@test public viventext_whenmatchesatwordnonboundary_thencorrect(){int matches = runtest(“\\ bdog \\ b”,“snoop dogg是一个说唱歌手”);assertTrue(匹配> 0);}

11.模式类方法

以前,我们只创造了模式物体以基本的方式。但是,这类课程有另一个变体编译接受一组标志的方法以及影响模式匹配方式的正则表达式参数。

这些标志只是抽象的整数值。让我们过度载荷小牛方法,这样它就可以接受一个标志作为第三个参数:

公共静态int runtest(String Regex,String Text,INT标志){Pattern = Pattern.compile(正则表达式,标志);匹配器= pattern.matcher(文本);Int匹配= 0;while(matcher.find()){matches ++;}返回比赛;}

在本节中,我们将了解不同的受支持标志以及它们是如何使用的。

pattern.canon_eq.

这个标志启用规范等价。当指定时,当且仅当它们的完整规范分解匹配时,将认为两个字符匹配。

考虑重点的Unicode字符e.它的复合代码点是u00E9.但是,Unicode还具有其组件字符的单独代码点E.U0065.和急性口音,u0301.在这种情况下,复合字符00E9.和两个字符序列是无法区分的吗00650301

默认情况下,匹配不考虑规范等价:

@test public void geldregexwithoutcanoneq_whenmatchfailsonequivalentunicode_thencorrect(){int matches = luntest(“\ u00e9”,“\ u0065 \ u0301”);assertFalse(匹配> 0);}

但是如果我们添加了这个标志,那么测试就会通过:

@Test public void givenregexwithcanoneq_whenmatchesonequivalentunicode_threct () {int matches = runTest("\u00E9", "\u0065\u0301", Pattern.CANON_EQ);assertTrue(匹配> 0);}

模式。CASE_INSENSITIVE

此标志使得无论案例如何匹配。默认匹配需要案例考虑:

@Test public void givenregexwithdefaultmatcher_whenmatchfailsondifferentcases_thenrect () {int matches = runTest("狗","这是一只狗");assertFalse(匹配> 0);}

所以使用这个标志,我们可以改变默认行为:

@Test public void givenRegexWithCaseInsensitiveMatcher _whenmatchesondifferentcases_thenrect () {int matches = runTest("狗","这是一只狗",Pattern.CASE_INSENSITIVE);assertTrue(匹配> 0);}

我们还可以使用等价,嵌入的标志表达式来实现相同的结果:

@Test public void givenregexwiththembeddedcaseinsensitivematcher _whenMatchesOnDifferentCases_thenCorrect() {int matches = runTest("(?i)狗","这是一只狗");assertTrue(匹配> 0);}

模式。评论

Java API允许其中包含#在正则表达式中的注释。这可以帮助记录复杂的正则表达式,这可能不会立即显而易见到另一个程序员。

注释标志使匹配器忽略正则表达式中的任何空格或注释,只考虑模式。在默认匹配模式下,以下测试将失败:

@Test public void givenregexwithcomments_whenmatchfailswithoutflag_threct () {int matches = runTest("dog$ #check for word dog at end of text", "This is a dog");assertFalse(匹配> 0);}

这是因为匹配器将在输入文本中寻找整个正则表达式,包括空格和#字符。但当我们使用该标志时,它会忽略额外的空格,并且每一行以#开头的文本都会被视为注释,会被忽略:

@test public void给gentregexwithcomments_whenmatcheswithflag_thencorrect(){int matches = runtest(“dog $ #check text text”,“这是一个狗”,pattern.comments);assertTrue(匹配> 0);}

还有一个替代的嵌入式标志表达式:

@Test public void givenregexwithcomments_whenmatcheswiththembeddedflag_threct () {int matches = runTest("(?x)dog$ #check end of text", "This is a dog");assertTrue(匹配> 0);}

模式。DOTALL

默认情况下,当我们使用点"。表达式,我们匹配输入中的每个字符细绳直到我们遇到一个新的行角色。

使用此标志,匹配也将包括行结束符。通过下面的示例,我们将更好地理解。这些例子会有一些不同。因为我们感兴趣的是对匹配的断言细绳,我们将使用匹配器集团返回上一个匹配的方法。

首先,我们将看到默认的行为:

@Test public void givenregexwithlineterminator_whenmatchfails_threct () {Pattern Pattern = Pattern.compile("(.*)");Matcher =模式。匹配器( "this is a text" + System.getProperty("line.separator") + " continued on another line"); matcher.find(); assertEquals("this is a text", matcher.group(1)); }

如我们所见,只匹配行结束符之前的输入的第一部分。

现在在dotall模式下,包括行结束符在内的整个文本将被匹配:

@Test public void givenregexwithlineterminator_whenmatcheswithdotall_threct () {Pattern Pattern = Pattern.compile("(.*)", Pattern. dotall);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)); }

我们还可以使用嵌入的标志表达式来启用dotall模式:

@Test public void givenregexwithlineterminator_whenmatcheswiththembeddeddotall _threct(){模式模式= Pattern.compile("(?s)(.*)");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)); }

模式。文字

在这种模式下,matcher没有为任何元字符、转义字符或正则表达式赋予任何特殊含义。如果没有这个标志,匹配器将对任何输入匹配下面的正则表达式细绳

@Test public void givenregex_whenmatcheswithoutliteralflag_threct () {int matches = runTest("(.*)", "text");assertTrue(匹配> 0);}

这是我们在所有示例中看到的默认行为。但是,使用此标志,不会找到匹配,因为匹配者将寻找(. *)而不是解释它:

@Test public void givenregex_whenmatchfailswithliteralflag_thenrect () {int matches = runTest("(.*)", "text", Pattern.LITERAL);assertFalse(匹配> 0);}

现在,如果我们添加所需的字符串,测试将通过:

@Test public void givenregex_whenmatcheswithliteralflag_thenrect () {int matches = runTest("(.*)", "text(.*)", Pattern.LITERAL);assertTrue(匹配> 0);}

不存在用于启用文本解析的嵌入标志字符。

pattern.multiline.

默认^$元字符在整个输入的开头和末尾绝对匹配细绳.匹配器忽略任何行终止符:

@Test public void givenregex_whenmatchfailswithoutmultilineflag_thenocrect () {int matches = runTest("狗$","这是一只狗" + System.getProperty("line.separator") + "这是一只狐狸");assertFalse(匹配> 0);}

匹配失败,因为匹配器搜索在整个结束细绳但是出现在字符串的第一行的末尾。

但是,有了这个标志,同样的测试也会通过,因为匹配器现在会考虑行终止符。绳子在线终止之前发现,因此成功:

@Test public void givenregex_whenmatcheswithmultilineflag_threct () {int matches = runTest("狗$","这是一只狗" + System.getProperty("line.separator") + "这是一只狐狸",Pattern.MULTILINE);assertTrue(匹配> 0);}

下面是嵌入的标志版本:

@test public void getregex_whenmatcheswithembedded multileinflag_ thencorrect(){int matches = runtest(“(?m)dog $”,“这是一个狗”+ system.getproperty(“line.separator”)+“这是狐狸”);assertTrue(匹配> 0);}

12.匹配类方法

在这一节中,我们将研究一些有用的方法匹配类。为了清晰起见,我们将根据功能对它们进行分组。

12.1。索引方法

索引方法提供了有用的索引值,该值精确地显示在输入中匹配的位置细绳.在以下测试中,我们将确认匹配的开始和结束指数在输入细绳

@Test public void givenmatch_whengetsindices_thcorrect () {Pattern Pattern = Pattern.compile("dog");Matcher =模式。匹配器("This dog is mine"); matcher.find(); assertEquals(5, matcher.start()); assertEquals(8, matcher.end()); }

12.2。研究方法

学习方法要经过输入细绳并返回一个布尔表示是否找到模式。常用是匹配长的方法。

匹配长的方法都尝试根据模式匹配输入序列。区别在于匹配需要整个输入序列匹配,而长的没有。

这两种方法都在输入的开头开始细绳

@Test public void whenstudymethodswork_thcorrect(){模式模式= Pattern.compile(“狗”);Matcher =模式。匹配器("dogs are friendly"); assertTrue(matcher.lookingAt()); assertFalse(matcher.matches()); }

匹配方法将在如下情况下返回true:

@test public void whenmatchesstudymethodworks_thencorrect(){pattern pattern = pattern.compile(“狗”);匹配器匹配器= pattern.matcher(“狗”);asserttrue(matcher.matches());}

12.3。替代的方法

替换方法对于替换输入字符串中的文本很有用。常见的是替换义务replaceAll

替换义务replaceAll方法替换与给定的正则表达式匹配的文本。他们的名字表明,替换义务替换第一个出现项,和replaceAll替换所有出现:

@Test公共void whenreplacefirstworks_thencorrect(){pattern pattern = pattern.compile(“狗”);匹配匹配器= pattern.matcher(“狗是家畜,狗友好”);string newstr = matcher.replacefirst(“cat”);assertequals(“猫是家畜,狗友好”,newstr);}

替换所有出现:

@Test public void whenreplaceallworks_thcorrect(){模式模式= Pattern.compile(“狗”);匹配匹配器= pattern.matcher(“狗是家畜,狗友好”);String newStr = match . replaceall ("cat");assertEquals(“猫是家养动物,猫是友好的”,newStr);}

replaceAll方法允许我们用相同的替换替换所有匹配。如果我们想要根据情况替换匹配,我们需要一个令牌替换技术

13.结论

在本文中,我们学习了如何在Java中使用正则表达式,并探索了正则表达式的最重要特性java.util.regex包裹。

该项目的完整源代码,包括这里使用的所有代码示例,可以在GitHub项目

Java底部

开始使用Spring 5和Spring Boot 2,通过学习的春天课程:

>>看看这个课程
4.评论
最古老的
最新的
内联反馈
查看所有评论
对这篇文章的评论关闭!