Java 正規表示式

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

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

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

Java正規表示式和Perl的是最相似的。

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

• Pattern類：

  pattern物件是一個正規表示式的編譯表示。 Pattern類別沒有公共構造方法。要建立一個Pattern對象，你必須先呼叫其公共靜態編譯方法，它會傳回一個Pattern物件。此方法接受一個正規表示式作為它的第一個參數。

• Matcher類：

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

• PatternSyntaxException：

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

捕獲組

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

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

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

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

• (A)

• (B(C))

• (C)

可以透過呼叫matcher物件的groupCount方法來查看表達式有多少個分組。 groupCount方法傳回一個int值，表示matcher物件目前有多個擷取群組。

還有一個特殊的組（組0），它總是代表整個表達式。該群組不包括在groupCount的回傳值中。

實例

下面的例子說明如何從一個給定的字串中找到數字字串：

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

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

// 依指定模式在字串中尋找 String line = "This order was placed for QT3000! OK?";
String pattern = "(.*)(\d+)(.*)";

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

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

以上實例編譯運行結果如下：

 Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

正規表示式語法

Matcher類別的方法

索引方法

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

研究方法

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

替換方法

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

start 和end 方法

下面是一個對單字"cat"出現在輸入字串中出現次數進行計數的例子：

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

public class RegexMatches
{
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

可以看到這個例子是使用單字邊界，以確保字母"c" "a" "t" 並非僅是一個較長的字的子字串。它也提供了一些關於輸入字串中匹配發生位置的有用資訊。

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

matches 和lookingAt 方法

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

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

我們透過下面這個例子，來解釋這個功能：

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

public class RegexMatches
{
private static final String REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
private static Pattern pattern;
private static Matcher matcher;

public static void main( String args[] ){
pattern = Pattern.compile(REGEX);
matcher = pattern.matcher(INPUT);

System.out.println("Current REGEX is: "+REGEX);
System.out.println("Current INPUT is: "+INPUT);

System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}

以上實例編譯運行結果如下：

 Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst 和replaceAll 方法

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

下面的例子來解釋這個功能：

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

public class RegexMatches
{
private static String REGEX = "dog";
private static String INPUT = "The dog says meow. " +
"All dogs say meow.";
private static String REPLACE = "cat";

public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}

以上實例編譯運行結果如下：

 The cat says meow. All cats say meow.

appendReplacement 和appendTail 方法

Matcher 類別也提供了appendReplacement 和appendTail 方法用於文字替換：

看下面的例子來解釋這個功能：

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

public class RegexMatches
{
private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoob";
private static String REPLACE = "-";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// 取得 matcher 物件 Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}

以上實例編譯運行結果如下：

 -foo-foo-foo-

PatternSyntaxException 類別的方法

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

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