[01] Pattern类和Matcher类

在Java中，有个java.util.regex包，这是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。

它主要有两个类：

• Pattern   一个正则表达式经编译后的表现模式，可以理解为某正则的对应类
• Matcher  匹配检查器，根据Pattern对象作为匹配模式对字符串进行匹配检查

1、Pattern

1.1 获取Pattern对象

Pattern类用于创建一个正则表达式，或者说创建一个匹配模式对象，我们不能直接创建，需要使用其静态方法compile实现：

• static Pattern   Pattern.compile(String regExp)

如果已有Pattern对象，希望返回其对应的正则表达式的字符串形式，则可以使用Pattern对象的pattern()方法，如下：

Pattern p = Pattern.compile("\\w+");
p.pattern();  //返回  \w+

2

 

1

Pattern p = Pattern.compile("\\w+"); 

2

p.pattern();  //返回  \w+

总结：

Pattern	Pattern.compile(String regExp)	返回正则表达式对应的Pattern对象
String	pattern()	返回Pattern对象对应的正则表达式的字符串形式

1.2 分隔字符串

Pattern有一个split(CharSequence input)方法，用于分隔字符串，其中Pattern对应的正则表达式匹配的字符串作为分隔符，并返回一个String[]。（CharSequence是一个接口，其实现类有String，StringBuffer，StringBuilder等）

如下例：

Pattern p=Pattern.compile("\\d+");
String[] str=p.split("我的QQ是:456456我的电话是:0532214我的邮箱是:aaa@aaa.com"); 

//结果:str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:aaa@aaa.com" 

4

 

1

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

2

String[] str=p.split("我的QQ是:456456我的电话是:0532214我的邮箱是:aaa@aaa.com"); 

3

4

//结果:str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:aaa@aaa.com" 

总结：

String[]

split(CharSequence input)

符合匹配规则的字符串作为分隔符，分隔字符串并返回字符串数组

1.3 判断是否完整符合匹配规则

Pattern.matcher(String regex,CharSequence input)是一个静态方法，用于快速匹配字符串，且匹配全部字符串。即相当于判断当前字符串是否完整符合匹配规则（注意，字符串中有子串符合匹配规则，也是不行的，返回false）

如下例：

Pattern.matches("\\d+","2223");//返回true
Pattern.matches("\\d+","2223aa");//返回false，需要匹配到所有字符串才能返回true，这里aa不符
Pattern.matches("\\d+","22bb23");//返回false，需要匹配到所有字符串才能返回true，这里bb不符

3

 

1

Pattern.matches("\\d+","2223");//返回true 

2

Pattern.matches("\\d+","2223aa");//返回false，需要匹配到所有字符串才能返回true，这里aa不符

3

Pattern.matches("\\d+","22bb23");//返回false，需要匹配到所有字符串才能返回true，这里bb不符

总结：

boolean

matches(String regex, CharSequence input)

判断字符串是否完整匹配对应的正则表达式

2、Matcher

2.1 获取Matcher对象

Matcher对象需要通过Pattern对象来获取，调用某个Pattern对象的matcher(CharSequence input)方法来返回一个Matcher对象。Pattern类只能做一些简单的匹配操作，需要更强更便捷的正则匹配操作，则需要结合Matcher协同作业。Matcher类提供了对正则表达式的分组支持，以及对正则表达式的多次匹配支持。

如下例：

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("22bb23");
m.pattern(); //返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的 

3

 

1

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

2

Matcher m = p.matcher("22bb23"); 

3

m.pattern(); //返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的 

总结：

Matcher

matcher(CharSequence input)

返回一个对应Pattern的Matcher对象

2.2 判断匹配规则

2.2.1 完整匹配判断

刚才我们提到Pattern的一个静态方法Pattern.matcher(String regex,CharSequence input)，可以用来对整个字符串进行正则匹配，符合才返回true。在Matcher中也有相同效果的方法matches()

如下例：

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("22bb23");
m.matches(); //返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功.
Matcher m2 = p.matcher("2223");
m2.matches(); //返回true,因为\d+匹配到了整个字符串

5

 

1

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

2

Matcher m = p.matcher("22bb23"); 

3

m.matches(); //返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功. 

4

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

5

m2.matches(); //返回true,因为\d+匹配到了整个字符串

总结：

boolean

matches()

判断对应字符串是否完全匹配正则表达式

2.2.2 开头匹配判断

lookiingAt()则是对字符串的开头进行匹配，即只有从头开始的子串符合正则，才返回true，如下例：

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("22bb23");
m.lookingAt(); //返回true,因为\d+匹配到了前面的22
Matcher m2 = p.matcher("aa2223");
m2.lookingAt(); //返回false,因为\d+不能匹配前面的aa

5

 

1

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

2

Matcher m = p.matcher("22bb23"); 

3

m.lookingAt(); //返回true,因为\d+匹配到了前面的22 

4

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

5

m2.lookingAt(); //返回false,因为\d+不能匹配前面的aa

总结：

boolean

lookingAt()

符合正则的子串是否位于字符串首位

2.2.3 子串匹配判断

find()则相当于在整个字符串不限位置进行匹配，只要包含符合正则的子串，则返回true，如下例：

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("22bb23");
m.find(); //返回true
Matcher m2 = p.matcher("aa2223");
m2.find(); //返回true
Matcher m3 = p.matcher("aa2223bb");
m3.find(); //返回true
Matcher m4 = p.matcher("aabb");
m4.find(); //返回false 

9

 

1

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

2

Matcher m = p.matcher("22bb23"); 

3

m.find(); //返回true 

4

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

5

m2.find(); //返回true 

6

Matcher m3 = p.matcher("aa2223bb"); 

7

m3.find(); //返回true 

8

Matcher m4 = p.matcher("aabb"); 

9

m4.find(); //返回false 

注意，find方法是可以重复调用的，它就像一个游走在字符串的光标，也就是说假如字符串包含多个匹配子串，第一次调用在查找到首个子串存在时候返回true，再次调用find方法时，会跳过已经匹配的子串往后匹配，如果还有则再次返回true，直到找不到为止。如下例：

Pattern pattern = Pattern.compile("\\d+");
Matcher matcher = pattern.matcher("aaa2223bb222");

while (matcher.find()) {
    System.out.println("ok");
}

//会输出两次ok，第一次匹配到了2223，第二次匹配到了尾部的222

8

 

1

Pattern pattern = Pattern.compile("\\d+");

2

Matcher matcher = pattern.matcher("aaa2223bb222");

3

4

while (matcher.find()) {

5

    System.out.println("ok");

6

}

7

8

//会输出两次ok，第一次匹配到了2223，第二次匹配到了尾部的222

总结：

boolean

find()

判断是否存在符合正则的子串，可以重复调用直到找不到符合匹配的子串为止

2.3 子串匹配

不论是通过上述的matches()，还是lookingAt()、find()，只要我们已经确认了字符串中包含符合正则的子串（完整匹配的子串就是它本身），我们就可以利用start()、end()、group()来进一步得到该匹配子串的详细信息：

• start()  返回匹配子串在字符串中的索引位置
• end()  返回匹配子串的最后一个字符在字符串中的索引位置
• group()  返回匹配到的子串

如下例：

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("aaa2223bb");
m.find(); //返回true，匹配2223
m.start(); //返回3
m.end(); //返回7, 返回的是2223后的位置，非索引号
m.group(); //返回2223 

6

 

1

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

2

Matcher m = p.matcher("aaa2223bb"); 

3

m.find(); //返回true，匹配2223 

4

m.start(); //返回3 

5

m.end(); //返回7, 返回的是2223后的位置，非索引号 

6

m.group(); //返回2223 

另外要注意的是，不乱是start、end、group，都是随着匹配操作进行而改变的。刚才我们提到find()方法类似游走的光标，每次调用指向新的子串，可以循环调用，每次调用后，上述三个方法都是针对的find匹配的新子串。如下例：

Pattern pattern = Pattern.compile("\\d+");
Matcher matcher = pattern.matcher("aaa2223bb222");

System.out.println(matcher.find());
System.out.println(matcher.group());  //返回2223
System.out.println(matcher.group());  //返回2223
System.out.println(matcher.group());  //返回2223

//因为上述find没有再次进行操作，即此刻的子串始终指向2223，那么下面我们将find循环调用

while (matcher.find()) {
    System.out.println(matcher.group() + " - " + matcher.start() + ", " + matcher.end());
}

//会得到两个输出
//2223 - 3, 7
//222 - 9, 12

17

 

1

Pattern pattern = Pattern.compile("\\d+");

2

Matcher matcher = pattern.matcher("aaa2223bb222");

3

4

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

5

System.out.println(matcher.group());  //返回2223

6

System.out.println(matcher.group());  //返回2223

7

System.out.println(matcher.group());  //返回2223

8

9

//因为上述find没有再次进行操作，即此刻的子串始终指向2223，那么下面我们将find循环调用

10

11

while (matcher.find()) {

12

    System.out.println(matcher.group() + " - " + matcher.start() + ", " + matcher.end());

13

}

14

15

//会得到两个输出

16

//2223 - 3, 7

17

//222 - 9, 12

总结：

int	start()	返回匹配子串在字符串中的索引位置
int	end()	返回匹配子串最后一个字符在字符串中的位置（非索引）
String	group()	返回匹配到的子串

2.4 分组操作

我们知道，正则表达式还可以进一步提取子串，用括号 ( ) 表示的就是要提取的分组。所谓组，就是更细化地分化你所匹配到的字符串。

start、end、group这三个方法还有重载方法start(int i)、end(int i)、group(int i)，这三个方法就是用于分组操作，同时Matcher类还有一个groupCount()方法用于返回组数。如下例：

Pattern pattern = Pattern.compile("([a-z]+)(\\d+)");
Matcher matcher = pattern.matcher("aaa2223bb222xxx88");

System.out.println(matcher.groupCount());
System.out.println("========");
while (matcher.find()) {
    System.out.println(matcher.group());
    System.out.println(matcher.group(1));
    System.out.println(matcher.group(2));
    System.out.println("--------");
}

x

 

1

Pattern pattern = Pattern.compile("([a-z]+)(\\d+)");

2

Matcher matcher = pattern.matcher("aaa2223bb222xxx88");

3

4

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

5

System.out.println("========");

6

while (matcher.find()) {

7

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

8

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

9

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

10

    System.out.println("--------");

11

}

上述([a-z]+)(\\d+)，分了两组，这个两组，是说匹配到的字符串由这两部分组成。

看输出结果即可明白，如第一个符合正则的子串aaa2223，其分组中：

• 第一组为aaa，对应([a-z])；
• 第二组为2223，对应(\\d+)

2
========
aaa2223
aaa
2223
--------
bb222
bb
222
--------
xxx88
xxx
88
--------

 

1

2

2

========

3

aaa2223

4

aaa

5

2223

6

--------

7

bb222

8

bb

9

222

10

--------

11

xxx88

12

xxx

13

88

14

--------

总结：

int	start(int i)	返回第 i 组匹配到的子串在字符串中的索引位置
int	end(int i)	返回第 i 组匹配子串最后一个字符在字符串中的位置（非索引号）
String	group(int i)	返回匹配到的字符串中第 i 组子串

3、参考链接

• JAVA正则表达式：Pattern类与Matcher类详解(转)