设为 “星标”,带你了解技术圈内新鲜事!
01初来乍到
欢迎来到正则表达式的国度,勇士!这里的每一个人都使用正则表达式,我是这里的 NPC,每一个来到这里的人都将由我代为介绍正则世界的规则,至于能领悟到何种境界,就看你的造化了。祝你好运,勇士!
啊,好的,正则表达式......有点奇怪的名字,它是什么呢?
什么?你还没有听过正则表达式,真是一个莽撞的小伙子。看来你也和外面世界的人一样,每次只有用到 字符串匹配 时,才会通过「谷鸽」来我们的国度寻找答案。一群知其然不知其所以然的家伙。
说着,NPC 身前浮现出几个鎏金大字:正则表达式用来匹配一系列符合某个规则的字符串的表达式正则的意思是正规、规则。正则表达式的英文名是 Regular Expression,可以直译为描述某种规则的表达式,一般缩写为 regex。
02牛刀小试我先来考考你吧:你如何判断一个字符串是不是有效的电话号码?这可是一个非常常见的需求。
没问题,我以前确实写过一份类似的代码。首先判断字符串是否是 11 位,再判断每一位是否都是数字就可以了。
好了好了,快把你这份代码藏好,这份代码放到我们正则的国度是会被笑掉大牙的。看看我们国度的人是怎么实现这份需求的吧! 啊?如此简洁的实现,正则强者竟恐怖如斯! 这可不是什么强者写的代码,充其量算是牛刀小试罢了。 我先给你讲讲正则表达式的精确匹配。一个普通的字符串,比如 这好像没什么用,需要精确匹配的话,我们可以用 没错,正则表达式的精确匹配很少用到。我只是在给你介绍正则表达式的一条基本规则而已。 如果需要匹配的字符串含有特殊字符,那就需要用 这么说来,这两个反斜杠的意义竟然还不一样:一个是正则的转义,一个是 Java 字符串的转义。那么我们之前那个匹配电话号码的例子里面, 不错不错,算你还有点悟性。 那么, 不能, 那我要怎么才能匹配多个数字呢? 你可以写多次,比如 那我如果要匹配 10000 个数字呢?总不能写一万次吧? 那就像我们刚才匹配电话号码的例子一样,在 原来如此,现在我能完全看懂刚才写的匹配电话号码的例子了! 趁热打铁,如果要匹配 n ~ m 次,用 按照这个写法,如果要匹配最多 刚夸了你有点悟性又被你蠢哭了,最多 m 次需要这么写吗?直接用 啊,原来如此,我想多了。 正则的基础规则中,除了 空格键打出来的空格 Tab 键打出来的空格 回车键打出来的空格 Tab 键打出来的空格和回车键打出来的空格?是指 完全正确。 我明白了,我来测试一下。 非常棒,我的勇士!希望这三个基本规则还不至于让你记昏了头。不过请放心,没有其他字母需要记忆了,只有这三个而已。 记住上面三个规则之后,你还可以顺带获得几个新的规则。因为正则国度规定:将字母换成大写,就表示相反的意思。用 哈,设计者真是太机智了,大大减少了我这种新手的学习成本。 是的,这非常好记。类似地, 有时候,我们对某些位置的字符没有要求,仅需要占个位置即可。这时候我们就可以用 那是不是也可以理解为: 是的,可以这么理解。还记得之前说的 我有疑问,为什么第三个表达式也会输出 true 呢?明明没有出现数字啊? 那意味着出现了 0 次, 我感觉比较常见的需求应该是某个字符至少出现一次吧? 那就可以用 哈哈,看来设计者也发现了这个需求更常用。平时 这倒没人统计过,在我们正则的国度,常常是一个场景一个正则,不存在谁比谁更常用的对比,按照实际场景使用就行了。 还有一种场景,如果某个字符要么匹配 0 次,要么匹配 1 次,我们就可以用 我感觉我已经掌握了够多的匹配规则,足以应付所有的字符串匹配场景了! 是的,你已经掌握了足够多的规则,勇士。可先别得意得太早,我再考考你吧。看看匹配电话号码的程序,如果我们规定电话号码不能以 不能以 刚刚谁还说「我已经掌握了足够多的匹配规则,足以应付所有的字符串匹配场景了!」 呃,还差一点......快别取笑我了,快告诉我这个要用什么新的规则吧! 年轻人啊,总是心浮气躁,这样的场景需要用 啊哈,那我就知道怎么写了, 这个问题的正则匹配规则是 就是这样。这里还有一个语法糖, 只能用于数字吗?可以用在字母身上吗? 当然可以,比如 但如果既可以是数字 1~9,又可以是字母 a~g,还可以是字母 U~Z,还是得把所有范围列出来。 不必,你还可以这么写: 这可真是太方便了!如果是 0~1,8~9 可以这样组合吗? 那样的话,你写 我想学习(装 X)。 那当然也是可以的, 还有一种写法可以实现这一点,那就是用 所以说范围就是 不对, 如果我想排除某些字符呢?比如这个位置不能是 原来如此,我懂了。现在还有什么规则我没有学到的吗? 新手教程到这里就结束了,这已经足够你应付许多应用场景了。但我这还有两本高手秘籍,你想不想学呢? 高手秘籍!听着都让人激动啊,快讲讲! 这第一本秘籍的名字叫 Name:Aurora Age:18 其中还夹杂着一些无关紧要的数据 Name:Bob Age:20 错误的数据有着各种各样错误的格式 Name:Cassin Age:22 ... 没问题,这已经难不倒我了。让我想想......观察字符串的规则,只需要用 很好!一般来说,下一步你要做的就是取出这些表达式中的姓名和年龄,以便把它们存到数据库中。 那我可以用 的确可行,但你现在不需要那个蠢办法了,我的勇士。你已经掌握了正则的力量,在我们正则国度有更简洁的取值方式。 看吧,只要用 你可以看到我用 这里是不是写错了,为什么 group 是从下标 1 开始取值的,计算机不都从 0 开始数吗? 并没有写错,这是因为 group(0) 被用来保存整个匹配的字符串了。 原来是这样,分组可真是太方便了。但我们之前都是用的 想知道这个问题的答案的话,我们不妨来看一下 源码中调用了 啊,我明白了!原来 Pattern 并不是什么新鲜东西, 没错,并且阅读源码之后,你可以发现,每次调用 我这第二本秘籍名为 你还别说,我之前真遇到过这个问题。结果用户的输入五花八门,有用逗号的,有用分号的,有用空格的,还有用制表符的...... 二分,回溯,递归,分治 搜索;查找;旋转;遍历 数论 图论 逻辑 概率 那你是怎么解决的呢? 用 输出为: 暴殄天物啊!你这种行为就好比拿着精心打磨的钻石当电钻头,这样的代码在我们正则王国是会遭人唾骂的。 当然是,但 split 函数可不是你这样用的,不知你是否看过 split 函数的源码,这个函数传入的参数实际上是一个正则表达式。 啊?但我之前没写过正则表达式,分割出来也没出错啊! 当然,你忘了我最开始给你讲的了吗?你直接使用字符串,在正则王国属于精确匹配,只能匹配你写死的那个字符串。 原来如此。那么我应该怎么做呢? 当然是用正则表达式模糊匹配,只要能匹配成功,就以其分割。 输出为: 原来 split 函数这么强大,我以后不会犯这种错误了! 字符串中,可不止这一个函数是传入的正则表达式,你还记得替换所有匹配字符串用的什么函数吗? 用的是 replaceAll 函数,这个函数不会也是传的正则表达式吧! 正是这样,所以我们可以用正则表达式模糊匹配,将符合规则的字符串全部替换掉。比如就现在这个例子,我们可以把用户输入的所有数据统一规范为使用 输出为: 果然是 还不止这一点,在 replaceAll 的第二个参数中,我们可以通过 输出为: 哈,有时候我们不需要替换,只需要将正则匹配出来的部分添加一些前缀或后缀,就可以用这种方式! 完全正确。 恭喜你学完了所有的正则教程,现在你知道正则表达式是什么了吧。 没错,以前总感觉正则表达式晦涩难懂,每次用到时就去网上搜索答案,现在看来也不过如此。 说 什么?还有学问?我感觉我已经学完了啊!还有什么学问,一并给我讲了吧! 那你看这样一道题:给你一些字符串,统计其末尾 LeetCode LeetCodeeee LeetCodeee 看起来并不难,用 你运行一下试试看。 怎么会这样?我期望的结果是 group1 等于 LeetCod,group2 等于 e 才对啊! 这是因为 e 仍然属于 贪婪匹配,听起来和贪心算法有异曲同工之妙。 没错,贪婪匹配和贪心算法原理是一致的。与之对应的匹配方式叫做 那么,我要怎样指定匹配方式为非贪婪匹配呢? 也很简单,在需要非贪婪匹配的正则表达式后面加个 运行程序,输出如下: 这里也用的是 不会混淆的,你仔细想一想就能明白了,如果只有一个字符,那就不存在贪婪不贪婪的问题,如果匹配多次,那么表示非贪婪匹配的 最后一个问题,为什么这里没有匹配成 group1 等于 L,group2 等于 ee...... 哦我明白了,如果这样匹配的话,字符串 就是这个原理,看来你是真的完全明白了。 天下没有不散的宴席,是时候说再见了。虽然我能教你的,或是说想与你探讨的,还不止这些内容,但授人以鱼不如授人以渔,以后遇到正则相关的问题,还是要靠你自己动脑思考。 这么快就要告别了吗?不知道为什么,竟然还有点舍不得...... 我最后再出一道题考考你,你就可以从正则王国顺利毕业了。来看下你的题目吧:我们王国有一个人口吃,请你帮忙矫正他。他今天说:肚...子。。好饿........,....早知道.....当.....初...。。。多.....刷.....点。。。力.....扣了.........! ez,只需要用 str.replaceAll(__, __) 就可以解决了!public static boolean isValidPhoneNumber(String number) {
// 判断是否是 11 位
if (number.length() != 11) return false;
// 判断每一位是否全为数字
for (int i = 0; i
if (number.charAt(i) <&#39;0&#39; || number.charAt(i) > &#39;9&#39;) return false;
}
return true;
}
public static boolean isValidPhoneNumber(String number) {
return number.matches("\\d{11}");
}
abc
&#xff0c;它如果用来做正则表达式匹配的话&#xff0c;只能匹配自己。也就是说它只能匹配字符串 abc
&#xff0c;不能匹配 ab
&#xff0c;Abc
等其他任何字符串。System.out.println("abc".matches("abc")); // 输出为 true
System.out.println("ab".matches("abc")); // 输出为 false
System.out.println("Abc".matches("abc")); // 输出为 false
String.equals()
函数&#xff0c;不需要用正则吧&#xff1f;\
转义。比如 a&b
&#xff0c;在用正则表达式匹配时&#xff0c;需要使用 a\&b
&#xff0c;又由于在 Java 字符串中&#xff0c;\
也是特殊字符&#xff0c;它也需要转义&#xff0c;所以 a\&b
对应的 Java 字符串是 a\\&b
&#xff0c;它是用来匹配 a&b
的。System.out.println("a&b".matches("a\\&b")); // 输出为 true
\\d
的本意也是 \d
吗&#xff1f;\d
在正则表达式中表示匹配任意数字&#xff0c;d 是 digital 的简写。比如 00\d
就可以匹配 000
&#xff0c; 007
&#xff0c;008
等等。00\d
可以匹配 0066
吗&#xff1f;\d
只能匹配单个数字。\d\d
就能匹配两个数字&#xff0c;\d\d\d
能匹配三个数字&#xff0c;需要匹配几个数字就写几次就行了。System.out.println("1".matches("\\d\\d")); // 输出为 false
System.out.println("11".matches("\\d\\d")); // 输出为 true
System.out.println("111".matches("\\d\\d")); // 输出为 false
\d
后面打上花括号 {}
&#xff0c;{n}
表示匹配 n 次。\d{10000}
就表示匹配 10000 个数字。{n,m}
即可&#xff0c;如果要匹配至少 n
次&#xff0c;用 {n,}
即可。需要注意 ,
后不能有空格。System.out.println("1".matches("\\d{1,2}")); // 输出为 true
System.out.println("12".matches("\\d{1,2}")); // 输出为 true
System.out.println("123".matches("\\d{1,2}")); // 输出为 false
System.out.println("123".matches("\\d{2,}")); // 输出为 true
m
次&#xff0c;是不是用 {,m}
&#xff1f;{0,m}
不就行了吗&#xff1f;只是因为正无穷不好表示我们才用的 {n,}
&#xff0c;在正则国度根本没有 {,m}
这样的写法。04小有所成
\d
&#xff0c;还有 \w
和\s
&#xff0c;w 是 word 的简写&#xff0c;表示匹配一个常用字符&#xff0c;包括字母、数字、下划线。s 是 space 的简写&#xff0c;表示匹配一个空格&#xff0c;包括三种&#xff1a;\t
和 \n
吗&#xff1f;System.out.println("LeetCode_666".matches("\\w{12}")); // 输出为 true
System.out.println("\t \n".matches("\\s{3}")); // 输出为 true
System.out.println("Leet\tCode 666".matches("\\w{4}\\s\\w{4}\\s\\d{3}")); // 输出为 true
\d
你可以匹配一个数字&#xff0c;\D
则表示匹配一个非数字。System.out.println("a".matches("\\d")); // 输出为 false
System.out.println("1".matches("\\d")); // 输出为 true
System.out.println("a".matches("\\D")); // 输出为 true
System.out.println("1".matches("\\D")); // 输出为 false
\W
可以匹配 \w
不能匹配的字符&#xff0c;\S
可以匹配 \s
不能匹配的字符。.
字符。System.out.println("a0b".matches("a.b")); // 输出为 true
System.out.println("a_b".matches("a.b")); // 输出为 true
System.out.println("a b".matches("a.b")); // 输出为 true
.
可以匹配任意字符。{n}
表示匹配 n
次吗&#xff1f;有时候&#xff0c;我们对匹配的次数没有要求&#xff0c;匹配任意次均可&#xff0c;这时&#xff0c;我们就可以用 *
字符。System.out.println("1".matches("\\d*")); // 输出为 true
System.out.println("123".matches("\\d*")); // 输出为 true
System.out.println("".matches("\\d*")); // 输出为 true
*
是指 可以匹配任意次&#xff0c;包括 0 次。也就是说&#xff0c;*
等价于 {0,}
&#43;
匹配&#xff0c;&#43;
表示 至少匹配一次。它等价于 {1,}
System.out.println("1".matches("\\d&#43;")); // 输出为 true
System.out.println("123".matches("\\d&#43;")); // 输出为 true
System.out.println("".matches("\\d&#43;")); // 输出为 false
&#43;
号比 *
号用得多吧&#xff01;?
匹配。它等价于 {0,1}
System.out.println("".matches("\\d?")); // 输出为 true
System.out.println("1".matches("\\d?")); // 输出为 true
System.out.println("123".matches("\\d?")); // 输出为 false
.
匹配任意字符&#xff1b;*
匹配任意次&#xff0c;包括 0 次&#xff1b;&#43;
号匹配至少 1 次&#xff0c;?
匹配 0 次或 1 次。我记住了&#xff01;07心浮气躁
0
开头&#xff0c;应该怎么写正则表达式呢&#xff1f;0
开头&#xff0c;那就不能用 \d{11}
了&#xff0c;这......[]
来匹配&#xff0c;[]
用于匹配指定范围内的字符&#xff0c;比如[123456789]
可以匹配 1~9。[123456789]\d{10}
。[123456789]
写起来太麻烦&#xff0c;可以写作 [1-9]
。[a-g]
表示 [abcdefg]
&#xff0c;[U-Z]
表示 [UVWXYZ]
。[1-9a-gU-Z]
。System.out.println("1".matches("[1-9a-gU-Z]")); // 输出为 true
System.out.println("b".matches("[1-9a-gU-Z]")); // 输出为 true
System.out.println("X".matches("[1-9a-gU-Z]")); // 输出为 true
System.out.println("A".matches("[1-9a-gU-Z]")); // 输出为 false
[0189]
不是更简洁吗&#xff1f;[0-18-9]
正是你想要的。由于正则一次只匹配一个字符&#xff0c;所以这样写并不会有歧义&#xff0c;也就是说计算机不会把这种写法误解成要匹配 0~18 之类的。System.out.println("1".matches("[0-18-9]")); // 输出为 true
System.out.println("5".matches("[0-18-9]")); // 输出为 false
或
运算符&#xff0c;正则的 或
运算符是 |
&#xff0c;[0189]
也可以写作 0|1|8|9
。System.out.println("1".matches("0|1|8|9")); // 输出为 true
System.out.println("5".matches("0|1|8|9")); // 输出为 false
或
的简写&#xff0c;对吗&#xff1f;或
可以实现更多的功能&#xff0c;它并不局限于单个字符。System.out.println("abc".matches("abc|ABC")); // 输出为 true
System.out.println("ABC".matches("abc|ABC")); // 输出为 true
System.out.println("123".matches("abc|ABC")); // 输出为 false
[123]
。我记得你之前说正则王国以大写表示取反&#xff0c;[]
要怎么大写呢&#xff1f;[]
可没有大写之说&#xff0c;[]
取反的方式是&#xff1a;[^]
&#xff0c;比如不能是 [123]
的表示方法为 [^123]
或者 [^1-3]
08探囊取物
探囊取物
。考虑一个实际需求&#xff0c;有许许多多以下格式的字符串&#xff0c;你需要用正则表达式匹配出其姓名和年龄。Name:\w&#43;\s*Age:\d{1,3}
就能匹配了。System.out.println("Name:Aurora Age:18".matches("Name:\\w&#43;\\s*Age:\\d{1,3}")); // 输出为 true
System.out.println("其中还夹杂着一些无关紧要的数据".matches("Name:\\w&#43;\\s*Age:\\d{1,3}")); // 输出为 false
System.out.println("Name:Bob Age:20".matches("Name:\\w&#43;\\s*Age:\\d{1,3}")); // 输出为 true
System.out.println("错误的数据有着各种各样错误的格式".matches("Name:\\w&#43;\\s*Age:\\d{1,3}")); // 输出为 false
System.out.println("Name:Cassin Age:22".matches("Name:\\w&#43;\\s*Age:\\d{1,3}")); // 输出为 true
indexOf
和 subString
函数来取这些值。Pattern pattern &#61; Pattern.compile("Name:(\\w&#43;)\\s*Age:(\\d{1,3})");
Matcher matcher &#61; pattern.matcher("Name:Aurora Age:18");
if(matcher.matches()) {
String group1 &#61; matcher.group(1);
String group2 &#61; matcher.group(2);
System.out.println(group1); // 输出为 Aurora
System.out.println(group2); // 输出为 18
}
()
将需要取值的地方括起来&#xff0c;传给 Pattern 对象&#xff0c;再用 Pattern 对象匹配后获得的 Matcher 对象来取值就行了。每个匹配的值将会按照顺序保存在 Matcher 对象的 group 中。()
把 \\w&#43;
和 \\d{1,3}
分别括起来了&#xff0c;判断 Pattern 对象与字符串是否匹配的方法是 Matcher.matches()
&#xff0c;如果匹配成功&#xff0c;这个函数将返回 true&#xff0c;如果匹配失败&#xff0c;则返回 false。System.out.println(matcher.group(0)); // 输出为 Name:Aurora Age:18
String.matches
方法来匹配的正则表达式&#xff0c;这里用的 Pattern 又是什么呢&#xff1f;String.matches
方法的源码。public boolean matches(String regex) {
return Pattern.matches(regex, this);
}
Pattern.matches
方法&#xff0c;我们再跟进去。public static boolean matches(String regex, CharSequence input) {
Pattern p &#61; Pattern.compile(regex);
Matcher m &#61; p.matcher(input);
return m.matches();
}
String.matches
内部就是调用的 Pattern&#xff0c;两种写法的原理是一模一样的&#xff01;String.matches
函数&#xff0c;都会新建出一个 Pattern 对象。所以如果要用同一个正则表达式多次匹配字符串的话&#xff0c;最佳的做法不是直接调用 String.matches
方法&#xff0c;而应该先用正则表达式新建一个 Pattern 对象&#xff0c;然后反复使用&#xff0c;以提高程序运行效率。
09移花接木// 错误的做法&#xff0c;每次都会新建一个 Pattern&#xff0c;效率低
boolean result1 &#61; "Name:Aurora Age:18".matches("Name:(\\w&#43;)\\s*Age:
(\\d{1,3})");
boolean result2 &#61; "Name:Bob Age:20".matches("Name:(\\w&#43;)\\s*Age:
(\\d{1,3})");
boolean result3 &#61; "Name:Cassin Age:22".matches("Name:(\\w&#43;)\\s*Age:
(\\d{1,3})");
// 正确的做法&#xff0c;复用同一个 Pattern&#xff0c;效率高
Pattern pattern &#61; Pattern.compile("Name:(\\w&#43;)\\s*Age:(\\d{1,3})");
boolean result4 &#61; pattern.matcher("Name:Aurora Age:18").matches();
boolean result5 &#61; pattern.matcher("Name:Bob Age:20").matches();
boolean result6 &#61; pattern.matcher("Name:Cassin Age:22").matches();
移花接木
。再考虑一个实际场景&#xff1a;你有一个让用户输入标签的输入框&#xff0c;用户可以输入多个标签。可是你并没有提示用户&#xff0c;标签之前用什么间隔符号隔开。String.split
函数呗&#xff0c;这个函数我已经用得很熟练了。将各种分隔符号依次传入尝试&#xff0c;最后总算是解决了。public static String[] splitTabs(String tabs) {
if(tabs.split(",").length &#61;&#61; 4) return tabs.split(",");
if(tabs.split(";").length &#61;&#61; 4) return tabs.split(";");
if(tabs.split(" ").length &#61;&#61; 4) return tabs.split(" ");
return new String[0];
}
public static void main(final String[] args){
System.out.println(Arrays.toString(splitTabs("二分,回溯,递归,分治")));
System.out.println(Arrays.toString(splitTabs("搜索;查找;旋转;遍历")));
System.out.println(Arrays.toString(splitTabs("数论 图论 逻辑 概率")));
}
[二分, 回溯, 递归, 分治]
[搜索, 查找, 旋转, 遍历]
[数论, 图论, 逻辑, 概率]
String.split
函数不就是用来分割字符串的吗&#xff1f;System.out.println(Arrays.toString("二分,回溯,递归,分治".split("[,;\\s]
&#43;")));
System.out.println(Arrays.toString("搜索;查找;旋转;遍历".split("[,;\\s]
&#43;")));
System.out.println(Arrays.toString("数论 图论 逻辑 概率".split("[,;\\s]
&#43;")));
[二分, 回溯, 递归, 分治]
[搜索, 查找, 旋转, 遍历]
[数论, 图论, 逻辑, 概率]
;
分隔&#xff0c;那我们就可以这样写。System.out.println("二分,回溯,递归,分治".replaceAll("[,;\\s]&#43;", ";"));
System.out.println("搜索;查找;旋转;遍历".replaceAll("[,;\\s]&#43;", ";"));
System.out.println("数论 图论 逻辑 概率".replaceAll("[,;\\s]&#43;", ";"));
二分;回溯;递归;分治
搜索;查找;旋转;遍历
数论;图论;逻辑;概率
移花接木
&#xff0c;模糊匹配比精确匹配效率高多了&#xff01;$1
&#xff0c;$2
&#xff0c;...来反向引用匹配到的子串。只要将需要引用的部分用 ()
括起来就可以了。System.out.println("二分,回溯,递归,分治".replaceAll("([,;\\s]&#43;)", "---$1---"));
System.out.println("搜索;查找;旋转;遍历".replaceAll("([,;\\s]&#43;)", "---$1---"));
System.out.println("数论 图论 逻辑 概率".replaceAll("([,;\\s]&#43;)", "---$1---"));
二分---,---回溯---,---递归---,---分治
搜索---;---查找---;---旋转---;---遍历
数论--- ---图论--- ---逻辑--- ---概率
不过如此
倒是有些托大了&#xff0c;虽然我给你介绍了正则表达式的基本规则&#xff0c;但正则表达式里面还有不少的学问可以去挖掘的。每种技术都有一个熟能生巧的过程。e
的个数(\w&#43;)(e*)
匹配&#xff0c;再取 group(2) 判断即可。Pattern pattern &#61; Pattern.compile("(\\w&#43;)(e*)");
Matcher matcher &#61; pattern.matcher("LeetCode");
if (matcher.matches()) {
String group1 &#61; matcher.group(1);
String group2 &#61; matcher.group(2);
System.out.println("group1 &#61; " &#43; group1 &#43; ", length &#61; " &#43; group1.length());
System.out.println("group2 &#61; " &#43; group2 &#43; ", length &#61; " &#43; group2.length());
}
group1 &#61; LeetCode, length &#61; 8
group2 &#61; , length &#61; 0
\w
能匹配的范畴&#xff0c;正则表达式默认会尽可能多地向后匹配&#xff0c;我们王国将其称之为 贪婪匹配
。非贪婪匹配
&#xff0c;非贪婪匹配
会在能匹配目标字符串的前提下&#xff0c;尽可能少的向后匹配。?
即可表示非贪婪匹配。Pattern pattern &#61; Pattern.compile("(\\w&#43;?)(e*)");
Matcher matcher &#61; pattern.matcher("LeetCode");
if (matcher.matches()) {
String group1 &#61; matcher.group(1);
String group2 &#61; matcher.group(2);
System.out.println("group1 &#61; " &#43; group1 &#43; ", length &#61; " &#43; group1.length());
System.out.println("group2 &#61; " &#43; group2 &#43; ", length &#61; " &#43; group2.length());
}
group1 &#61; LeetCod, length &#61; 7
group2 &#61; e, length &#61; 1
?
&#xff0c;我记得之前 ?
表示的是匹配 0 次或者 1 次&#xff0c;两个符号不会混淆吗&#xff1f;?
前面必有一个标志匹配次数的符号。所以不会出现混淆。LeetCode
就无法和正则表达式匹配起来。怪不得非贪婪匹配的定义是 在能匹配目标字符串的前提下
&#xff0c;尽可能少的向后匹配。互动话题&#xff1a;嘿&#xff0c;说你呢&#xff01;在留言区写下你的答案吧&#xff01;
本文作者&#xff1a;Alpinist Wang编辑&版式&#xff1a;霍霍声明&#xff1a;本文归 “力扣” 版权所有&#xff0c;如需转载请联系。