Pattern类
静态方法compile获取Pattern对象
```java
Pattern pattern = Pattern.compile("正则表达式");
```
pattern方法获取被编译后的正则表达式
```java
Pattern pattern = Pattern.compile("正则表达式");
String string = pattern.pattern();
```
静态方法matches校验给定串是否匹配给定正则表达式
```java
boolean matches = Pattern.matches("[a-z]", "a");
```
split方法根据给定正则表达式分割给定串
```java
Pattern pattern = Pattern.compile(",");
String[] split = pattern.split("a,b,c,d,e,f,g");
```
matcher方法获取一个匹配器
```java
Pattern pattern = Pattern.compile("\\.");
Matcher matcher = pattern.matcher("a.b.c");
```
### 分组
> 通过从左至右计算其开括号来编号
( (A) (B (C) ) )
分组0：`( (A) (B (C) ) )`[默认分组(特殊的组)]总是代表整个表达式
分组1：`( (A) (B (C) ) )`
分组2：`(A)`
分组3：` (B (C) )`
分组4：`(C)`
```java
Matcher matcher = pattern.matcher("a.b.c");
matcher.groupCount() // 获取分组的数量
```
### 正则表达式语法
| 字符 | 说明 |
| :--: | :--------------------------: |
| \ | 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。 |
例如：普通的`"n"`只会匹配到字符`"n"`，但是加了`\`字符后，`\n`表示匹配换行符。
在Java的String串中，`\`表示转移，所以想表达出正则表达式中的`\`，需要用两个`\`才行，比如：`\\`表示一个`\`符号。想要表示一个普通的反斜杠需要用`\\\\`，原因是，`\\`表示一个`\`，两个`\\`表示一个`\\`，而`\\`在正则表达式中表示一个`\`符号。
| 字符 | 说明 |
| :--: | :-----------: |
| ^ | 匹配输入字符串开始的位置。 |
| $ | 匹配输入字符串结尾的位置。 |
如果设置了 **RegExp** 对象的 **Multiline** 属性， ^ 和 $ 还会与"\n"或"\r"之前的位置匹配。
| 字符 | 说明 |
| :--: | :---------------------------: |
| * | 零次或多次匹配前面的字符或子表达式。 等效于 {0,}。 |
| + | 一次或多次匹配前面的字符或子表达式。 等效于 {1,}。 |
| ? | 零次或一次匹配前面的字符或子表达式。 等效于 {0,1}。 |
| 字符 | 说明 |
| :-------: | :------------------: |
| {*n*} | 正好匹配 *n* 次。 |
| {*n*,} | 至少匹配 *n *次。 |
| {*n*,*m*} | 匹配至少 *n* 次，至多 *m* 次。 |
| 字符 | 说明 |
| :--: | :--------------------------------------: |
| ? | 当此字符紧随任何其他限定符（*、+、?、{*n*}、{*n*,}、{*n*,*m*}）之后时，匹配模式是"非贪心的"。 |
"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"。
| 字符 | 说明 |
| :--: | :-----------------: |
| . | 匹配除"\r\n"之外的任何单个字符。 |
若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。
| 字符 | 说明 |
| :---------: | :-----------------------: |
| (*pattern*) | 匹配 *pattern* 并捕获该匹配的子表达式。 |
可以使用 \$0…\$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用"\\("或者"\\)"。
| 字符 | 说明 |
| :-----------: | :------------------------------------: |
| (?:*pattern*) | 匹配 *pattern* 但不捕获该匹配的子表达式，不存储供以后使用的匹配。 |
这对于用"or"字符 (|) 组合模式部件的情况很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。
| 字符 | 说明 |
| :-----------: | :--------------------------------------: |
| (?=*pattern*) | 执行正向预测先行搜索的子表达式，表达式处于匹配 *pattern* 的字符串的起始点的字符串。 |
它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
| 字符 | 说明 |
| :-----------: | :--------------------------------: |
| (?!*pattern*) | 执行反向预测先行搜索的子表达式。与(?=*pattern*)做对比。 |
它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows"，但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
| 字符 | 说明 |
| :------: | :-----------: |
| *x*\|*y* | 匹配 *x* 或 *y*。 |
例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。
| 字符 | 说明 |
| :-----: | :--: |
| [*xyz*] | 字符集。 |
匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。
| 字符 | 说明 |
| :------: | :----: |
| [^*xyz*] | 反向字符集。 |
匹配未包含的任何字符。
| 字符 | 说明 |
| :-----: | :---: |
| [*a-z*] | 字符范围。 |
匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。
| 字符 | 说明 |
| :------: | :-----: |
| [^*a-z*] | 反向字符范围。 |
匹配不在指定的范围内的任何字符。
| 字符 | 说明 |
| :--: | :----------------: |
| \b | 匹配一个字边界，即字与空格间的位置。 |
例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
| 字符 | 说明 |
| :--: | :-----: |
| \B | 非字边界匹配。 |
"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。
| 字符 | 说明 |
| :---: | :-------------: |
| \c*x* | 匹配 *x* 指示的控制字符。 |
例如，\cM 匹配 Control-M 或回车符。*x* 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身。
| 字符 | 说明 |
| :--: | :-----: |
| \d | 数字字符匹配。 |
等效于 [0-9]。
| 字符 | 说明 |
| :--: | :------: |
| \D | 非数字字符匹配。 |
等效于 \[^0-9]。
| 字符 | 说明 |
| :--: | :----: |
| \f | 换页符匹配。 |
等效于 \x0c 和 \cL。
| 字符 | 说明 |
| :--: | :----: |
| \n | 换行符匹配。 |
等效于 \x0a 和 \cJ。
| 字符 | 说明 |
| :--: | :------: |
| \r | 匹配一个回车符。 |
等效于 \x0d 和 \cM。
| 字符 | 说明 |
| :--: | :---------------------: |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等。 |
与 [ \f\n\r\t\v] 等效。
| 字符 | 说明 |
| :--: | :--------: |
| \S | 匹配任何非空白字符。 |
与\[^ \f\n\r\t\v] 等效。
| 字符 | 说明 |
| :--: | :----: |
| \t | 制表符匹配。 |
与 \x09 和 \cI 等效。
| 字符 | 说明 |
| :--: | :------: |
| \v | 垂直制表符匹配。 |
与 \x0b 和 \cK 等效。
| 字符 | 说明 |
| :--: | :-------------: |
| \w | 匹配任何字类字符，包括下划线。 |
与"[A-Za-z0-9_]"等效。
| 字符 | 说明 |
| :--: | :---------: |
| \W | 与任何非单词字符匹配。 |
与\[^A-Za-z0-9_]"等效。
| 字符 | 说明 |
| :---: | :------------------------: |
| \x*n* | 匹配 *n*，此处的 *n* 是一个十六进制转义码。 |
十六进制转义码必须正好是两位数长。例如，"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。
| 字符 | 说明 |
| :--: | :------------------------: |
| \num | 匹配 *num*，此处的 *num* 是一个正整数。 |
到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。
| 字符 | 说明 |
| :--: | :--------------: |
| \n | 标识一个八进制转义码或反向引用。 |
如果 \n 前面至少有 *n* 个捕获子表达式，那么 *n* 是反向引用。否则，如果 *n* 是八进制数 (0-7)，那么 *n* 是八进制转义码。
| 字符 | 说明 |
| :--: | :--------------: |
| \nm | 标识一个八进制转义码或反向引用。 |
| 字符 | 说明 |
| :--: | :------------------------------------: |
| \un | 匹配 *n*，其中 *n* 是以四位十六进制数表示的 Unicode 字符。 |
例如，\u00A9 匹配版权符号 (©)。
### Matcher类
```java
public class DoClient {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("\\.");
Matcher matcher = pattern.matcher("a.b.c");
}
}
```
查找方法`find()`
> 尝试查找与该模式匹配的输入序列的下一个子序列。
```java
public class DoClient {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("[a-z]");
Matcher matcher = pattern.matcher("****a.b.c****");
if (matcher.find()) {
System.out.println(matcher.start());
}
}
}
```
查找方法`find(int start)`
> 重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
```java
public class DoClient {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("[a-z]");
Matcher matcher = pattern.matcher("****a.b.c****");
if (matcher.find(7)) {
System.out.println(matcher.start());
}
}
}
```
查找方法`matches()`
> 尝试将整个区域与模式匹配。
```java
public class DoClient {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("[a-z]+");
Matcher matcher = pattern.matcher("abc");
if (matcher.matches()) {
System.out.println(matcher.start());
}
}
}
```
查找方法`lookingAt()`
> 尝试将从区域开头开始的输入序列与该模式匹配。
```java
public class DoClient {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("[a-z]+");
Matcher matcher = pattern.matcher("!abc");
if (matcher.lookingAt()) {
System.out.println(matcher.start());
}
}
}
```
索引方法`start()、end()`
```java
System.out.println(matcher.start());
System.out.println(matcher.end());
```
