Matcher类:

使用Matcher类,最重要的一个概念必须清楚:组(Group),在正则表达式中

()定义了一个组,由于一个正则表达式可以包含很多的组,所以下面先说说怎么划分组的,

以及这些组和组的下标怎么对应的.

下面我们看看一个小例子,来说明这个问题

引用

\w(\d\d)(\w+)

这个正则表达式有三个组:

整个\w(\d\d)(\w+) 是第0组 group(0)

(\d\d)是第1组 group(1)

(\w+)是第2组 group(2)

我们看看和正则表达式匹配的一个字符串x99SuperJava，

group(0)永远都是匹配整个表达式的字符串的那部分x99SuperJava

group(1)是第1组(\d\d)匹配的部分:99

group(2)是第二组(\w+)匹配的那部分SuperJava

下面我们写一个程序来验证一下：

packageedu.jlu.fuliang;importjava.util.regex.Matcher;importjava.util.regex.Pattern;public classRegexTest {public static voidmain(String[] args) {

String regex= "\\w(\\d\\d)(\\w+)";

String candidate= "x99SuperJava";

Pattern p=Pattern.compile(regex);

Matcher matcher=p.matcher(candidate);if(matcher.find()){int gc =matcher.groupCount();for(int i = 0; i <= gc; i++)

System.out.println("group " + i + " :" +matcher.group(i));

}

}

}

输出结果:

引用

group 0:99SuperJava

group 1 :99

group 2 :SuperJava

下面我们看看Matcher类提供的方法：

public Pattern pattern()

这个方法返回了，创建Matcher的那个pattern对象。

下面我们看看一个小例子来说明这个结果

import java.util.regex.*;public classMatcherPatternExample{public static voidmain(String args[]){

test();

}public static voidtest(){

Pattern p= Pattern.compile("\\d");

Matcher m1= p.matcher("55");

Matcher m2= p.matcher("fdshfdgdfh");

System.out.println(m1.pattern()==m2.pattern());//return true

}

}

public Matcher reset()

这个方法将Matcher的状态重新设置为最初的状态。

public Matcher reset(CharSequence input)

重新设置Matcher的状态，并且将候选字符序列设置为input后进行Matcher,

这个方法和重新创建一个Matcher一样，只是这样可以重用以前的对象。

public int start()

这个方法返回了，Matcher所匹配的字符串在整个字符串的的开始下标：

下面我们看看一个小例子

public classMatcherStartExample{public static voidmain(String args[]){

test();

}public static voidtest(){//create a Matcher and use the Matcher.start() method

String candidateString = "My name is Bond. James Bond.";

String matchHelper[]={" ^"," ^"};

Pattern p= Pattern.compile("Bond");

Matcher matcher=p.matcher(candidateString);//Find the starting point of the first 'Bond'

matcher.find();int startIndex =matcher.start();

System.out.println(candidateString);

System.out.println(matchHelper[0] +startIndex);//Find the starting point of the second 'Bond'

matcher.find();int nextIndex =matcher.start();

System.out.println(candidateString);

System.out.println(matchHelper[1] +nextIndex);

}

输出结果：

My name is Bond. James Bond.

^11

My name is Bond. James Bond.

^23

public int start(int group)

这个方法可以指定你感兴趣的sub group,然后返回sup group匹配的开始位置。

public int end()

这个和start()对应，返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。

其实start和end经常是一起配合使用来返回匹配的子字符串。

public int end(int group)

和public int start(int group)对应，返回在sup group匹配的子字符串最后一个字符在整个字符串下标加一

public String group()

返回由以前匹配操作所匹配的输入子序列。

这个方法提供了强大而方便的工具，他可以等同使用start和end,然后对字符串作substring(start,end)操作。

看看下面一个小例子：

import java.util.regex.*;public classMatcherGroupExample{public static voidmain(String args[]){

test();

}public static voidtest(){//create a Pattern

Pattern p = Pattern.compile("Bond");//create a Matcher and use the Matcher.group() method

String candidateString = "My name is Bond. James Bond.";

Matcher matcher=p.matcher(candidateString);//extract the group

matcher.find();

System.out.println(matcher.group());

}

}

public String group(int group)

这个方法提供了强大而方便的工具，可以得到指定的group所匹配的输入字符串

应为这两个方法经常使用，同样我们看一个小例子

import java.util.regex.*;public classMatcherGroupParamExample{public static voidmain(String args[]){

test();

}public static voidtest(){//create a Pattern

Pattern p = Pattern.compile("B(ond)");//create a Matcher and use the Matcher.group(int) method

String candidateString = "My name is Bond. James Bond.";//create a helpful index for the sake of output

Matcher matcher =p.matcher(candidateString);//Find group number 0 of the first find

matcher.find();

String group_0= matcher.group(0);

String group_1= matcher.group(1);

System.out.println("Group 0 " +group_0);

System.out.println("Group 1 " +group_1);

System.out.println(candidateString);//Find group number 1 of the second find

matcher.find();

group_0= matcher.group(0);

group_1= matcher.group(1);

System.out.println("Group 0 " +group_0);

System.out.println("Group 1 " +group_1);

System.out.println(candidateString);

}

}

public int groupCount()

这个方法返回了，正则表达式的匹配的组数。

public boolean matches()

尝试将整个区域与模式匹配。这个要求整个输入字符串都要和正则表达式匹配。

和find不同， find是会在整个输入字符串查找匹配的子字符串。

public boolean find()

find会在整个输入中寻找是否有匹配的子字符串，一般我们使用find的流程：

while(matcher.find()){//在匹配的区域，使用group,replace等进行查看和替换操作

}

public boolean find(int start)

从输入字符串指定的start位置开始查找。

public boolean lookingAt()

基本上是matches更松约束的一个方法，尝试将从区域开头开始的输入序列与该模式匹配

public Matcher appendReplacement (StringBuffer sb, String replacement)

你想把My name is Bond. James Bond. I would like a martini中的Bond换成Smith

StringBuffer sb = newStringBuffer();

String replacement= "Smith";

Pattern pattern= Pattern.compile("Bond");

Matcher matcher=pattern.matcher("My name is Bond. James Bond. I would like a martini.");while(matcher.find()){

matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith

}

Matcher对象会维护追加的位置，所以我们才能不断地使用appendReplacement来替换所有的匹配。

public StringBuffer appendTail(StringBuffer sb)

这个方法简单的把为匹配的结尾追加到StringBuffer中。在上一个例子的最后再加上一句：

matcher.appendTail(sb);

结果就会成为My name is Smith. James Smith. I would like a martini.

public String replaceAll(String replacement)

这个是一个更方便的方法，如果我们想替换所有的匹配的话，我们可以简单的使用replaceAll就ok了。

while(matcher.find()){

matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith

}

matcher.appendTail(sb);

更便捷的方法:

public String replaceFirst(String replacement)

这个与replaceAll想对应很容易理解，就是只替换第一个匹配的。