正則表示式定義了字串的模式。

正則表示式可以用來搜尋、編輯或處理文字。

正則表示式並不僅限於某一種語言，但是在每種語言中有細微的差別。

java.util.regex 包主要包括以下三個類：

• Pattern 類：

  pattern 物件是一個正則表示式的編譯表示。Pattern 類沒有公共構造方法。要建立一個 Pattern 物件，你必須首先呼叫其公共靜態編譯方法，它返回一個 Pattern 物件。該方法接受一個正則表示式作為它的第一個引數。

• Matcher 類：

  Matcher 物件是對輸入字串進行解釋和匹配操作的引擎。與Pattern 類一樣，Matcher 也沒有公共構造方法。你需要呼叫 Pattern 物件的 matcher 方法來獲得一個 Matcher 物件。
• PatternSyntaxException：

  PatternSyntaxException 是一個非強制異常類，它表示一個正則表示式模式中的語法錯誤。

一.  正則表示式語法

在其他語言中，\\ 表示：在正則表示式中插入一個普通的（字面上的）反斜槓，請不要給它任何特殊的意義。

在 Java 中，\\ 表示：插入一個正則表示式的反斜線，所以其後的字元具有特殊的意義。

所以，在其他的語言中，一個反斜槓 \ 就足以具有轉義的作用，而在 Java 中正則表示式中則需要有兩個反斜槓才能被解析為其他語言中的轉義作用。

也可以簡單的理解在 Java 的正則表示式中，兩個 \\ 代表其他語言中的一個 \，這也就是為什麼表示一位數字的正則表示式是 \\d，而表示一個普通的反斜槓是 \\\\。

二.  捕獲組

捕獲組是把多個字元當一個單獨單元進行處理的方法，它通過對括號內的字元分組來建立。

例如，正則表示式 (dog) 建立了單一分組，組裡包含"d"，"o"，和"g"。

捕獲組是通過從左至右計算其開括號來編號。例如，在表示式（（A）（B（C））），有四個這樣的組：

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

可以通過呼叫 matcher 物件的 groupCount 方法來查看錶達式有多少個分組。groupCount 方法返回一個 int 值，表示matcher物件當前有多個捕獲組。

還有一個特殊的組（group(0)），它總是代表整個表示式。該組不包括在 groupCount 的返回值中。

package  com.zth;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo1{
    public static void main( String args[] ){

        // 按指定模式在字串查詢
        String line = "This order was placed for QT3000! OK?";
        String pattern = "(\\D*)(\\d+)(.*)";

        // 建立 Pattern 物件
        Pattern r = Pattern.compile(pattern);

        // 現在建立 matcher 物件
        Matcher m = r.matcher(line);
        if (m.find( )) {
            System.out.println(m.groupCount());
            System.out.println("Found value: " + m.group(0) );
            System.out.println("Found value: " + m.group(1) );
            System.out.println("Found value: " + m.group(2) );
            System.out.println("Found value: " + m.group(3) );
        } else {
            System.out.println("NO MATCH");
        }
    }
}

執行結果：

3
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT
Found value: 3000
Found value: ! OK?

三. Matcher 類的方法

1.  索引方法

索引方法提供了有用的索引值，精確表明輸入字串中在哪能找到匹配：

2.  研究方法

研究方法用來檢查輸入字串並返回一個布林值，表示是否找到該模式：

3.  替換方法

替換方法是替換輸入字串裡文字的方法：

4.  start 和 end 方法

package  com.zth;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo1{
    private static final String REGEX = "\\bcat\\b";
    private static final String INPUT =
            "cat cat cat cattie cat";

    public static void main( String args[] ){
        Pattern p = Pattern.compile(REGEX);
        Matcher m = p.matcher(INPUT); // 獲取 matcher 物件
        int count = 0;

        while(m.find()) {
            count++;
            System.out.println("Match number "+count);
            System.out.println("start(): "+m.start());
            System.out.println("end(): "+m.end());
        }
    }
}

執行結果：

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

Start 方法返回在以前的匹配操作期間，由給定組所捕獲的子序列的初始索引，end 方法最後一個匹配字元的索引加 1。

5.  matches 和 lookingAt 方法

matches 和 lookingAt 方法都用來嘗試匹配一個輸入序列模式。它們的不同是 matches 要求整個序列都匹配，而lookingAt 不要求。

lookingAt 方法雖然不需要整句都匹配，但是需要從第一個字元開始匹配。

這兩個方法經常在輸入字串的開始使用。

package com.zth;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo1{
    public static void main(String[] args){
        String regex = "foo";

        String str1 = "fooooooo";
        String str2 = "ooofoooo";

        Pattern pattern = Pattern.compile(regex);

        Matcher m1 = pattern.matcher(str1);
        Matcher m2 = pattern.matcher(str2);

        System.out.println("lookingAt(): "+ m1.lookingAt());
        System.out.println("matches(): "+m1.matches());
        System.out.println("lookingAt(): "+ m2.lookingAt());

    }

}

執行結果：

lookingAt(): true
matches(): false
lookingAt(): false

6.  replaceFirst 和 replaceAll 方法

replaceFirst 和 replaceAll 方法用來替換匹配正則表示式的文字。不同的是，replaceFirst 替換首次匹配，replaceAll 替換所有匹配。

package com.zth;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Demo1{
    public static void main(String[] args){
        String regex = "dog";
        String str = "The dog says meow. All dogs say meow.";
        String replace = "cat";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        str = matcher.replaceFirst(replace);
        System.out.println(str);
        str = matcher.replaceAll(replace);
        System.out.println(str);
    }
    
}

執行結果：

The cat says meow. All dogs say meow.
The cat says meow. All cats say meow.

7. appendReplacement 和 appendTail 方法

appendReplacement方法：

sb是一個StringBuffer，replaceContext待替換的字串，這個方法會把匹配到的內容替換為replaceContext，並且把從上次替換的位置到這次替換位置之間的字串也拿到，然後，加上這次替換後的結果一起追加到StringBuffer裡（假如這次替換是第一次替換，那就是隻追加替換後的字串啦）。

appendTail方法：

sb是一個StringBuffer，這個方法是把最後一次匹配到內容之後的字串追加到StringBuffer中。

兩個方法一起使用就可以達到所有替換或者替換第一個：

所有替換：

 while(m.find()){
		m.appendReplacement(sb,replaceContext);
	}
m.appendTail(sb);

替換第一個：

if (matcher.find()){
	matcher.appendReplacement(sb, replaceContext);
}
matcher.appendTail(sb); 

【例】

package com.zth;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {
    public static void main(String[] args) throws Exception{
        String REGEX = "a*b";
        String INPUT = "aabfooaabfooabfoobkkk";
        String REPLACE = "-";

        Pattern p = Pattern.compile(REGEX);


        // 獲取 matcher 物件
        Matcher m = p.matcher(INPUT);
        StringBuffer sb = new StringBuffer();

        while(m.find()){
            m.appendReplacement(sb,REPLACE);
        }
        System.out.println(sb.toString());
        m.appendTail(sb);
        System.out.println(sb.toString());
    }
}

執行結果：

foo-foo-foo-
foo-foo-foo-kkk

8. PatternSyntaxException 類的方法

PatternSyntaxException 是一個非強制異常類，它指示一個正則表示式模式中的語法錯誤。

PatternSyntaxException 類提供了下面的方法來幫助我們檢視發生了什麼錯誤。

四. 常用正則表示式