转自文章《详解Java正则表达式中Pattern类和Matcher类》http://www.jb51.net/article/100673.htm
文章《Pattern和Matcher详解（字符串匹配和字节码）》https://blog.csdn.net/u010700335/article/details/44616451
java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。包括两个类Pattern和Matcher Pattern，Pattern是一个正则表达式经编译后的表现模式。Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。
前言
本文将介绍Java正则表达式中的Pattern类与Matcher类。首先我们要清楚指定为字符串的正则表达式必须首先被编译为pattern类的实例。因此如何更好的了解这两个类，是编程人员必须知道的。
以下我们就分别来看看这两个类：
一、捕获组的概念
捕获组可以通过从左到右计算其开括号来编号，编号是从1 开始的。例如，在表达式 ((A)(B(C)))中，存在四个这样的组：
|
1
2
3
4
|
1
((A)(B(C)))
2
(A)
3
(B(C))
4
(C)
|
组零始终代表整个表达式。 以 (?) 开头的组是纯的非捕获 组，它不捕获文本，也不针对组合计进行计数。
与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串"aba" 与表达式(a(b)?)+ 相匹配，会将第二组设置为 "b"。在每个匹配的开头，所有捕获的输入都会被丢弃。
二、详解Pattern类和Matcher类
java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳).
Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式,
Java代码示例:
|
1
2
|
Pattern p=Pattern.compile(
"\\w+"
);
p.pattern();
//返回 \w+
|
pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数
1.Pattern.split(CharSequence input)
Pattern有一个split(CharSequence input)方法,用于分隔字符串,并返回一个String[],我猜String.split(String regex)就是通过Pattern.split(CharSequence input)来实现的.
Java代码示例:
|
1
2
|
Pattern p=Pattern.compile(
"\\d+"
);
|
结果:str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:[email protected]"
2.Pattern.matcher(String regex,CharSequence input)是一个静态方法,用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串.
Java代码示例:
|
1
2
3
|
Pattern.matches(
"\\d+"
,
"2223"
);
//返回true
Pattern.matches(
"\\d+"
,
"2223aa"
);
//返回false,需要匹配到所有字符串才能返回true,这里aa不能匹配到
Pattern.matches(
"\\d+"
,
"22bb23"
);
//返回false,需要匹配到所有字符串才能返回true,这里bb不能匹配到
|
3.Pattern.matcher(CharSequence input)
说了这么多,终于轮到Matcher类登场了,Pattern.matcher(CharSequence input)返回一个Matcher对象.
Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例.
Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持.
Java代码示例:
|
1
2
3
|
Pattern p=Pattern.compile(
"\\d+"
);
Matcher m=p.matcher(
"22bb23"
);
m.pattern();
//返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的
|
4.Matcher.matches()/ Matcher.lookingAt()/ Matcher.find()
Matcher类提供三个匹配操作方法,三个方法均返回boolean类型,当匹配到时返回true,没匹配到则返回false
matches()对整个字符串进行匹配,只有整个字符串都匹配了才返回true
Java代码示例:
|
1
2
3
4
5
|
Pattern p=Pattern.compile(
"\\d+"
);
Matcher m=p.matcher(
"22bb23"
);
m.matches();
//返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功.
Matcher m2=p.matcher(
"2223"
);
m2.matches();
//返回true,因为\d+匹配到了整个字符串
|
我们现在回头看一下Pattern.matcher(String regex,CharSequence input) ,它与下面这段代码等价 Pattern.compile(regex).matcher(input).matches()
lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true
Java代码示例:
|
1
2
3
4
5
|
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
|
find()对字符串进行匹配,匹配到的字符串可以在任何位置.
Java代码示例:
|
1
2
3
4
5
6
7
8
9
|
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
|
5.Mathcer.start()/ Matcher.end()/ Matcher.group()
当使用matches() , lookingAt() , find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息.
start()返回匹配到的子字符串在字符串中的索引位置.
end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置.
group()返回匹配到的子字符串
Java代码示例:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
Pattern p=Pattern.compile(
"\\d+"
);
Matcher m=p.matcher(
"aaa2223bb"
);
m.find();
//匹配2223
m.start();
//返回3
m.end();
//返回7,返回的是2223后的索引号
m.group();
//返回2223
Mathcer m2=m.matcher(
"2223bb"
);
m.lookingAt();
//匹配2223
m.start();
//返回0,由于lookingAt()只能匹配前面的字符串,所以当使用lookingAt()匹配时,start()方法总是返回0
m.end();
//返回4
m.group();
//返回2223
Matcher m3=m.matcher(
"2223bb"
);
m.matches();
//匹配整个字符串
m.start();
//返回0,原因相信大家也清楚了
m.end();
//返回6,原因相信大家也清楚了,因为matches()需要匹配所有字符串
m.group();
//返回2223bb
|
说了这么多,相信大家都明白了以上几个方法的使用,该说说正则表达式的分组在java中是怎么使用的. start() , end() , group()均有一个重载方法它们是start(int i) , end(int i) , group(int i)专用于分组操作,Mathcer类还有一个groupCount()用于返回有多少组.
Java代码示例:
|
1
2
3
4
5
6
7
8
9
10
|
Pattern p=Pattern.compile(
"([a-z]+)(\\d+)"
);
Matcher m=p.matcher(
"aaa2223bb"
);
m.find();
//匹配aaa2223
m.groupCount();
//返回2,因为有2组
m.start(
1
);
//返回0 返回第一组匹配到的子字符串在字符串中的索引号
m.start(
2
);
//返回3
m.end(
1
);
//返回3 返回第一组匹配到的子字符串的最后一个字符在字符串中的索引位置.
m.end(
2
);
//返回7
m.group(
1
);
//返回aaa,返回第一组匹配到的子字符串
m.group(
2
);
//返回2223,返回第二组匹配到的子字符串
|
现在我们使用一下稍微高级点的正则匹配操作,例如有一段文本,里面有很多数字,而且这些数字是分开的,我们现在要将文本中所有数字都取出来,利用java的正则操作是那么的简单.
Java代码示例:
|
1
2
3
4
5
|
Pattern p=Pattern.compile(
"\\d+"
);
while
(m.find()) {
System.out.println(m.group());
}
|
输出:
|
1
2
3
|
456456
0532214
123
|
如将以上while()循环替换成
|
1
2
3
4
5
|
while
(m.find()) {
System.out.println(m.group());
System.out.print(
"start:"
+m.start());
System.out.println(
" end:"
+m.end());
}
|
则输出:
|
1
2
3
4
5
6
|
456456
start:
6
end:
12
0532214
start:
19
end:
26
123
start:
36
end:
39
|
现在大家应该知道,每次执行匹配操作后start() , end() , group()三个方法的值都会改变,改变成匹配到的子字符串的信息,以及它们的重载方法,也会改变成相应的信息.
注意:只有当匹配操作成功,才可以使用start() , end() , group()三个方法,否则会抛出java.lang.IllegalStateException,也就是当matches() , lookingAt() , find()其中任意一个方法返回true时,才可以使用.
三、Java正则表达式
现在通过一些实验来说明正则表达式的匹配规则,这儿是Greedy方式
. 任何字符
a? a一次或一次也没有
a* a零次或多次
a+ a一次或多次
a{n}? a恰好 n 次
a{n,}? a至少n次
a{n,m}? a至少n次，但是不超过m次
//初步认识. * + ?
p("a".matches("."));//true
p("aa".matches("aa"));//true
p("aaaa".matches("a*"));//true
p("aaaa".matches("a+"));//true
p("".matches("a*"));//true
p("aaaa".matches("a?"));//false
p("".matches("a?"));//true
p("a".matches("a?"));//true
p("1232435463685899".matches("\\d{3,100}"));//true
p("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));//false
p("192".matches("[0-2][0-9][0-9]"));//true [abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
//范围
p("a".matches("[abc]"));//true
p("a".matches("[^abc]"));//false
p("A".matches("[a-zA-Z]"));//true
p("A".matches("[a-z]|[A-Z]"));//true
p("A".matches("[a-z[A-Z]]"));//true
p("R".matches("[A-Z&&[RFG]]"));//true
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
//认识\s \w \d \
p("\n\r\t".matches("\\s(4)"));//false
p(" ".matches("\\S"));//false
p("a_8 ".matches("\\w(3)"));//false
p("abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+"));//true
p("\\".matches("\\\\"));//true
边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾
//边界匹配
p("hello sir".matches("^h.*"));//true
p("hello sir".matches(".*ir$"));//true
p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));//true
p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));//false
//空白行:一个或多个(空白并且非换行符)开头，并以换行符结尾
p(" \n".matches("^[\\s&&[^\\n]]*\\n$"));//true
重点说明
表示<>之间有任意一个（含）字符以上，括号表示捕获组，匹配后可以单独提取出括号内的内容，?代表最短匹配，比如<asdf>>>这样的输入，有？会匹配成<asdf>，没有？会匹配整个<asdf>>>。
str.ReplactAll("<(.)+?>","")就是把所有<>间有一个字符以上的文字都替换为空。比如
asdf<1234>jkl<>会变成asdfjkl<>
另外要是str_line.replaceAll("&(.)+?;"," ") 是将&开头的包含任意字符的右面的最短匹配并以;结束的都替换成为空