java学习笔记---正则表达式

（1）创建正则表达式

字符

B	指定字符B
\xhh	十六进制为0xhh的字符
\uhhhh	十六进制表示为0xhhhh的Unicode字符
\t	制表符Tab
\n	换行符
\r	回车
\f	换页
\e	转义（Escape）

字符类

.	任意字符
[abc]	包含a、b和c的任何字符（和a|b|c作用相同）
[^abc]	除了a、b和c之外的任何字符（否定）
[a-zA-z]	从a到z或从A到Z的任何字符（范围）
[abc[hij]]	任意a、b、c、h、i和j字符（和a|b|c|h|i|j）作用相同
[a-z&&[hij]]	任意h、i或j（交）
\s	空白符（空格、tab、换行、换页和回车）
\S	非空白符([^\s]）
\d	数字[0-9]
\D	非数字[^0-9]
\w	词字符[a-zA-Z0-9]
\W	非词字符[^\w]

逻辑操作符

XY	Y跟在X后面
X|Y	X或Y
（X）	捕获组（capturing group）。可以在表达式中用\i引用第i个捕获组

边界匹配符

^	一行的开始
$	一行的结束
\b	词的边界
\B	非词的边界
\G	前一个匹配的结束

(2)量词

量词描述了一个模式吸收输入文本的方式：

1）贪婪型：量词总是贪婪的，除非有其他的选项被设置。贪婪表达式会为所有可能的模式发现尽可能多的匹配。导致此问题的一个典型理由就是假定我们的模式仅能匹配第一个可能的字符组，如果它是贪婪的，那么它就会继续匹配下去。

2）勉强型：用问号来指定，这个量词匹配满足模式所需的最小字符数。因此也称作懒惰的、最少匹配的、非贪婪的、或不贪婪的。

3）占有型：目前，这种类型的量词只有在Java语言中才可用（在其他语言中不可用），并且也更高级，因此我们大概不会立刻用到它。当正则表达式被应用于字符串时，它会产生相当多的状态，一边在匹配失败时可以回溯。而“占有的”量词并不保存这些中间状态，因此它们可以防止回溯。它们常常用于防止正则表达式失控，因此可以使正则表达式执行起来更有效。

贪婪型	勉强型	占有型	如何匹配
X?	X??	X?+	一个或零个x
X*	X*?	X*+	零个或多个X
X+	X+?	X++	一个或多个X
X{n}	X{n}?	X{n}+	恰好n个X
X{n,}	X{n,}?	X{n,}+	至少n个X
X{n,m}	X{n,m}?	X{n,m}+	X至少n次，且不超过m次

（3）Pattern和Matcher

一般来说，比起功能有限的String类，我们更愿意构造功能强大的正则表达式对象。只需导入java.util.regex包，然后用static Pattern.compile()方法来编译你的正则表达式即可。它会根据你的String类型的正则表达式生成一个Pattern对象。接下来，把你想要检索的字符串传入Pattern对象的matcher()方法。matcher()方法会声称已Matcher对象，它有很多功能可用。

import java.util.regex.*;

public class TestRegularExpression
{
public static void main(String[] args)
{
if(args.length<2)
{
System.out.println("Error");
System.exit(0);
}
System.out.println(args[0]);
System.out.println();
for(String arg :args)
{
System.out.println("Regular expression: "+arg);
Pattern p=Pattern.compile(arg);
Matcher m=p.matcher(args[0]);
while(m.find())
{
System.out.println("Match "+m.group()+" at position"+m.start()+"-"+m.end());
}
System.out.println();
}

输入参数输入：

Javanowhasregularexpression
^Java
\Breg
n.w\s+h(a|i)s
s?
s*
s+
s{4}
s{1}.
s{0,3}

输出结果为：

Javanowhasregularexpression

Regular expression: Javanowhasregularexpression
Match Javanowhasregularexpression at position0-27

Regular expression: ^Java
Match Java at position0-4

Regular expression: \Breg
Match reg at position10-13

Regular expression: n.w\s+h(a|i)s

Regular expression: s?
Match  at position0-0
Match  at position1-1
Match  at position2-2
Match  at position3-3
Match  at position4-4
Match  at position5-5
Match  at position6-6
Match  at position7-7
Match  at position8-8
Match s at position9-10
Match  at position10-10
Match  at position11-11
Match  at position12-12
Match  at position13-13
Match  at position14-14
Match  at position15-15
Match  at position16-16
Match  at position17-17
Match  at position18-18
Match  at position19-19
Match  at position20-20
Match  at position21-21
Match s at position22-23
Match s at position23-24
Match  at position24-24
Match  at position25-25
Match  at position26-26
Match  at position27-27

Regular expression: .settings

Regular expression: src

Regular expression: s+
Match s at position9-10
Match ss at position22-24

Regular expression: s{4}

Regular expression: s{1}.
Match sr at position9-11
Match ss at position22-24

Regular expression: s{0,3}
Match  at position0-0
Match  at position1-1
Match  at position2-2
Match  at position3-3
Match  at position4-4
Match  at position5-5
Match  at position6-6
Match  at position7-7
Match  at position8-8
Match s at position9-10
Match  at position10-10
Match  at position11-11
Match  at position12-12
Match  at position13-13
Match  at position14-14
Match  at position15-15
Match  at position16-16
Match  at position17-17
Match  at position18-18
Match  at position19-19
Match  at position20-20
Match  at position21-21
Match ss at position22-24
Match  at position24-24
Match  at position25-25
Match  at position26-26
Match  at position27-27

(4)Matcher的方法

Matcher对象的构造方法：Matcher m=Pattern.compile(regex);//其中regex为正则表达式。

得到matcher对象后可以调用其各种方法：

m.find():试图寻找下一个满足匹配模式的子序列，返回boolean类型。

m.find(i):指定查找开始的位置。

m.group()：返回先前匹配的子序列，返回String类型。

m.group(i):返回先前匹配的子序列的第i组

如：A(B(C))D

则组0是ABCD，组1是BC，组2是C

又如：(A)((B)(C))

则组0是ABC，组1是A，组2是BC，组3是B，组4是D

m.groupCount():返回匹配模式中组的数目。

m.start():返回先前匹配的起始位置的索引。

m.end():返回先前匹配的最后字符的索引+1的值。

m.lookingAt()、m.matches()与m.find()都是试图寻找满足匹配模式的子序列。find()可以再输入的任意位置定位正则表达式，而lookingAt()和matches()只有在正则表达式与输入的最开始出就开始匹配是才会成功。matches()只有在整个输入都匹配正则表达式时才会成功，而lookingAt()只要在输入的第一部分匹配就会成功。

m.spilt(CharSequence input)

m.spilt(CharSequence input,int limit)：limit可以限制将输入分割成字符串的数量。

m.reset(String newInput):可以将现有的Matcher对象应用于一个新的字符序列。

m.replaceFirst(String replacement):以参数字符串replacement替换掉第一个匹配成功的部分。

m.relplageAll(String replacement):以参数字符串replacement替换掉所有匹配成功的部分。

m.appendReplacement(StringBuffer sbuf,String replacement)：执行渐进式的替换

m.appendTail(String sbuf)：在执行了若干次appendReplacement后，调用此方法可将输入字符串余下的部分复制到sbuf中。

StringBuffer sbuf=new StringBuffer()
while(m.find())
m.appendReplacement(sbuf,m.group().toUpperCase());
m.appendTail(sbuf);

（5）Pattern标记

Pattern类的compile()方法还有另一个版本，它接收一个标记参数，以调整匹配的行为：

Pattern Pattern.compile(String regex,int flag)

其中flag来自以下Pattern类的常量：

Pattern.CANON_EQ
Pattern.CASE_INSENSITIVE(?i)	默认情况下，大小写不敏感的匹配假定只有US-ASCII字符集中的字符才能进行。这个标记允许模式匹配不必考虑大小写。
Pattern.COMMENTS(?x)	空格符将被忽略，并且以#开始直到行末的注释也会被忽略掉。
Pattern.DOTALL(?S)	表达式.匹配所有字符，包括行终结符。默认情况下，不包括行终结符。
Pattern.MULTILINE(?m)	表达式^和$分别匹配一行的开始和结束。^还匹配输入字符串的开始，而$还匹配输入字符串的结尾。默认，这些表达式仅匹配输入的完整字符串的开始和结束。
Pattern.UNICODE_CASE(?u)	当指定这个标记，且开启CASE_INSENSITIVE时，大小写不敏感的匹配将按照与Unicode标准相一致的方式进行
Pattern.UNIX_LINES(?d)	在这种模式下，在.、^和$行为中，只识别行终结符\n。