大佬把他总结的正则表达式使用给我了！

一、前言

编程总在实践中出结果！

正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。

正则引擎主要可以分为两大类：一种是DFA，一种是NFA。这两种引擎都有了很久的历史(至今二十多年)，当中也由这两种引擎产生了很多变体！于是POSIX的出台规避了不必要变体的继续产生。这样一来，主流的正则引擎又分为3类：一、DFA，二、传统型NFA，三、POSIX NFA。

正则也是一种非常有意思的技术，但往往不知道这些符号的编程在实际使用中该如何使用，因此总结了本篇文章，方便所有小伙伴可以当成一个工具文章使用，方便处理一些需要使用正则的技术内容。

 

二、规则

1. 常用符号
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’)

2. 字母字符
[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]（减去）

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

4. POSIX 字符
\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]

5. Character 类
\p{javaLowerCase} 等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase} 等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace} 等效于 java.lang.Character.isWhitespace()
\p{javaMirrored} 等效于 java.lang.Character.isMirrored()

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

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

8. Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

9. Reluctant 数量词
X?? X，一次或一次也没有
X*? X，零次或多次
X+? X，一次或多次
X{n}? X，恰好 n 次
X{n,}? X，至少 n 次
X{n,m}? X，至少 n 次，但是不超过 m 次

10. Possessive 数量词
X?+ X，一次或一次也没有
X*+ X，零次或多次
X++ X，一次或多次
X{n}+ X，恰好 n 次
X{n,}+ X，至少 n 次
X{n,m}+ X，至少 n 次，但是不超过 m 次

11. Logical 运算符
XY X 后跟 Y
X|Y X 或 Y
(X) X，作为捕获组

12. Back 引用
\n 任何匹配的 nth 捕获组

13. 引用
\ Nothing，但是引用以下字符
\Q Nothing，但是引用所有字符，直到 \E
\E Nothing，但是结束从 \Q 开始的引用

14. 特殊构造（非捕获）
(?: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，作为独立的非捕获组

三、案例

1. 字符匹配

 

"a".matches(".")

结果：true
描述：. 匹配任意字符

 

"a".matches("[abc]")

结果：true
描述：包含 abc 任意一个字符都匹配，默认匹配一次

 

"a".matches("[^abc]")

结果：true
描述：任何字符，除了 a、b 或 c（否定）

 

"A".matches("[a-zA-Z]")

结果：true
描述：a 到 z 或 A 到 Z，两头的字母包括在内（范围）

 

"A".matches("[a-z]|[A-Z]")

结果：true
描述：a 到 z 或 A 到 Z，两头的字母包括在内（范围）

 

"A".matches("[a-z(A-Z)]")

结果：true
描述：a-z，A-Z，匹配范围相同，括号是捕获组

 

"R".matches("[A-Z&&(RFG)]")

结果：true
描述：匹配 A-Z 与 RFG 交集

 

"a_8".matches("\\w{3}")

结果：true
描述：\w 单词字符等同于 [a-zA-Z_0-9]，{3} 匹配三次

 

"\\".matches("\\\\")

结果：true
描述：\ 表示的是一个 \

 

"hello sir".matches("h.*")

结果：true
描述：. 任何字符，* 匹配零次到多次

 

"hello sir".matches(".*ir$")

结果：true
描述：.* 匹配任意字符 ir$ 确定匹配行的结尾

"hello sir".matches("^h[a-z]{1,3}o\\b.*")

结果：true
描述：^h 匹配开头，[a-z]{1,3}o 匹配1到3次的a-z之后匹配字母o，\b 并不匹配这些单词分隔字符中的任何一个，它只匹配一个位置。匹配的是o后面的位置。

"hellosir".matches("^h[a-z]{1,3}o\\b.*")

结果：false
描述：o后面跟着s，是字母，不是空格，\b 不能匹配单词的o的边界。

" \n".matches("^[\\s&&[^\\n]]*\\n$")

结果：true
描述：匹配开头是一个空格 ^[\\s&&[^\\n]]，且不能是换行符，最后必须是换行 \\n$

System.out.println("java".matches("(?i)JAVA"));

结果：true
描述：(?i)非捕获组里面这个表示忽略大小写

2. 模式匹配

2.1 验证匹配

Pattern p = Pattern.compile("[a-z]{3,}");
Matcher m = p.matcher("fgha");
System.out.println(m.matches()); // true，匹配字符3次及以上

结果：true
描述：Pattern 与 Matcher 一起合作 .Matcher 类提供了对正则表达式的分组支持，以及对正则表达式的多次匹配支持.。单独用Pattern只能使用 Pattern.matches(String regex,CharSequence input) 一种最基础最简单的匹配。

2.2 匹配功能

Pattern p = Pattern.compile("\\d{3,5}");
Matcher m = p.matcher("123-4536-89789-000");
System.out.println(m.matches());
m.reset();// 把吃进去的字符吐出来重新匹配，否经过m2.matches会吃进去字符 下面的匹配就不成功
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end());  // 找到了 就把首位位置打印下（必须找到才能打印）
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end()); // 找到了 就把首位位置打印下（必须找到才能打印）
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end()); // 找到了 就把首位位置打印下（必须找到才能打印）
System.out.println(m.find());
System.out.println(m.lookingAt());              //每次都是才头上开始找

测试结果

false
true
0-3
true
4-8
true
9-14
true
true

m.matches()，是全量匹配
m.reset()，把吃进去的字符吐出来重新匹配，否经过m2.matches会吃进去字符 下面的匹配就不成功
m.find()，查找匹配
m.start()，匹配到的字符串，开始位置
m.end()，匹配到的字符串，结束位置

2.3 匹配普通替换

Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java_Java_jAva_jAVa_IloveJava");
System.out.println(m.replaceAll("JAVA"));

结果：JAVA_JAVA_JAVA_JAVA_IloveJAVA
描述：把所有匹配到的小写字母 java、JavA，都匹配为大写

2.4 匹配逻辑替换

Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java_Java_jAva_jAVa_IloveJava fdasfas");
StringBuffer sb = new StringBuffer();
int i = 0;
while (m.find()) {
    i++;
    if (i % 2 == 0) {
        m.appendReplacement(sb, "java");
    } else {
        m.appendReplacement(sb, "JAVA");
    }
}
m.appendTail(sb);
System.out.println(sb);

结果：JAVA_java_JAVA_java_IloveJAVA fdasfas
描述：按照程序逻辑 i % 2，进行单双数替换匹配

2.4 分组匹配

Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");
Matcher m = p.matcher("123bb_78987dd_090po");
while(m.find()){
    System.out.println(m.group(1));
}

结果：

123
78987
090

Process finished with exit code 0

描述：分组加括号只取数字一组，grop括号里面第0组是整体，第一组是左起第一个括号，第二组是左起第二个括号

 

2.5 贪婪的匹配与不贪婪匹配

Pattern p = Pattern.compile("(.{3,10}?)[0-9]");
Matcher m = p.matcher("aaaa5dddd8");
while (m.find()) {
    System.out.println(m.start() + "-" + m.end());
}

结果：

0-5
5-10

Process finished with exit code 0

描述：.{3,10}后面没问号就是贪婪匹配会陪到最长，如果{3,10}?加?号就是懒蛋匹配之匹配最少的，从3个开始找。如果这里用if(m.find)(){m.start()+"-"+m.end()} 那么之匹配第一个

 

2.6 普通捕获

Pattern p = Pattern.compile(".{3}");
Matcher m = p.matcher("ab4dd5");
while(m.find()){
    System.out.println(m.group());
}

结果：

ab4
5-10

Process finished with exit code 0

描述：每次匹配三个任意字符，用 m.group() 输出。

 

2.7 非捕获组(?=a)

 Pattern p = Pattern.compile(".{3}(?=a)");           
 Matcher m = p.matcher("ab4add5");
 while (m.find()) {
     System.out.println("后面不能是a的：" + m.group());
 }

结果：后面不能是a的：ab4
描述：(?=a)这个是非捕获组的意思，最后一个是a而且还不把这个a取出来！！(?=a)这个要是写在前面就不一样了

 

Pattern p = Pattern.compile("(?!a).{3}");           
Matcher m = p.matcher("abbsab89");
while (m.find()) {
    System.out.println("前面不能是a的：" + m.group());
}

结果：前面不能是a的：bbs、前面不能是a的：b89
描述：(?!a)前面不能是a的，所以找到整个字符串中 bbs、b89

2.8 去除><号匹配

Pattern p = Pattern.compile("(?!>).+(?=<)");
Matcher m = p.matcher(">小傅哥<");
while (m.find()) {
    System.out.println(m.group());
}

结果：小傅哥
描述：一般可以匹配网页中的特殊字符串里面的内容信息。

2.9 向前引用

Pattern p = Pattern.compile("(\\d\\d)\\1");
Matcher m = p.matcher("1212");
System.out.println(m.matches());

结果：true
描述：这里面的1是向前引用，12是第一匹配到的，下一次在匹配出来12和前面相同 所以是true

四、总结
正则中包括了很多的符号、类型、匹配范围、匹配数量、匹配原则等等，像贪婪、排除、向前引用等等，这些个使用方法其实也不难，只要按照正则的标准就可以组合出你想要匹配和拦截出来的字符串内容信息。
————————————————
版权声明：本文为「小傅哥」的原创文章