Java 中的正则表达式

1. 字符

x	字符x，表示一个普通字符。
\	正则表达式中的转义字符。
\\	正则表达式中的反斜杠字符。
	在正则表达式中 \ 为转义字符，所以要表示一个普通的反斜杠是 \\ 。
	在Java字符串中 \ 也是转义字符，在Java字符串中表示一个 \ 是 "\\" ，
	在Java字符串中表示一个正则表达式的 \ 是 "\\\\" 。例如，"\\".replaceAll("\\\\","1") 输出为 1。
\t	制表符
\n	换行符
\r	回车符
\f	换页符

2. 字符类

[abc]			a, b, 或 c
[^abc]			除 a, b, or c 之外的任何字符。
[0-9a-zA-Z]		0-9, 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 之外的字符。
[a-z&&[^m-p]]	a-z 中除 m-p 之外的字符。

3. 预定义字符类

.	表示任意一个字符
\d	表示一个数字字符: [0-9]
\D	表示一个非数字字符: [^0-9]
\s	表示一个空白字符: [\t\n\r\f \x0B]
\S	表示一个非空白字符: [^\s]
\w	表示一个单词字符: [a-zA-Z_0-9]
\W	表示一个非单词字符: [^\w]

4. 边界匹配器

^	行首
$	行尾
\b	单词边界，即匹配一个字边界，例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
\B	非单词边界，例如，"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。

5. 贪婪匹配

贪婪匹配：匹配搜索到的、尽可能长的字符串。
X?	表示0个或1个X
X*	表示0个或多个X
X+	表示1个或多个X
X{n}	表示n个X
X{n,}	表示至少n个X (包含n)
X{n,m}	表示n个到m个X (包含n,m)

示例：
"abcabcabcabc".replaceAll("a.+c","1") // 1

6.懒惰匹配

懒惰匹配，即在贪婪匹配后加?：匹配搜索到的、尽可能短的字符串。
X??	表示0个或1个X
X*?	表示0个或多个X
X+?	表示1个或多个X
X{n}?	表示n个X
X{n,}?	表示至少n个X (包含n)
X{n,m}?	表示n个到m个X (包含n,m)

示例：
"abcabcabcabc".replaceAll("a.+?c","1") // 1111

7.逻辑运算符

逻辑运算符
XY	 X后面是Y
X|Y	 X或Y
(X)	 X作为一个捕获组

8. 其他注意项

匹配正则表达式特殊字符需要转义： ^  $  *  ?  +  .  [  ]  (  )  {  }  |  \  
&& 在中括号中表示“与”，如果是匹配“&&”字符，需要转义。例如，"a&&b".replaceAll("[a\\&\\&b]","1") 输出 1111 。

9. 示例

1、java.util.regex
java.util.regex 主要包括2个类：Pattern 类 和 Matcher 类。

2、捕获组
捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。
捕获组是通过从左至右计算其开括号来编号。例如，在表达式 ((A)(B(C)))，有四个这样的组：
((A)(B(C)))
(A)
(B(C))
(C)
其中 group(0) 是一个特殊的组，它总是代表整个表达式。

示例：
@Test
public void regex() {
    // 1. 判断字符串是否匹正则表达式
    boolean isMatch = Pattern.matches(".*runoob.*", "www.runoob.com");
    System.out.println(isMatch); // true

    // 2.按指定模式在字符串查找
    String str = "www.runoob.com";
    // 创建 Pattern 对象
    Pattern r = Pattern.compile("(run).+?(b)");
    // 创建 matcher 对象
    Matcher m = r.matcher(str);
    if (m.find()) {
        System.out.println(m.group(0)); // runoob
        System.out.println(m.group(1)); // run
        System.out.println(m.group(2)); // b
    } else {
        System.out.println("NO MATCH");
    }
}