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

正規表示式語法

字元

說明

#\

將下一字元標記為特殊字元、文字、反向引用或八進位轉義符。例如，"n"匹配字元"n"。 "\n"符合換行符號。序列"\\"匹配"\"，"\("匹配"("。

^

符合輸入字串開始的位置。

$

符合輸入字串結尾的位置。如果設定了 RegExp 物件的 Multiline 屬性，$ 也會與"\n"或"\r"之前的位置相符。

*

零次或多次符合前面的字元或子表達式。例如，zo* 匹配"z"和"zoo"。 * 等效於 {0,}。

+

一次或多次符合前面的字元或子表達式。例如，"zo+"與"zo"和"zoo"匹配，但與"z"不匹配。 + 等效於 {1,}。

?

零次或一次符合前面的字元或子表達式。例如，"do(es)?"符合"do"或"does"中的"do"。 ? 等效於 {0,1}。

{n}

#n 是非負整數。剛好符合 n 次。例如，"o{2}"與"Bob"中的"o"不匹配，但與"food"中的兩個"o"匹配。

{n,}

#n 為非負整數。至少匹配 n 次。例如，"o{2,}"不符合"Bob"中的"o"，而符合"foooood"中的所有 o。 "o{1,}"等價於"o+"。 "o{0,}"等價於"o*"。

{n,m}

M 和n 是非負整數，其中n <= m。配對至少 n 次，至多 m 次。例如，"o{1,3}"符合"fooooood"中的頭三個 o。 'o{0,1}' 等價於 'o?'。注意：您不能將空格插入逗號和數字之間。

?

當此字元緊接在任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之後時，配對模式是「非貪心的」。 "非貪心的"模式匹配搜尋到的、盡可能短的字串，而預設的"貪心的"模式匹配搜尋到的、盡可能長的字串。例如，在字串"oooo"中，"o+?"只符合單一"o"，而"o+"符合所有"o"。

.

匹配除"\r\n"之外的任何單一字元。若要符合包括"\r\n"在內的任意字符，請使用諸如"[\s\S]"之類的模式。

(pattern)

#pattern 並擷取該匹配的子表達式。可以使用 $0…$9 屬性從結果"匹配"集合中檢索捕獲的匹配。若要符合括號字元 ( )，請使用"\("或"\)"。

(?:pattern)

匹配 pattern 但不捕獲該匹配的子表達式，即它是一個非捕獲匹配，並不會儲存以供以後使用的匹配。這對於用"or"字元 (|) 組合模式部件的情況很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更經濟的表達式。

(?=pattern)

執行正向預測先行搜尋的子表達式，該表達式會匹配處於符合pattern 的字串的起始點的字串。它是一個非捕獲匹配，即不能捕獲以供以後使用的匹配。例如，'Windows (?=95|98|NT|2000)' 符合"Windows 2000"中的"Windows"，但不符合"Windows 3.1"中的"Windows"。預測先行不佔用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配之後，而不是在組成預測先行的字符後。

(?!pattern)

執行反向預測先行搜尋的子表達式，該表達式匹配不處於匹配pattern 的字串的起始點的搜尋字串。它是一個非捕獲匹配，即不能捕獲以供以後使用的匹配。例如，'Windows (?!95|98|NT|2000)' 符合"Windows 3.1"中的 "Windows"，但不符合"Windows 2000"中的"Windows"。預測先行不佔用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配之後，而不是在組成預測先行的字符後。

x|y

匹配x 或y。例如，'z|food' 匹配"z"或"food"。 '(z|f)ood' 匹配"zood"或"food"。

[xyz]

字元集。匹配包含的任一字元。例如，"[abc]"符合"plain"中的"a"。

[^xyz]

#反向字元集。匹配未包含的任何字元。例如，"[^abc]"符合"plain"中"p"，"l"，"i"，"n"。

[a-z]

字元範圍。匹配指定範圍內的任何字元。例如，"[a-z]"符合"a"到"z"範圍內的任何小寫字母。

[^a-z]

反向範圍字元。匹配不在指定的範圍內的任何字元。例如，"[^a-z]"會匹配任何不在"a"到"z"範圍內的任何字元。

\b

#符合一個字邊界，即字與空格間的位置。例如，"er\b"符合"never"中的"er"，但不符合"verb"中的"er"。

\B

#非字邊界比對。 "er\B"符合"verb"中的"er"，但不符合"never"中的"er"。

\cx

符合 x 指示的控製字元。例如，\cM 符合 Control-M 或回車符。 x 的值必須在 A-Z 或 a-z 之間。如果不是這樣，則假定 c 就是"c"字元本身。

\d

數字字元匹配。等效於 [0-9]。

\D

#非數字字元匹配。等效於 [^0-9]。

\f

# 換頁符號符合。等效於 \x0c 和 \cL。

\n

#換行符匹配。等效於 \x0a 和 \cJ。

\r

#符合一個回車符。等效於 \x0d 和 \cM。

\s

#符合任何空白字符，包括空格、製表符、換頁符等。與 [ \f\n\r\t\v] 等效。

\S

#符合任何非空白字元。與 [^ \f\n\r\t\v] 等效。

\t

#製表符匹配。與 \x09 和 \cI 等效。

\v

#垂直製表符匹配。與 \x0b 和 \cK 等效。

\w

#符合任何字類字符，包括下劃線。與"[A-Za-z0-9_]"等效。

\W

#與任何非單字字元相符。與"[^A-Za-z0-9_]"等效。

\xn

匹配n，此處的n 是一個十六進位轉義碼。十六進制轉義碼必須正好是兩位數長。例如，"\x41"符合"A"。 "\x041"與"\x04"&"1"等效。允許在正規表示式中使用 ASCII 代碼。

\num

#匹配num，此處的num 是一個正整數。到捕獲匹配的反向引用。例如，"(.)\1"符合兩個連續的相同字元。

\n

#標識一個八進位轉義碼或反向引用。如果 \n 前面至少有 n 個捕獲子表達式，那麼 n 是反向引用。否則，如果 n 是八進位數 (0-7)，那麼 n 是八進位轉義碼。

\nm

#標識一個八進位轉義碼或反向引用。如果 \nm 前面至少有 nm 個捕獲子表達式，那麼 nm 是反向引用。如果 \nm 前面至少有 n 個捕獲，則 n 是反向引用，後面跟著字元 m。如果兩個前面的情況都不存在，則\nm 匹配八進位值nm，其中n 和m 是八進位數字( 0-7)。

\nml

#當n 是八進位數( 0-3)，m 和l 是八進位數(0-7) 時，符合八進位轉義碼nml。

\un

符合 n，其中 n 是以四位數十六進位數表示的 Unicode 字元。例如，\u00A9 符合版權符號 (©)。

Matcher類別的方法

索引方法

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

public int start() public int start(int group)public int end()
序號#方法及說明

#                    1
# 傳回先前匹配的初始索引。                     2
 返回在先前的配對作業期間，由給定群組所捕捉的子序列的初始指標                    3
# 傳回最後匹配字元之後的偏移量。

                    4public int end(int group)研究方法用來檢查輸入字串並傳回一個布林值，表示是否找到該模式：方法與說明public boolean lookingAt() # 嘗試尋找與該模式相符的輸入序列的下一個子序列。 ）
返回在先前的匹配操作期間，由給定組捕獲子序列的最後字元之後的偏移量。 研究方法
#序號
                    1
 嘗試將從區域開頭開始的輸入序列與該模式相符。                     2
public boolean find()
                    3
public boolean find(int start
重設此匹配器，然後嘗試尋找符合該模式、從指定索引開始的輸入序列的下一個子序列。 ############                    4#########public boolean matches() ###### 嘗試將整個區域與模式配對。 ############

替換方法

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

#方法及說明
                    1public Matcher appendReplacement(StringBuffer sb, String replacement)
# 實現非終端添加和替換步驟。
                    2public StringBuffer appendTail(StringBuffer sb)
實現終端添加和替換步驟。
                    3public String replaceAll(String replacement)
 替換模式與給定替換字串相符的輸入序列的每個子序列。
                    4public String replaceFirst(String replacement)
#  替換模式與給定替換字串相符的輸入序列的第一個子序列。
                    5#########public static String quoteReplacement(String s)###### 傳回指定字串的字面替換字串。這個方法傳回一個字串，就像傳遞給Matcher類別的appendReplacement 方法一個字面字串一樣運作。 ############

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 方法都用來嘗試匹配一個輸入序列模式。它們的不同是matcher要求整個序列都匹配，而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 類別提供了下面的方法來幫助我們查看發生了什麼錯誤。

序號
#                    1public String getDescription()
取得錯誤的描述。
                    2public int getIndex()
 取得錯誤的索引。
                    3public String getPattern()
取得錯誤的正規表示式模式。
                    4public String getMessage()
傳回多行字串，包含語法錯誤及其索引的描述、錯誤的正規表示式模式和模式中錯誤索引的可視化指示。
#