Java 正则表达式
1 正则表达式简介
正则表达式可以用字符串来描述规则，并用来匹配字符串。例如，判断手机号，我们用正则表达式 \d{11} ：
boolean isValidMobileNumber(String s) {
return s.matches("\\d{11}");
}
一个正则表达式就是一个描述规则的字符串，所以，只需要编写正确的规则，我们就可以让正则表达式引擎去判断目标字符串是否符合规则。正则表达式是一套标准，它可以用于任何语言。Java标准库的 java.util.regex 包内置了正则表达式引擎，在 Java 程序中使用正则表达式非常简单。
举个例子：要判断用户输入的年份是否是 20## 年，我们先写出规则如下：
一共有4个字符，分别是： 2 ， 0 ， 0~9任意数字 ， 0~9任意数字 。对应的正则表达式就是： 20\d\d ，其中 \d 表示任意一个数字。
把正则表达式转换为Java字符串就变成了 20\\d\\d ，注意Java字符串用 \\ 表示 \ 。
public class Main {
public static void main(String[] args) {
String regex = "20\\d\\d";
System.out.println("2019".matches(regex)); // true
System.out.println("2100".matches(regex)); // false
}
}
使用正则表达式，不必编写复杂的代码来判断，只需给出一个字符串表达的正则规则即可。
2 基本匹配规则
2.1 精确匹配
对于正则表达式 abc 来说，它只能精确地匹配字符串 "abc" ，不能匹配 "ab" ， "Abc" ， "abcd" 等其他任何字符串。
如果正则表达式有特殊字符，那就需要用 \ 转义。例如，正则表达式 a\&c ，其中 \& 是用来匹配特殊字符 & 的，它能精确匹配字符串 "a&c" ，但不能匹配 "ac" 、 "a-c" 、 "a&&c" 等。要注意正则表达式在Java代码中也是一个字符串，所以，对于正则表达式 a\&c 来说，对应的Java字符串是 "a\\&c" ，因为 \ 也是Java字符串的转义字符，两个 \\ 实际上表示的是一个 \
如果想匹配非ASCII字符，例如中文，那就用\u####的十六进制表示，例如：a\u548cc匹配字符串"a和c"，中文字符和的Unicode编码是548c。
2.2 单次匹配
2.2.1 匹配任意字符
大多数情况下，我们想要的匹配规则更多的是模糊匹配。我们可以用.匹配一个任意字符。例如，正则表达式a.c中间的.可以匹配一个任意字符，例如，下面的字符串都可以被匹配：
"abc"，因为.可以匹配字符b；"a&c"，因为.可以匹配字符&；"acc"，因为.可以匹配字符c。
但它不能匹配"ac"、"a&&c"，因为.匹配一个字符且仅限一个字符。
2.2.2 匹配数字
用.可以匹配任意字符，这个口子开得有点大。如果我们只想匹配0~9这样的数字，可以用\d匹配。例如，正则表达式00\d可以匹配：
"007"，因为\d可以匹配字符7；"008"，因为\d可以匹配字符8。
它不能匹配"00A"，"0077"，因为\d仅限单个数字字符。
2.2.3 匹配常用字符
用\w可以匹配一个字母、数字或下划线，w 的意思是 word。例如，java\w 可以匹配：
"javac"，因为\w可以匹配英文字符c；"java9"，因为\w可以匹配数字字符9；。"java_"，因为\w可以匹配下划线_。
它不能匹配"java#"，"java "，因为\w不能匹配#、空格等字符。
2.2.4 匹配空格字符
用\s可以匹配一个空格字符，注意空格字符不但包括空格``，还包括tab字符（在Java中用\t表示）。例如，a\sc可以匹配：
"a c"，因为\s可以匹配空格字符``；"a c"，因为\s可以匹配tab字符\t。
它不能匹配"ac"，"abc"等。
2.2.5 匹配非数字
用\d可以匹配一个数字，而\D则匹配一个非数字。例如，00\D可以匹配：
"00A"，因为\D可以匹配非数字字符A；"00#"，因为\D可以匹配非数字字符#。
00\d可以匹配的字符串"007"，"008"等，00\D是不能匹配的。
类似的，\W可以匹配\w不能匹配的字符，\S可以匹配\s不能匹配的字符，这几个正好是反着来的。
public class Main {
public static void main(String[] args) {
String re1 = "java\\d"; // 对应的正则是java\d
System.out.println("java9".matches(re1)); // true
System.out.println("java10".matches(re1)); // false
System.out.println("javac".matches(re1)); // false
String re2 = "java\\D";
System.out.println("javax".matches(re2)); // true
System.out.println("java#".matches(re2)); // true
System.out.println("java5".matches(re2)); // false
}
}
2.3 重复匹配
修饰符*可以匹配任意个字符，包括0个字符。我们用A\d*可以匹配：
A：因为\d*可以匹配0个数字；A0：因为\d*可以匹配1个数字0；A380：因为\d*可以匹配多个数字380。
修饰符+可以匹配至少一个字符。我们用A\d+可以匹配：
A0：因为\d+可以匹配1个数字0；A380：因为\d+可以匹配多个数字380。
但它无法匹配"A"，因为修饰符+要求至少一个字符。
修饰符?可以匹配0个或一个字符。我们用A\d?可以匹配：
A：因为\d?可以匹配0个数字；A0：因为\d?可以匹配1个数字0。
但它无法匹配"A33"，因为修饰符?超过1个字符就不能匹配了。
如果我们想精确指定n个字符怎么办？用修饰符{n}就可以。A\d{3}可以精确匹配：
A380：因为\d{3}可以匹配3个数字380。
如果我们想指定匹配n~m个字符怎么办？用修饰符{n,m}就可以。A\d{3,5}可以精确匹配：
A380：因为\d{3,5}可以匹配3个数字380；A3800：因为\d{3,5}可以匹配4个数字3800；A38000：因为\d{3,5}可以匹配5个数字38000。
如果没有上限，那么修饰符{n,}就可以匹配至少n个字符。
3 复杂匹配规则
3.1 匹配指定位置
3.1.1 匹配开头和结尾
用正则表达式进行多行匹配时，我们用^表示开头，$表示结尾。例如，^A\d{3}$，可以匹配"A001"、"A380"。
要注意 ^ 和 $ 符号的前后位置。
3.2 匹配指定范围
使用[...]可以匹配范围内的字符，例如，[123456789]可以匹配1~9，这样就可以写出上述电话号码的规则：[123456789]\d{6,7}。
把所有字符全列出来太麻烦，[...]还有一种写法，直接写[1-9]就可以。
要匹配大小写不限的十六进制数，比如1A2b3c，我们可以这样写：[0-9a-fA-F]，它表示一共可以匹配以下任意范围的字符：
0-9：字符0~9；a-f：字符a~f；A-F：字符A~F。
如果要匹配6位十六进制数，前面讲过的{n}仍然可以继续配合使用：[0-9a-fA-F]{6}。
[...]还有一种排除法，即不包含指定范围的字符。假设我们要匹配任意字符，但不包括数字，可以写[^1-9]{3}：
- 可以匹配
"ABC"，因为不包含字符1~9； - 可以匹配
"A00"，因为不包含字符1~9； - 不能匹配
"A01"，因为包含字符1； - 不能匹配
"A05"，因为包含字符5。
3.3 或规则匹配
用|连接的两个正则规则是或规则，例如，AB|CD表示可以匹配AB或CD。
3.4 使用括号
现在我们想要匹配字符串learn java、learn php和learn go怎么办？一个最简单的规则是learn\sjava|learn\sphp|learn\sgo，但是这个规则太复杂了，可以把公共部分提出来，然后用(...)把子规则括起来表示成learn\\s(java|php|go)。
3.5 分组匹配
实际上(...)还有一个重要作用，就是分组匹配。来看一下如何用正则匹配区号-电话号码这个规则。利用前面讲到的匹配规则，写出来很容易：
\d{3,4}\-\d{6,8}
虽然这个正则匹配规则很简单，但是往往匹配成功后，下一步是提取区号和电话号码，分别存入数据库。于是问题来了：如何提取匹配的子串？
当然可以用String提供的indexOf()和substring()这些方法，但它们从正则匹配的字符串中提取子串没有通用性，下一次要提取learn\s(java|php)还得改代码。
正确的方法是用(...)先把要提取的规则分组，把上述正则表达式变为(\d{3,4})\-(\d{6,8})。
现在我们没办法用String.matches()这样简单的判断方法了，必须引入java.util.regex包，用Pattern对象匹配，匹配后获得一个Matcher对象，如果匹配成功，就可以直接从Matcher.group(index)返回子串：
Pattern p = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})");
Matcher m = p.matcher("010-12345678");
if (m.matches()) {
String g1 = m.group(1);
String g2 = m.group(2);
System.out.println(g1);
System.out.println(g2);
} else {
System.out.println("匹配失败!");
}
要特别注意，Matcher.group(index)方法的参数用1表示第一个子串，2表示第二个子串。如果我们传入0会得到什么呢？答案是010-12345678，即整个正则匹配到的字符串。
3.6 Pattern 类
我们在前面的代码中用到的正则表达式代码是String.matches()方法，而我们在分组提取的代码中用的是java.util.regex包里面的Pattern类和Matcher类。实际上这两种代码本质上是一样的，因为String.matches()方法内部调用的就是Pattern和Matcher类的方法。
但是反复使用String.matches()对同一个正则表达式进行多次匹配效率较低，因为每次都会创建出一样的Pattern对象。完全可以先创建出一个Pattern对象，然后反复使用，就可以实现编译一次，多次匹配：
public class Main {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})");
pattern.matcher("010-12345678").matches(); // true
pattern.matcher("021-123456").matches(); // false
pattern.matcher("022#1234567").matches(); // false
// 获得Matcher对象:
Matcher matcher = pattern.matcher("010-12345678");
if (matcher.matches()) {
String whole = matcher.group(0); // "010-12345678", 0表示匹配的整个字符串
String area = matcher.group(1); // "010", 1表示匹配的第1个子串
String tel = matcher.group(2); // "12345678", 2表示匹配的第2个子串
System.out.println(area);
System.out.println(tel);
}
}
}
使用Matcher时，必须首先调用matches()判断是否匹配成功，匹配成功后，才能调用group()提取子串。
获取 xx:xx:xx 的时分秒的正则表达式：
"([0-1]\\d|2[0-3]):([0-5]\\d):([0-5]\\d)"
4 非贪婪匹配
当我们的正则表达式不止一组（括号划分）匹配的时候，位于左侧的正则表达式会尽可能多地匹配字符，如果想让左侧的正则表达式尽可能少的匹配，我们只需要使用 ? 修饰即可。
我们再来这个正则表达式(\d??)(9*)，注意\d?表示匹配0个或1个数字，后面第二个?表示非贪婪匹配，因此，给定字符串"9999"，匹配到的两个子串分别是""和"9999"，因为对于\d?来说，可以匹配1个9，也可以匹配0个9，但是因为后面的?表示非贪婪匹配，它就会尽可能少的匹配，结果是匹配了0个9。
5 搜索和替换
5.1 分割字符串
使用正则表达式分割字符串可以实现更加灵活的功能。String.split()方法传入的正是正则表达式。我们来看下面的代码：
"a b c".split("\\s"); // { "a", "b", "c" }
"a b c".split("\\s"); // { "a", "b", "", "c" }
"a, b ;; c".split("[\\,\\;\\s]+"); // { "a", "b", "c" }
如果我们想让用户输入一组标签，然后把标签提取出来，因为用户的输入往往是不规范的，这时，使用合适的正则表达式，就可以消除多个空格、混合,和;这些不规范的输入，直接提取出规范的字符串。
5.2 搜索字符串
使用正则表达式还可以搜索字符串，我们来看例子：
public class Main {
public static void main(String[] args) {
String s = "the quick brown fox jumps over the lazy dog.";
Pattern p = Pattern.compile("\\wo\\w");
Matcher m = p.matcher(s);
while (m.find()) {
String sub = s.substring(m.start(), m.end());
System.out.println(sub);
}
}
}
我们获取到Matcher对象后，不需要调用matches()方法（因为匹配整个串肯定返回false），而是反复调用find()方法，在整个串中搜索能匹配上\\wo\\w规则的子串，并打印出来。这种方式比String.indexOf()要灵活得多，因为我们搜索的规则是3个字符：中间必须是o，前后两个必须是字符[A-Za-z0-9_]。
5.3 替换字符串
使用正则表达式替换字符串可以直接调用String.replaceAll()，它的第一个参数是正则表达式，第二个参数是待替换的字符串。我们还是来看例子：
public class Main {
public static void main(String[] args) {
String s = "The quick\t\t brown fox jumps over the lazy dog.";
String r = s.replaceAll("\\s+", " ");
System.out.println(r); // "The quick brown fox jumps over the lazy dog."
}
}
上面的代码把不规范的连续空格分隔的句子变成了规范的句子。可见，灵活使用正则表达式可以大大降低代码量。
5.4 反向引用
如果我们要把搜索到的指定字符串按规则替换，比如前后各加一个<b>xxxx</b>，这个时候，使用replaceAll()的时候，我们传入的第二个参数可以使用$1、$2来反向引用匹配到的子串。例如：
public class Main {
public static void main(String[] args) {
String s = "the quick brown fox jumps over the lazy dog.";
String r = s.replaceAll("\\s([a-z]{4})\\s", " <b>$1</b> ");
System.out.println(r);
}
}
上述代码的运行结果是：
the quick brown fox jumps <b>over</b> the <b>lazy</b> dog.
它实际上把任何4字符单词的前后用<b>xxxx</b>括起来。实现替换的关键就在于" <b>$1</b> "，它用匹配的分组子串([a-z]{4})替换了$1。
