正则表达式

前言

正则表达式，（Regular Expression，在代码中常简写为Regex、regexp或RE），计算机科学的一个概念 正则表达式常用来检索、替换那些符合某个模式（规则）的文本

案例

字符匹配

  // 匹配任意字符
 System.out.println("a".matches("."));//true
 // 包含 abc 任意一个字符都匹配，默认匹配一次
 System.out.println("a".matches("[abc]"));//true
 // 任何字符，除了 a、b 或 c（否定）
 System.out.println("a".matches("[^abc]"));//false
 // a 到 z 或 A 到 Z，两头的字母包括在内（范围）
 System.out.println("A".matches("[a-zA-Z]"));//true
 // a 到 z 或 A 到 Z，两头的字母包括在内（范围）
 System.out.println("A".matches("[a-z]|[A-Z]"));//true
 // a-z，A-Z，匹配范围相同，括号是捕获组
 System.out.println("A".matches("[a-z(A-Z)]"));//true
 // 匹配 A-Z 与 RFG 交集
 System.out.println("R".matches("[A-Z&&(RFG)]"));//true
 // \w 单词字符等同于 [a-zA-Z_0-9]，{3} 匹配三次
 System.out.println("a_8".matches("\\w{3}"));//true
 // \ 表示的是一个 \
 System.out.println("\\".matches("\\\\"));//true
 // 任何字符，* 匹配零次到多次
 System.out.println("hello sir".matches("h.*"));//true
 // * 匹配任意字符 ir$ 确定匹配行的结尾
 System.out.println("hello sir".matches(".*ir$"));//true
 // ^h 匹配开头，[a-z]{1,3}o 匹配1到3次的a-z之后匹配字母o，\b 并不匹配这些单词分隔字符中的任何一个，它只匹配一个位置。匹配的是o后面的位置。
 System.out.println("hello sir".matches("^h[a-z]{1,3}o\\b.*"));//true
 // o后面跟着s，是字母，不是空格，\b 不能匹配单词的o的边界。
 System.out.println("hellosir".matches("^h[a-z]{1,3}o\\b.*"));//false
 // 匹配开头是一个空格 ^[\\s&&[^\\n]]，且不能是换行符，最后必须是换行 \\n$
 System.out.println(" \n".matches("^[\\s&&[^\\n]]*\\n$"));//true
 // (?i)非捕获组里面这个表示忽略大小写
 System.out.println("java".matches("(?i)JAVA"));//true

模式匹配

参考code-notes代码

总结

正则中包括了很多的符号、类型、匹配范围、匹配数量、匹配原则等等，像贪婪、排除、向前引用等等，这些个使用方法其实也不难，只要按照正则的标准就可以组合出你想要匹配和拦截出来的字符串内容信息。

规则

常用符号

• 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’)

  字母字符

• [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

• \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}]
• \pPunct} 标点符号：!”#$%&’()*+,-./:;<=>?@[]^_`{~
• \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]

  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()

  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，作为独立的非捕获组