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