Java正则表达式使用详解(2015版)

Java正则表达式使用详解
2015年4月15日修订
如果你曾经用过Perl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。

如果你不熟悉这个术语，那么“正则表达式”（Regular Expression）就是一个字符构成的串，它定义了一个用来搜索匹配字符串的模式。

许多语言，包括Perl、PHP、Python、JavaScript和JScript，都支持用正则表达式处理文本，一些文本编辑器用正则表达式实现高级“搜索-替换”功能。

那么Java又怎样呢？本文写作时，一个包含了用正则表达式进行文本处理的Java规范需求（Specification Request）已经得到认可。

一、正则表达式基础知识
我们先从简单的开始。

假设你要搜索一个包含字符“cat”的字符串，搜索用的正则表达式就是“cat”。

如果搜索对大小写不敏感，单词“catalog”、“Catherine”、“sophisticated”都可以匹配。

也就是说：
1.1 句点符号
假设你在玩英文拼字游戏，想要找出三个字母的单词，而且这些单词必须以“t”字母开头，以“n”字母结束。

另外，假设有一本英文字典，你可以用正则表达式搜索它的全部内容。

要构造出这个正则表达式，你可以使用一个通配符——句点符号“.”。

这样，完整的表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配“t#n”、“tpn”甚至“t n”，还有其他许多无意义的组合。

这是因为句点符号匹配所有字符，包括空格、Tab字符甚至换行符：
1.2 方括号符号
为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（“[]”）里面指定看来有意义的字符。

此时，只有方括号里面指定的字符才参与匹配。

也就是说，正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”。

但“Toon”不匹配，因为在方括号之内你只能匹配单个字符：
1.3 “或”符号
如果除了上面匹配的所有单词之外，你还想要匹配“toon”，那么，你可以使用“|”操作符。

“|”操作符的基本意义就是“或”运算。

要匹配“toon”，使用“t(a|e|i|o|oo)n”正则表达式。

这里不能使用方扩号，因为方括号只允许匹配单个字符；这里必须使用圆括号“()”。

圆括号还可以用来分组，具体请参见后面介绍。

1.4 表示匹配次数的符号
表一显示了表示匹配次数的符号，这些符号用来确定紧靠该符号左边的符号出现的次数：
假设我们要在文本文件中搜索美国的社会安全号码。

这个号码的格式是999-99-9999。

用来匹配它的正则表达式如图一所示。

在正则表达式中，连字符（“-”）有着特殊的意义，它表示一个范围，比如从0到9。

因此，匹配社会安全号码中的连字符号时，它的前面要加上一个转义字符“\”。

图一：匹配所有123-12-1234形式的社会安全号码
假设进行搜索的时候，你希望连字符号可以出现，也可以不出现——即，999-99-9999和999999999都属于正确的格式。

这时，你可以在连字符号后面加上“？”数量限定符号，如图二所示：
图二：匹配所有123-12-1234和123121234形式的社会安全号码
下面我们再来看另外一个例子。

美国汽车牌照的一种格式是四个数字加上二个字母。

它的正则表达式前面是数字部分“[0-9]{4}”，再加上字母部分“[A-Z]{2}”。

图三显示了完整的正则表达式。

图三：匹配典型的美国汽车牌照号码，如8836KV
1.5 “否”符号
“^”符号称为“否”符号。

如果用在方括号内，“^”表示不想要匹配的字符。

例如，图四的正则表达式匹配所有单词，但以“X”字母开头的单词除外。

图四：匹配所有单词，但“X”开头的除外
1.6 圆括号和空白符号
假设要从格式为“June 26，1951”的生日日期中提取出月份部分，用来匹配该日期的正则表达式可以如图五所示：
图五：匹配所有Moth DD，YYYY格式的日期
新出现的“\s”符号是空白符号，匹配所有的空白字符，包括Tab字符。

如果字符串正确匹配，接下来如何提取出月份部分呢？只需在月份周围加上一个圆括号创建一个组，然后提取出它的值。

修改后的正则表达式如图六所示：
图六：匹配所有Month DD，YYYY格式的日期，定义月份值为第一个组
1.7 其它符号
为简便起见，你可以使用一些为常见正则表达式创建的快捷符号。

如表二所示：
表二：常用符号
例如，在前面社会安全号码的例子中，所有出现“[0-9]”的地方我们都可以使用“\d”。

修改后的正则表达式如图七所示：
图七：匹配所有123-12-1234格式的社会安全号码
1.8 正则表达式中常见通配符
对于单字符串比较而言，使用正则表达式没有什么优势.Regex的真正强大之处在于体现在包括字符类和量词(*，+，?)的更复杂的模式上.
字符类包括:
下面的字符将用于控制将一个子模式应用到匹配次数的过程.
二、Java的Pattern类和Matcher类
正则表达式是Java处理字符串、文本的重要工具。

我们已了解Java正则表达式的一些基础知识，但是还没有设计JDK中的类库使用。

从Java1.4起，Java核心API就引入了java.util.regex程序包。

现在我们来了解下JDK API中有关正则表达式的两个重要的类，及其详细的方法说明与使用。

Java对正则表达式的处理集中在以下两个类：
java.util.regex.Pattern模式类：一个正则表达式经编译后的表现模式，用来表示一个编译过的正则表达式。

java.util.regex.Matcher匹配类：用模式匹配一个字符串所表达的抽象结果。

一个Matcher对象是一个状态机器，它依据Pattern对象作为匹配模式对字符串展开匹配检查。

首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。

2.1 Pattern类的方法简述
Pattern是一个正则表达式经编译后的表现模式。

在Java中，通过适当命名的Pattern类可以容易确定String是否匹配某种模式。

模式可以像匹配某个特定的String那样简单，也可以很复杂，需要采用分组和字符类，如空白、数字、字母或控制符。

因为Java字符串基于统一字符编码(Unicode)，正则表达式也适用于国际化的应用程序。

2.2 Matcher类的方法简述
Matcher 一个Matcher对象是一个状态机器，它依据Pattern对象作为匹配模式对字符串展开匹配检查。

首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。

以下是实例部分:
实例一:
正则式是最简单的能准确匹配一个给定String的模式，模式与要匹配的文本是等价的。

静态的Pattern.matches 方法用于比较一个String是否匹配一个给定模式.例程如下:
实例二:
输出结果
字符串moon匹配模式m(o+)n成功
字符串mon匹配模式m(o+)n成功
字符串moon匹配模式m(o+)n成功
字符串mono匹配模式m(o+)n失败
模式是”m(o+)n”，它表示mn中间的o可以重复一次或多次，因此moon，mon，mooon能匹配成功，而mono在n后多了一个o，和模式匹配不上.
注:+表示一次或多次；?表示0次或一次；*表示0次或多次.
实例三:
输出结果
字符串ban匹配模式b[aeiou]n成功
字符串ben匹配模式b[aeiou]n成功
字符串bin匹配模式b[aeiou]n成功
字符串bon匹配模式b[aeiou]n成功
字符串bun匹配模式b[aeiou]n成功
字符串byn匹配模式b[aeiou]n失败
字符串baen匹配模式b[aeiou]n失败
注:方括号中只允许的单个字符，模式“b[aeiou]n”指定，只有以b开头，n结尾，中间是a，e，i，o，u中任意一个的才能匹配上，所以数组的前五个可以匹配，后两个元素无法匹配.
方括号[]表示只有其中指定的字符才能匹配.
实例四:
输出结果
字符串been匹配模式b(ee|ea|oo)n成功
字符串bean匹配模式b(ee|ea|oo)n成功
字符串boon匹配模式b(ee|ea|oo)n成功
字符串buin匹配模式b(ee|ea|oo)n失败
字符串bynn匹配模式b(ee|ea|oo)n失败
如果需要匹配多个字符，那么[]就不能用上了，这里我们可以用()加上|来代替，()表示一组，|表示或的关系，模式b(ee|ea|oo)n就能匹配been，bean，boon等.
因此前三个能匹配上，而后两个不能.
实例五:
输出结果
字符串1匹配模式\d+成功
字符串10匹配模式\d+成功
字符串101匹配模式\d+成功
字符串1010匹配模式\d+成功
字符串100+匹配模式\d+失败
注:从前面可以知道，\d表示的是数字，而+表示一次或多次，所以模式\d+就表示一位或多位数字.
因此前四个能匹配上，最后一个因为+号是非数字字符而匹配不上.
实例六:
输出结果
字符串a100匹配模式\w+\d+成功
字符串b20匹配模式\w+\d+成功
字符串c30匹配模式\w+\d+成功
字符串df10000匹配模式\w+\d+成功
字符串gh0t匹配模式\w+\d+失败
模式\w+\d+表示的是以多个单字字符开头，多个数字结尾的字符串，因此前四个能匹配上，最后一个因为数字后还含有单字字符而不能匹配.
实例七:
输出结果
薪水
职位
姓名
年龄
性别
String类的split函数支持正则表达式，上例中模式能匹配”，”，单个空格，”;”中的一个，split函数能把它们中任意一个当作分隔符，将一个字符串劈分成字符串数组.
实例八:
输出结果
2007
12
11
Pattern是一个正则表达式经编译后的表现模式，它的split方法能有效劈分字符串.
注意其和String.split()使用上的不同.
实例九:
输出结果
10￥1000￥10000￥100000￥
上例中，模式“(\d+)(元|人民币|RMB)”按括号分成了两组，第一组\d+匹配单个或多个数字，第二组匹配元，人民币，RMB中的任意一个，替换部分表示第一个组匹配的部分不变($1表示前面的第一组)，其余组替换成￥.如果改成：
str = str.replaceAll("(\\d+)(元|人民币|RMB)"，"￥$2"); //$2表示前面的第二组
则结果为：
￥元￥人民币￥元￥RMB
实例十:
输出结果
替换后内容是moon moon moon moon moon
实例十一:
除了用+表示一次或多次，*表示0次或多次，?表示0次或一次外，还可以用{}来指定精确指定出现的次数，X{2，5}表示X最少出现2次，最多出现5次;X{2，}表示X最少出现2次，多则不限;X{5}表示X只精确的出现5次.
例程:
输出结果
字符串google匹配模式g(o{2，5})gle成功
字符串gooogle匹配模式g(o{2，5})gle成功
字符串gooooogle匹配模式g(o{2，5})gle成功
字符串goooooogle匹配模式g(o{2，5})gle失败
字符串ggle匹配模式g(o{2，5})gle失败
实例十二:
-表示从..到…，如[a-e]等同于[abcde]
输出结果
字符串Tan匹配模式T[a-c]n成功
字符串Tbn匹配模式T[a-c]n成功
字符串Tcn匹配模式T[a-c]n成功
字符串Ton匹配模式T[a-c]n失败
字符串Twn匹配模式T[a-c]n失败
实例十三:不区分大小写匹配.
正则表达式默认都是区分大小写的，使用了Pattern.CASE_INSENSITIVE则不对大小写进行区分.
输出结果
字符串ab匹配模式ab成功
字符串Ab匹配模式ab成功
字符串AB匹配模式ab成功
实例十四:使用正则表达式劈分字符串.
注意这里要把复杂的模式写在前面，否则简单模式会先匹配上.
输出结果
职务=GM
薪水=50000
姓名=职业经理人
性别=男
年龄=45
实例十五:解析正则表达式中的文字，
\1对应第一个小括号括起来的group1.
输出结果
Bill
50000
GM
实例十六:将单词数字混合的字符串的单词部分大写.
输出结果
替换完的字串为AGE45 SALARY500000 50000 title
2.3 一些容易迷糊的问题
2.3.1 Java对反斜线处理的问题
在其他语言中，\\表示要插入一个字符\;
在Java语言中，\\表示要插入正则表达式的反斜线，并且后面的字符有特殊意义。

看API文档：
但是看看上面程序，对比下不难看出：
\d在实际使用的时候就写成了\\d;
在Java正则表达式中，如果要插入一个\字符，则需要在正则表达式中写成\\\\，原因是下面的APIDoc定义\\表示一个反斜线。

但是如果在正则表示式中表示回车换行等，则不需要多添加反斜线了。

比如回车\r就写作\r.
字符
2.3.2 Matcher.find()
尝试查找与模式匹配的字符序列的下一个子序列。

此方法从字符序列的开头开始，如果该方法的前一次调用成功了并且从那时开始匹配器没有被重置，则从以前匹配操作没有匹配的第一个字符开始，即如果前一次找到与模式匹配的子序列则这次从这个子序列后开始查找。

2.3.3 Matcher.matchers()
判断整个字符序列与模式是否匹配。

当连续用Matcher对象检查多个字符串时候，可以使用Matcher. reset()重置匹配器，放弃其所有显式状态信息并将其添加位置设置为零。

或者Matcher.reset (CharSequence input)重置此具有新输入序列的匹配器来重复使用匹配器。

2.3.4 组的概念
这个概念很重要，组是用括号划分的正则表达式，可以通过编号来引用组。

组号从0开始，有几对小括号就表示有几个组，并且组可以嵌套，组号为0的表示整个表达式，组号为1的表示第一个组，依此类推。

例如：A(B)C(D)E正则式中有三组，组0是ABCDE，组1是B，组2是D；
A((B)C)(D)E正则式中有四组：组0是ABCDE，组1是BC，组2是B；组3是C，组4是D。

int groupCount()：返回匹配其模式中组的数目，不包括第0组。

String group()：返回前一次匹配操作（如find()）的第0组。

String group(int group)：返回前一次匹配操作期间指定的组所匹配的子序列。

如果该匹配成功，但指定组未能匹配字符序列的任何部分，则返回null。

int start(int group)：返回前一次匹配操作期间指定的组所匹配的子序列的初始索引。

int end(int group)：返回前一次匹配操作期间指定的组所匹配的子序列的最后索引+1。

2.3.5 匹配的范围的控制
最变态的就要算lookingAt()方法了，名字很让人迷惑，需要认真看APIDoc。

start()返回以前匹配的初始索引。

end()返回最后匹配字符之后的偏移量。

public boolean lookingAt()尝试将从区域开头开始的输入序列与该模式匹配。

与matches 方法类似，此方法始终从区域的开头开始；与之不同的是，它不需要匹配整个区域。

如果匹配成功，则可以通过start、end 和group 方法获取更多信息。

返回：当且仅当输入序列的前缀匹配此匹配器的模式时才返回true。

2.3.6 Pattern标记
Pattern类的静态方法
static Pattern compile(String regex, int flags) 将给定的正则表达式编译到具有给定标志的模式中。

其中的flags参数就是Pattern标记，这个标记在某些时候非常重要。

2.4 字符串的替换
2.5 字符串的切分
当然，还有一个StringTokenizer类，可以用来切分字符串，但是现在SUN已经不推荐使用了。

转变下思路，其实用正则表达式也可以达到将字符串切分为段的目的。

三、Perl应用实例
3.1日志文件处理
任务：分析一个Web服务器日志文件，确定每一个用户花在网站上的时间。

在典型的BEA WebLogic日志文件中，日志记录的格式如下：
分析这个日志记录，可以发现，要从这个日志文件提取的内容有两项：IP地址和页面访问时间。

你可以用分组符号（圆括号）从日志记录提取出IP地址和时间标记。

首先我们来看看IP地址。

IP地址有4个字节构成，每一个字节的值在0到255之间，各个字节通过一个句点分隔。

因此，IP地址中的每一个字节有至少一个、最多三个数字。

图八显示了为IP地址编写的正则表达式：
图八：匹配IP地址
IP地址中的句点字符必须进行转义处理（前面加上“\”），因为IP地址中的句点具有它本来的含义，而不是采用正则表达式语法中的特殊含义。

句点在正则表达式中的特殊含义本文前面已经介绍。

日志记录的时间部分由一对方括号包围。

你可以按照如下思路提取出方括号里面的所有内容：首先搜索起始方括号字符（“[”），提取出所有不超过结束方括号字符（“]”）的内容，向前寻找直至找到结束方括号字符。

图九显示了这部分的正则表达式。

图九：匹配至少一个字符，直至找到“]”
现在，把上述两个正则表达式加上分组符号（圆括号）后合并成单个表达式，这样就可以从日志记录提取出IP 地址和时间。

注意，为了匹配“- -”（但不提取它），正则表达式中间加入了“\s-\s-\s”。

完整的正则表达式如图十所示。

图十：匹配IP地址和时间标记
现在正则表达式已经编写完毕，接下来可以编写使用正则表达式库的Java代码了。

为使用Jakarta-ORO库，首先创建正则表达式字符串和待分析的日志记录字符串：
这里使用的正则表达式与图十的正则表达式差不多完全相同，但有一点例外：在Java中，你必须对每一个向前的斜杠（“\”）进行转义处理。

图十不是Java的表示形式，所以我们要在每个“\”前面加上一个“\”以免出现编译错误。

遗憾的是，转义处理过程很容易出现错误，所以应该小心谨慎。

你可以首先输入未经转义处理的正则表达式，然后从左到右依次把每一个“\”替换成“\\”。

如果要复检，你可以试着把它输出到屏幕上。

初始化字符串之后，实例化PatternCompiler对象，用PatternCompiler编译正则表达式创建一个Pattern对象：
现在，创建PatternMatcher对象，调用PatternMatcher接口的contain()方法检查匹配情况：
接下来，利用PatternMatcher接口返回的MatchResult对象，输出匹配的组。

由于logEntry字符串包含匹配的内容，你可以看到类如下面的输出：
3.2 HTML处理实例一
下面一个任务是分析HTML页面内FONT标记的所有属性。

HTML页面内典型的FONT标记如下所示：
程序将按照如下形式，输出每一个FONT标记的属性：
在这种情况下，我建议你使用两个正则表达式。

第一个如图十一所示，它从字体标记提取出“"face="Arial，Serif" size="+2" color="red"”。

图十一：匹配FONT标记的所有属性
第二个正则表达式如图十二所示，它把各个属性分割成名字-值对。

图十二：匹配单个属性，并把它分割成名字-值对
分割结果为：
现在我们来看看完成这个任务的Java代码。

首先创建两个正则表达式字符串，用Perl5Compiler把它们编译成Pattern对象。

编译正则表达式的时候，指定Perl5Compiler.CASE_INSENSITIVE_MASK选项，使得匹配操作不区分大小写。

接下来，创建一个执行匹配操作的Perl5Matcher对象。

假设有一个String类型的变量html，它代表了HTML文件中的一行内容。

如果html字符串包含FONT标记，匹配器将返回true。

此时，你可以用匹配器对象返回的MatchResult对象获得第一个组，它包含了FONT的所有属性：
接下来创建一个PatternMatcherInput对象。

这个对象允许你从最后一次匹配的位置开始继续进行匹配操作，因此，它很适合于提取FONT标记内属性的名字-值对。

创建PatternMatcherInput对象，以参数形式传入待匹配的字符串。

然后，用匹配器实例提取出每一个FONT的属性。

这通过指定PatternMatcherInput对象（而不是字符串对象）为参数，反复地调用PatternMatcher对象的contains()方法完成。

PatternMatcherInput对象之中的每一次迭代将把它内部的指针向前移动，下一次检测将从前一次匹配位置的后面开始。

本例的输出结果如下：
3.3 HTML处理实例二
下面我们来看看另一个处理HTML的例子。

这一次，我们假定Web服务器从移到了。

现在你要修改一些页面中的链接：
执行这个搜索的正则表达式如图十三所示：
图十三：匹配修改前的链接
如果能够匹配这个正则表达式，你可以用下面的内容替换图十三的链接：
注意#字符的后面加上了$1。

Perl正则表达式语法用$1、$2等表示已经匹配且提取出来的组。

图十三的表达式把所有作为一个组匹配和提取出来的内容附加到链接的后面。

现在，返回Java。

就象前面我们所做的那样，你必须创建测试字符串，创建把正则表达式编译到Pattern对象所必需的对象，以及创建一个PatternMatcher对象：
接下来，用com.oroinc.text.regex包Util类的substitute()静态方法进行替换，输出结果字符串：
Util.substitute()方法的语法如下：
这个调用的前两个参数是以前创建的PatternMatcher和Pattern对象。

第三个参数是一个Substiution对象，它决定了替换操作如何进行。

本例使用的是Perl5Substitution对象，它能够进行Perl5风格的替换。

第四个参数是想要进行替换操作的字符串，最后一个参数允许指定是否替换模式的所有匹配子串（Util.SUBSTITUTE_ALL），或只替换指定的次数。

四、JAVA正则表达式中的数量词
java中的正则位于java.util.regex包中，这个包中只有一个MatchResult接口和Matcher、Pattern两个类。

正则中的数量词有Greedy (贪婪)、Reluctant(懒惰)和Possessive(强占)三种.
4.1 Greedy 数量词
Greedy是最常用的，它的匹配方式是先把整个字符串吞下，然后匹配整个字符串，如果不匹配，就从右端吐出一个字符，再进行匹配，直到找到匹配或把整个字符串吐完为止。

运行结果为：
a====b=========b
因为总是从最大匹配开始匹配，故称贪婪。

4.2 Reluctant 数量词
Reluctant正好和Greedy相反，它先从最小匹配开始，先从左端吞入一个字符，然后进行匹配，若不匹配就再吞入一个字符，直到找到匹配或将整个字符串吞入为止。

运行结果为：
a====b
因为总是从最小匹配开始，故称懒惰。

4.3 Possessive 数量词
Possessive和Greedy的匹配方式一样，先把整个字符串吞下，然后匹配整个字符串，如果匹配，就认为匹配，如果不匹配，就认为整个字符串不匹配，它不会从右端吐出一个字符串再进行匹配，只进行一次。

}
运行结果为：
因为贪婪但并不聪明，故称强占。

五、Java正则表达式——分组与捕获
正则表达式在字符串处理中经常使用，关于正则简单的用法相信有一点程序基础的人都懂得一些，这里就不介绍简单基础了。

这里主要讲解一下在JAVA中实现了的正则的高级用法-分组与捕获。

对于要重复单个字符，非常简单，直接在字符后卖弄加上限定符即可，例如a+ 表示匹配1个或一个以上的a，a?表示匹配0个或1个a。

这些限定符如下所示：
但是我们如果要对多个字符进行重复怎么办呢？此时我们就要用到分组，我们可以使用小括号"()"来指定要重复的子表达式，然后对这个子表达式进行重复，例如：(abc)? 表示0个或1个abc 这里一个括号的表达式就表示一个分组。

分组可以分为两种形式，捕获组和非捕获组。

5.1 捕获组
捕获组可以通过从左到右计算其开括号来编号。

例如，在表达式((A)(B(C))) 中，存在四个这样的组：
组零始终代表整个表达式
之所以这样命名捕获组，是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。

捕获的子序列稍后可以通过Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器检索。

Back引用是说在后面的表达式中我们可以使用组的编号来引用前面的表达式所捕获到的文本序列(是文本不是正则)。

例如([" ']).* \1 其中使用了分组，\1就是对引号这个分组的引用，它匹配包含在两个引号或者两个单引号中的所有字符串，如，"abc" 或" ' " 或' " ' ，但是请注意，它并不会对" a'或者'a"匹配。

原因上面已经说明，Back引用只是引用文本而不是表达式。

5.2 非捕获组
5.2.1 示例引入
下面由一个例子引出非捕获组。

有两个金额：8899￥和6688$ 。

显然，前一个是8899元的人民币，后一个是6688元的美元。

我现在需要一个正则表达式，要求提炼出它们的货币金额和货币种类。

正则表达式可以这写：
(\\d)+([￥$])$(在java中测试，所以多了转义字符'\')
测试程序如下：
运行结果为：
货币金额: 8899
货币种类: ￥
OK,满足了要求。

这里的正则分成了两个组，一个是(\\d+)，一个是([￥$])，前一个组匹配货币金额，后一个组匹配货币种类。

现在，我需要这个正则可以匹配浮点数。

如8899.56￥。

我们都知道，现在少于一元钱基本上买不到东西了，所以我希望忽略小数部分，正则还是提炼出8899 和￥。

那么正则如下：
(\\d+)(\\.?)(\\d+)([￥$])$
运行结果为：
货币金额: 8899
货币种类: .
货币种类: 56
货币种类: ￥
这里用括号分了四组，所以要输出货币金额的整数部分和货币种类，要分别输了group(1), group(4)了。

如果输出部分和正则表达式是分开的，我希望只修改正则表达式而不去修改输出部分的代码，也就是还是用group(1)，group(2)作为输出。

由此可以引出非捕获组(?:)。

把前面的正则修改为：
(\\d+)(?:\\.?)(?:\\d+)([￥$])$
运行结果为：
货币金额: 8899
货币种类: ￥
这样，还是用group(1),group(2)作为输出，同样输出了8899 和￥
这个正则的中间两个组用到的就是非捕获组（?:），它可以理解为只分组而不捕获。

以 (?) 开头的组是纯的非捕获组，它不捕获文本，也不针对组合计进行计数。

就是说，如果小括号中以?号开头，那么这个分组就不会捕获文本，当然也不会有组的编号，因此也不存在Back 引用。

在Java中，支持的非捕获组，有如下几种：
这四个非捕获组用于匹配表达式X，但是不包含表达式的文本。

5.2.2 (?=)和(?<=)
有的资料把它们叫做肯定式向前查找和肯定式向后查找；有的资料也叫做肯定顺序环视和肯定逆序环视。

5.2.2.1 举例
姑且不理它们的名称，看下面的例子：。