正則表示式的子表示式（分組）不是很好懂，但卻是很強大的文字處理工具。

1 正則表示式熱身

匹配電話號碼

// 電話號碼匹配
// 手機號段只有 13xxx 15xxx 18xxxx 17xxx
System.out.println("18304072984".matches("1[3578]\\d{9}"));   // true

// 座機號：010-65784236,0316-3312617,022-12465647,03123312336
String regex = "0\\d{2}-?\\d{8}|0\\d{3}-?\\d{7}";
String telStr = "010-43367458";
System.out
 
.println(telStr.matches(regex));  // true

匹配郵箱

String mail = "[email protected]";
String reg = "[a-zA-Z_0-9][email protected][a-zA-Z0-9]+(\\.[a-zA-Z]+){1,2}";
System.out.println(mail.matches(reg));  // true

特殊字元替換

將不是中文的字元替換為空：

String input = "神探狄仁&*%$傑之四大天王@bdfbdbdfdgds23532";
String
 
 reg = "[^\\u4e00-\\u9fa5]";
input = input.replaceAll(reg, "");
System.out.println(input);   // 神探狄仁傑之四大天王

漢字的Unicode編碼範圍是：\u4e00-\u9fa5

2 分組

什麼是分組，直接引用 Java Api 中 Pattern 中的描述：

Capturing groups are numbered by counting their opening parentheses from left to right. In the expression ((A)(B(C))), for example, there are four such groups:
1. ((A)(B(C)))
2. (A)
3. (B(C))
4. (C)

可以根據有多少個左括號來來確定有多少個分組，括號裡的表示式都稱子表示式。

Eg1:

String regex = "\\$\\{([^{}]+?)\\}";
Pattern pattern = Pattern.compile(regex);
String input = "${name}-babalala-${age}-${address}";

Matcher matcher = pattern.matcher(input);
while (matcher.find()) {
    System.out.println(matcher.group(0) + ", pos: " + matcher.start());
    System.out.println(matcher.group(1) + ", pos: " + matcher.start(1));
}

輸出：

${name}, pos: 0
name, pos: 2
${age}, pos: 17
age, pos: 19
${address}, pos: 24
address, pos: 26

group，翻譯成中文就是分組。
group()或group(0)對應於整個正則表示式每次匹配到的內容，
group(1)表示括號中(一個子表示式分組)匹配到的內容。

Eg2:

為了更直觀的看分組，在Eg1的正則表示式上再多加一對括號：

String regex = "(\\$\\{([^{}]+?)\\})";
Pattern pattern = Pattern.compile(regex);
String input = "${name}-babalala-${age}-${address}";

Matcher matcher = pattern.matcher(input);
while (matcher.find()) {
    System.out.println(matcher.group(0) + ", pos: " + matcher.start());
    System.out.println(matcher.group(1) + ", pos: " + matcher.start(1));
    System.out.println(matcher.group(2) + ", pos: " + matcher.start(2));
}

輸出：

${name}, pos: 0
${name}, pos: 0
name, pos: 2
${age}, pos: 17
${age}, pos: 17
age, pos: 19
${address}, pos: 24
${address}, pos: 24
address, pos: 26

由此可得出一對括號一個分組，可以通過左括號數來確定有多少個分組。

通過group()獲取分組中的匹配字串應用場景很廣泛，
在筆者的一個專案中，通過使用這個特性實現了很有意思的萬用字元替換，感動！

3 分組替換

Eg1：

String tel = "18304072984";
// 括號表示組，被替換的部分$n表示第n組的內容
tel = tel.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
System.out.print(tel);   // output: 183****2984

replaceAll 是一個替換字串的方法，正則表示式中括號表示一個分組，replaceAll 的引數 2 中可以使用 $n（n 為數字）來依次引用子表示式中匹配到的分組字串，"(\\d{3})\\d{4}(\\d{4})", "$1****$2"，分為前（前三個數字）中間四個數字(最後四個數字) 替換為（第一組數字保持不變 $1）（中間為 * ）（第二組數字保持不變 $2）。

Eg2:

String one = "hello girl hi hot".replaceFirst("(\\w+)\\s+(\\w+)", "$2 $1"); 
String two = "hello girl hi hot".replaceAll("(\\w+)\\s+(\\w+)", "$2 $1"); 
System.out.println(one);   // girl hello hi hot
System.out.println(two);   // girl hello hot hi

理解了Eg1，這個例子也自然就理解了。

Eg3：

來一個實用的例子，重複標點符號替換：

String input = "假如生活欺騙了你，，，相信吧，，，快樂的日子將會來臨！！！…………";

// 重複標點符號替換
String duplicateSymbolReg = "([。？！?!，]|\\.\\.\\.|……)+";
input = input.replaceAll(duplicateSymbolReg, "$1");
System.out.println(input);

輸出：

假如生活欺騙了你，相信吧，快樂的日子將會來臨！……

正則表示式：([。？！?!，]|\\.\\.\\.|……)+，括號中是一個分組：表示一個標點符號，+表示這個分組出現一次或多次，$1分組的內容（一個標點符號）。replaceAll 就使用$1去對字串進行替換了。

Eg4:

IP地址排序

String ip = "192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30";
ip = ip.replaceAll("(\\d+)", "00$1");
System.out.println(ip);

ip = ip.replaceAll("0*(\\d{3})", "$1");
System.out.println(ip);
String[] strs = ip.split(" ");

Arrays.sort(strs);
for (String str : strs) {
    str = str.replaceAll("0*(\\d+)", "$1");
    System.out.println(str);
}

輸出：

00192.0068.001.00254 00102.0049.0023.00013 0010.0010.0010.0010 002.002.002.002 008.00109.0090.0030
192.068.001.254 102.049.023.013 010.010.010.010 002.002.002.002 008.109.090.030
2.2.2.2
8.109.90.30
10.10.10.10
102.49.23.13
192.68.1.254

1. 讓IP地址的每一段都是3位，替換之後有4位的情況
2. 保證IP地址每一段都是3位
3. 排序之

寫到這裡，筆者不禁感嘆，真的很強大！

4 反向引用

使用小括號指定一個子表示式分組後，匹配這個子表示式的文字可以在表示式或其它程式中作進一步的處理。預設情況下，每個分組會自動擁有一個組號，規則是：以分組的左括號為標誌，從左向右，第一個分組的組號為1，第二個為2，以此類推。

Eg:

/* 這個正則表示式表示 安安靜靜 這樣的疊詞 */
String regex = "(.)\\1(.)\\2";  
System.out.println("安安靜靜".matches(regex));   // true
System.out.println("安靜安靜".matches(regex));   // false

上面 (.) 表示一個分組，裡面 . 表示任意字元，每一個字元都是一個分組，
\\1表示組1（安）又出現了一次，\\2表示組2（靜）又出現了一次。

那匹配 安靜安靜，怎麼寫正則表示式？根據上面的例子，將安靜分成一個組，然後這個組又出現了一次就是安靜安靜：

String regex = "(..)\\1";  
System.out.println("安靜安靜".matches(regex));   // true
System.out.println("安安靜靜".matches(regex));   // false

5 反向引用替換

Eg1:

String str = "我我...我我...我要..要要...要要...找找找一個....女女女女...朋朋朋朋朋朋...友友友友友..友.友...友...友友！！！";

/*將 . 去掉*/
str = str.replaceAll("\\.+", "");
System.out.println(str);

str = str.replaceAll("(.)\\1+", "$1");
System.out.println(str);

輸出：

我我我我我要要要要要找找找一個女女女女朋朋朋朋朋朋友友友友友友友友友友！！！
我要找一個女朋友！

(.)表示任意一個字元都會成為一個分組；\\1+ 引用分組（一個字元），表示出現1次或多次這個分組。 $1引用分組(.)將多個重複字元替換成一個字元。

Eg2:

替換重複出現的兩位數之間的內容：

"xx12abdd12345".replaceAll("(\\d{2}).+?\\1", "");  //結果為 xx345

是不是覺得很神奇！