Java学习笔记-正则表达式

符合一定规则，对于字符串进行操作的一种表达式
在其他语言中，\\表示：我想要在正则表达式中插入一个普通的（字面上的）反斜杠，请不要给它任何特殊的意义
在Java中，\\ 表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义

正则表达式在Java中有三个常用运用

• 匹配：String matches(regex)方法。用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false

String telReg = "1\\d{10}"; //匹配手机号
boolean b = "13812345678".matches(telReg);
String reg = "[a-zA-Z]\\d*"; //匹配字母开头的数字序列
String reg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+"; //匹配邮箱
String reg = "\\w+@\\w+(\\.\\w+)+"; //匹配邮箱

• 切割：String split(regex);

String[] arr = "a.b.c.d".split("\\."); //用点号分割
String[] arr = "c:\\test\\a.txt".split("\\\\"); //用双反斜线分割
String[] arr = "erkktyqqquizzzzzo".split("(.)\\1+"); //用重复字母分割

• 替换：String replaceAll(regex, str);如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式中的已有的组

String str = "qq123456w14op25675f".replaceAll("\\d{5,}","#"); //将大于等于5位的数字替换成井号
String str = "addbgggckkkd".replaceAll("(.)\\1+","#"); //将多个重复字符替换成井号
String str = "erkktyqqquizzzzzo".replaceAll("(.)\\1+","$1"); //将多个重复字符替换成单个字符

• 获取：将字符串中的符合规则的子串取出
  • 将正则表达式封装成对象
  • 让正则对象和要操作的字符串相关联
  • 关联后，获取正则匹配引擎
  • 通过引擎对符合规则的子串进行操作，比如取出

//将规则封装成对象
Pattern p = Pattern.compile(reg);
//让正则对象和要作用的字符串相关联。获取匹配器对象。
Matcher m  = p.matcher(str);
while(m.find()) {
    System.out.println(m.group());
}

• 如果只想知道该字符是否对是错，使用匹配
• 想要将已有的字符串变成另一个字符串，替换
• 想要按照自定的方式将字符串变成多个字符串。切割。获取规则以外的子串
• 想要拿到符合需求的字符串子串，获取。获取符合规则的子串

字符：

构造	匹配
`x`	字符 x
`\\`	反斜线字符
`\0n`	带有八进制值 0 的字符 n (0 <= n <= 7)
`\0nn`	带有八进制值 0 的字符 nn (0 <= n <= 7)
`\0mnn`	带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）
`\xhh`	带有十六进制值 0x 的字符 hh
`\uhhhh`	带有十六进制值 0x 的字符 hhhh
`\t`	制表符 (`'\u0009'`)
`\n`	新行（换行）符 (`'\u000A'`)
`\r`	回车符 (`'\u000D'`)
`\f`	换页符 (`'\u000C'`)
`\a`	报警 (bell) 符 (`'\u0007'`)
`\e`	转义符 (`'\u001B'`)
`\cx`	对应于 x 的控制符

字符类：

构造	匹配
`[abc]`	a、b 或 c（简单类）
`[^abc]`	任何字符，除了 a、b 或 c（否定）
`[a-zA-Z]`	a 到 z 或 A 到 Z，两头的字母包括在内（范围）
`[a-d[m-p]]`	a 到 d 或 m 到 p：`[a-dm-p]`（并集）
`[a-z&&[def]]`	d、e 或 f（交集）
`[a-z&&[^bc]]`	a 到 z，除了 b 和 c：`[ad-z]`（减去）
`[a-z&&[^m-p]]`	a 到 z，而非 m 到 p：`[a-lq-z]`（减去）

预定义字符类：

构造	匹配
`.`	任何字符（与行结束符可能匹配也可能不匹配）
`\d`	数字：`[0-9]`
`\D`	非数字：`[^0-9]`
`\s`	空白字符：`[ \t\n\x0B\f\r]`
`\S`	非空白字符：`[^\s]`
`\w`	单词字符：`[a-zA-Z_0-9]`
`\W`	非单词字符：`[^\w]`

POSIX 字符类（仅 US-ASCII）：

构造	匹配
`\p{Lower}`	小写字母字符：`[a-z]`
`\p{Upper}`	大写字母字符：`[A-Z]`
`\p{ASCII}`	所有 ASCII：`[\x00-\x7F]`
`\p{Alpha}`	字母字符：`[\p{Lower}\p{Upper}]`
`\p{Digit}`	十进制数字：`[0-9]`
`\p{Alnum}`	字母数字字符：`[\p{Alpha}\p{Digit}]`
`\p{Punct}`	标点符号：`!"#$%&'()*+,-./:;<=>?@[\]^_{|}~`
`\p{Graph}`	可见字符：`[\p{Alnum}\p{Punct}]`
`\p{Print}`	可打印字符：`[\p{Graph}\x20]`
`\p{Blank}`	空格或制表符：`[ \t]`
`\p{Cntrl}`	控制字符：`[\x00-\x1F\x7F]`
`\p{XDigit}`	十六进制数字：`[0-9a-fA-F]`
`\p{Space}`	空白字符：`[ \t\n\x0B\f\r]`

java.lang.Character 类（简单的 java 字符类型）：

构造	匹配
`\p{javaLowerCase}`	等效于 `java.lang.Character.isLowerCase()`
`\p{javaUpperCase}`	等效于 `java.lang.Character.isUpperCase()`
`\p{javaWhitespace}`	等效于 `java.lang.Character.isWhitespace()`
`\p{javaMirrored}`	等效于 `java.lang.Character.isMirrored()`

Unicode 块和类别的类：

构造	匹配
`\p{InGreek}`	Greek 块（简单块）中的字符
`\p{Lu}`	大写字母（简单类别）
`\p{Sc}`	货币符号
`\P{InGreek}`	所有字符，Greek 块中的除外（否定）
`[\p{L}&&[^\p{Lu}]]`	所有字母，大写字母除外（减去）

边界匹配器：

构造	匹配
`^`	行的开头
`$`	行的结尾
`\b`	单词边界
`\B`	非单词边界
`\A`	输入的开头
`\G`	上一个匹配的结尾
`\Z`	输入的结尾，仅用于最后的结束符（如果有的话）
`\z`	输入的结尾

Greedy 数量词：

构造	匹配
`X?`	X，一次或一次也没有
`X*`	X，零次或多次
`X+`	X，一次或多次
`X{n}`	X，恰好 n 次
`X{n,}`	X，至少 n 次
`X{n,m}`	X，至少 n 次，但是不超过 m 次

Reluctant 数量词：

构造	匹配
`X??`	X，一次或一次也没有
`X*?`	X，零次或多次
`X+?`	X，一次或多次
`X{n}?`	X，恰好 n 次
`X{n,}?`	X，至少 n 次
`X{n,m}?`	X，至少 n 次，但是不超过 m 次

Possessive 数量词：

构造	匹配
`X?+`	X，一次或一次也没有
`X*+`	X，零次或多次
`X++`	X，一次或多次
`X{n}+`	X，恰好 n 次
`X{n,}+`	X，至少 n 次
`X{n,m}+`	X，至少 n 次，但是不超过 m 次

Logical 运算符：

构造	匹配
`XY`	X 后跟 Y
`X|Y`	X 或 Y
`(X)`	X，作为捕获组

Back 引用：

构造	匹配
`\n`	任何匹配的 nth 捕获组

引用：

构造	匹配
`\`	Nothing，但是引用以下字符
`\Q`	Nothing，但是引用所有字符，直到`\E`
`\E`	Nothing，但是结束从`\Q`开始的引用

特殊构造（非捕获）：

构造	匹配
`(?:X)`	X，作为非捕获组
`(?idmsux-idmsux)`	Nothing，但是将匹配标志i d m s u x on - off
`(?idmsux-idmsux:X)`	X，作为带有给定标志 i d m s u x on - off
`(?=X)`	X，通过零宽度的正 lookahead
`(?!X)`	X，通过零宽度的负 lookahead
`(?<=X)`	X，通过零宽度的正 lookbehind
`(?<!X)`	X，通过零宽度的负 lookbehind
`(?>X)`	X，作为独立的非捕获组