java 正則表達(dá)式

正則表達(dá)式（regular expression）通常被用來(lái)檢索、替換那些符合某個(gè)模式（規(guī)則）的文本。

正則表達(dá)式在編程語(yǔ)言中，通常縮寫為regex、regexp或re。正則表達(dá)式并不僅限于某一種語(yǔ)言，但是在每種語(yǔ)言中有細(xì)微的差別。

java 語(yǔ)言支持正則表達(dá)式，語(yǔ)法與 perl 語(yǔ)言中的正則表達(dá)式非常相似。

1. java 正則表達(dá)式的語(yǔ)法

在其它編程語(yǔ)言中，\\ 表示：在正則表達(dá)式中插入一個(gè)普通的反斜杠，即反斜杠的轉(zhuǎn)義。

在 java 語(yǔ)言中，\\ 表示：插入一個(gè)正則表達(dá)式的反斜線，所以其后的字符具有特殊的意義。

所以，在其他的語(yǔ)言中（如perl），一個(gè)反斜杠 \ 就足以具有轉(zhuǎn)義的作用，而在 java 中正則表達(dá)式中則需要有兩個(gè)反斜杠才能被解析為其他語(yǔ)言中的轉(zhuǎn)義作用。也可以簡(jiǎn)單的理解在 java 的正則表達(dá)式中，兩個(gè) \\ 代表其他語(yǔ)言中的一個(gè) \，這也就是為什么表示一位數(shù)字的正則表達(dá)式是 \\d，而表示一個(gè)普通的反斜杠是 \\\\。

根據(jù) java language specification 的要求，java 源代碼的字符串中的反斜線被解釋為 unicode 轉(zhuǎn)義或其他字符轉(zhuǎn)義。因此必須在字符串字面值中使用兩個(gè)反斜線，表示正則表達(dá)式受到保護(hù)，不被 java 字節(jié)碼編譯器解釋。例如，當(dāng)解釋為正則表達(dá)式時(shí)，字符串字面值 "\b" 與單個(gè)退格字符匹配，而 "\\b" 與單詞邊界匹配。字符串字面值 "\(hello\)" 是非法的，將導(dǎo)致編譯時(shí)錯(cuò)誤；要與字符串 (hello) 匹配，必須使用字符串字面值 "\\(hello\\)"。

2. java 正則表達(dá)式的范例

一個(gè)字符串其實(shí)就是一個(gè)簡(jiǎn)單的正則表達(dá)式，例如 hello world 正則表達(dá)式匹配 "hello world" 字符串。

.（點(diǎn)號(hào)）也是一個(gè)正則表達(dá)式，它匹配任何一個(gè)字符如："a" 或 "1"。

下表列出了一些正則表達(dá)式的范例及描述：

3. java 處理正則表達(dá)式的類

java 處理正則表達(dá)式的包為 java.util.regex，其中包括以下三個(gè)類：

• pattern 類：

  pattern 對(duì)象是一個(gè)正則表達(dá)式的編譯表示。pattern 類沒(méi)有公共構(gòu)造方法。要?jiǎng)?chuàng)建一個(gè) pattern 對(duì)象，你必須首先調(diào)用其公共靜態(tài)編譯方法，它返回一個(gè) pattern 對(duì)象。該方法接受一個(gè)正則表達(dá)式作為它的第一個(gè)參數(shù)。

• matcher 類：

  matcher 對(duì)象是對(duì)輸入字符串進(jìn)行解釋和匹配操作的引擎。與pattern 類一樣，matcher 也沒(méi)有公共構(gòu)造方法。你需要調(diào)用 pattern 對(duì)象的 matcher 方法來(lái)獲得一個(gè) matcher 對(duì)象。

• patternsyntaxexception：

  patternsyntaxexception 是一個(gè)非強(qiáng)制異常類，它表示一個(gè)正則表達(dá)式模式中的語(yǔ)法錯(cuò)誤。

以下范例中使用了正則表達(dá)式 .*yapf.* 用于查找字符串中是否包了 yapf 子串：

import java.util.regex.*;
 
class regexexample1{
   public static void main(string[] args){
      string content = "i am baoku from yapf.com";
      string pattern = ".*yapf.*";
 
      boolean ismatch = pattern.matches(pattern, content);
      system.out.println("字符串中是否包含了 'yapf' 子字符串? " + ismatch);
   }
}

運(yùn)行結(jié)果：

字符串中是否包含了 'yapf' 子字符串? true

4. java matcher 類的方法

1）索引方法

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

2）查找方法

查找方法用來(lái)檢查輸入字符串并返回一個(gè)布爾值，表示是否找到該模式：

3）替換方法

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

4）start 和 end 方法

下面是一個(gè)對(duì)單詞 "cat" 出現(xiàn)在輸入字符串中出現(xiàn)次數(shù)進(jìn)行計(jì)數(shù)的例子：

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 對(duì)象
       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());
      }
   }
}

以上范例編譯運(yùn)行結(jié)果如下：

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

可以看到這個(gè)例子是使用單詞邊界，以確保字母 "c" "a" "t" 并非僅是一個(gè)較長(zhǎng)的詞的子串。它也提供了一些關(guān)于輸入字符串中匹配發(fā)生位置的有用信息。

start 方法返回在以前的匹配操作期間，由給定組所捕獲的子序列的初始索引，end 方法最后一個(gè)匹配字符的索引加 1。

5）matches 和 lookingat 方法

matches 和 lookingat 方法都用來(lái)嘗試匹配一個(gè)輸入序列模式。它們的不同是 matches 要求整個(gè)序列都匹配，而lookingat 不要求。

lookingat 方法雖然不需要整句都匹配，但是需要從第一個(gè)字符開(kāi)始匹配。

這兩個(gè)方法經(jīng)常在輸入字符串的開(kāi)始使用。

我們通過(guò)下面這個(gè)例子，來(lái)解釋這個(gè)功能：

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 final string input2 = "ooooofoooooooooooo";
    private static pattern pattern;
    private static matcher matcher;
    private static matcher matcher2;
 
    public static void main( string[] args ){
       pattern = pattern.compile(regex);
       matcher = pattern.matcher(input);
       matcher2 = pattern.matcher(input2);
 
       system.out.println("current regex is: "+regex);
       system.out.println("current input is: "+input);
       system.out.println("current input2 is: "+input2);
 
 
       system.out.println("lookingat(): "+matcher.lookingat());
       system.out.println("matches(): "+matcher.matches());
       system.out.println("lookingat(): "+matcher2.lookingat());
   }
}

以上范例編譯運(yùn)行結(jié)果如下：

current regex is: foo
current input is: fooooooooooooooooo
current input2 is: ooooofoooooooooooo
lookingat(): true
matches(): false
lookingat(): false

6）replacefirst 和 replaceall 方法

replacefirst 和 replaceall 方法用來(lái)替換匹配正則表達(dá)式的文本。不同的是，replacefirst 替換首次匹配，replaceall 替換所有匹配。

下面的例子來(lái)解釋這個(gè)功能：

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);
   }
}

以上范例編譯運(yùn)行結(jié)果如下：

the cat says meow. all cats say meow.

7）appendreplacement 和 appendtail 方法

matcher 類也提供了appendreplacement 和 appendtail 方法用于文本替換：

看下面的例子來(lái)解釋這個(gè)功能：

import java.util.regex.matcher;
import java.util.regex.pattern;
 
public class regexmatches
{
   private static string regex = "a*b";
   private static string input = "aabfooaabfooabfoobkkk";
   private static string replace = "-";
   public static void main(string[] args) {
      pattern p = pattern.compile(regex);
      // 獲取 matcher 對(duì)象
      matcher m = p.matcher(input);
      stringbuffer sb = new stringbuffer();
      while(m.find()){
         m.appendreplacement(sb,replace);
      }
      m.appendtail(sb);
      system.out.println(sb.tostring());
   }
}

以上范例編譯運(yùn)行結(jié)果如下：

-foo-foo-foo-kkk

5. patternsyntaxexception 類的方法

patternsyntaxexception 是一個(gè)非強(qiáng)制異常類，它指示一個(gè)正則表達(dá)式模式中的語(yǔ)法錯(cuò)誤。

patternsyntaxexception 類提供了下面的方法來(lái)幫助我們查看發(fā)生了什么錯(cuò)誤。

捕獲組是把多個(gè)字符當(dāng)一個(gè)單獨(dú)單元進(jìn)行處理的方法，它通過(guò)對(duì)括號(hào)內(nèi)的字符分組來(lái)創(chuàng)建。

例如，正則表達(dá)式 (dog) 創(chuàng)建了單一分組，組里包含"d"，"o"，和"g"。

捕獲組是通過(guò)從左至右計(jì)算其開(kāi)括號(hào)來(lái)編號(hào)。例如，在表達(dá)式（（a）（b（c））），有四個(gè)這樣的組：

• ((a)(b(c)))
• (a)
• (b(c))
• (c)

可以通過(guò)調(diào)用 matcher 對(duì)象的 groupcount 方法來(lái)查看表達(dá)式有多少個(gè)分組。groupcount 方法返回一個(gè) int 值，表示matcher對(duì)象當(dāng)前有多個(gè)捕獲組。

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

范例

下面的例子說(shuō)明如何從一個(gè)給定的字符串中找到數(shù)字串：

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*)(\\d+)(.*)";
 
      // 創(chuàng)建 pattern 對(duì)象
      pattern r = pattern.compile(pattern);
 
      // 現(xiàn)在創(chuàng)建 matcher 對(duì)象
      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) );
         system.out.println("found value: " + m.group(3) ); 
      } else {
         system.out.println("no match");
      }
   }
}

以上范例編譯運(yùn)行結(jié)果如下：

found value: this order was placed for qt3000! ok?
found value: this order was placed for qt
found value: 3000
found value: ! ok?