2009-12-29

缩略显示

学点Java正则表达式 选择自 DotJox 的 Blog

文章分类:Java编程

正则表达式用来指定字符串模式。当你需要定位匹配某种模式的字符串时就可以使用正则表达式。例如，我们下面的一个例程就是在一个HTML文件中通过查找字符串模式<a href="...">来定位所有的超链接。

当然，为了指定一种模式，使用...这种记号是不够精确的。你需要精确地指定什么样的字符 排列是一个合法的匹配。当描述某种模式时，你需要使用一种特殊的语法。

这里有一个简单例子。正则表达式
[Jj]ava.+
匹配下列形式的任何字符串：

学点Java正则表达式

TCP存活定时器（TCP Keepalive Timer）

TCP持续定时器（TCP Persist Timer）

uClinux在S3C44B0X上的移植

• 首字母是J或j

• 后续的三个字母是ava

• 字符串的剩余部分由一个或多个任意字符组成

例如，字符串“javaness”匹配这个特殊的正则表达式，但是字符串“Core Java”却不匹配。

如你所见，你需要了解一点语法来理解正则表达式的含意。幸运的是对于大多数的用途，使用少量的简单构造（straightforward constructs）就已足够。

• 字符类是可选自符的集合，用‘[’封装，比如[Jj],[0-9],[A-Za-z]或[^0-9]。这里的-表示范围（Unicode落在两个边界之间的所有字符），^表示求补（指定字符外的所有字符）。

• 有许多预定以的字符类，像/d（数字）或/p{Sc}（Unicode货币符号），见表12-8和12-9。

• 大多数字符与它们自身匹配，像上例中的ava字符。

• 符号.匹配任何字符（可能行终止符（line terminators）除外，这依赖于标识设置（flag settings））

• /用作转义符，比如/.匹配一个句点，//匹配一个反斜杠。

• ^和$分别匹配行头和行尾

• 如果X和Y都是正则表达式，则XY表示“X的匹配后面跟着Y的匹配”。X|Y表示“任何X或Y的匹配”

• 可以将量词（quantifier）用到表达式中，X+ 表示X重复1次或多次，X* 表示X重复0次或多次，X? 表示X重复0次或1次

• 默认地，一个量词总是与使总体成功匹配的最长的可能重复匹配。可以加上后缀？（称为reluctant或stingy 匹配，用以匹配最小的重复数），和+（称为possessive或贪婪匹配，用以即使在总体匹配失败的情况下也匹配最大的重复数）来更改这种属性。

• 可以使用分组来定义子表达式。将分组封装在（）中，如([+-]?)([0-9]+)。然后你可以让模式匹配符（the pattern matcher）返回每个分组的匹配，或者使用/n来回引分组（refer back to a group with /n），其中n是组号（以/1起始）

这里有一个稍微有点复杂却又很有用的正则表达式－－它用来描述十进制和十六进制的整数。
[+-]?[0-9]+|0[Xx][0-9A-Fa-f]+

不幸的是，在使用正则表达式的各种程序和库之间，它的语法还没有完全标准化。对基本的构造上已达成了共识，但在细节方面有许多令人“抓狂”的区别（many maddening differences）。Java的正则表达式类使用了与Perl语言类似的语法，但也不尽相同。表12-8显示了Java语法的所有正则表达式构造。要了解更多关于正则表达式的信息，请参考Pattern类的API文档，或者Jeffrey E. F. Friedl的著作《Mastering Regular Expressions》(O'Reilly and Associates, 1997)（刚去第二书店查了一下，东南大学出版社已经引入了其第二版，影印）

表12-8 正则表达式语法

---

语法                                                           解释

---

字符
c                                                            字符c
/unnnn, /xnn, /0n, /0nn, /0nnn          带有十六或八进制值的代码单元

/t, /n, /r, /f, /a, /e                                    控制字符，依次是制表符，换行符，回车符，换页符，报警符和转义符
/cc                                                         控制字符中出现的相应字符c

---

字符类
[C1C2. . .]                       C1、C2……中的任何字符。Ci可以是字符，字符范围（C1-C2）或者字符类。
[^. . .]                                字符类的补集
[ . . . && . . .]                    两个字符类的交集

---

预定义字符类
.                                        除行终止符外的任何字符（如果DOTALL标志置位，则表示任何字符）
/d                                      数字[0-9]
/D                                    非数字[^0-9]
/s                                     空白字符[/t/n/r/f/x0B]
/S                                     非空白字符
/w                                    单词字符[a-zA-Z0-9_]
/W                                   非单词字符
/p{name}                        一个指定的字符类，见表12-9
/P{name}                       指定字符类的补集

---

边界匹配符
^ $                                   输入的开头和结尾(在多行模式(multiline mode)下是行的开头和结尾)
/b                                    单词边界
/B                                    非单词边界
/A                                     输入的开头
/z                                     输入的结尾
/Z                                    除最后行终止符之外的输入结尾
/G                                   上个匹配的结尾

---

量词
X?                                    可选的X（即X可能出现，也可能不出现）
X*                                    X，可以重复0次或多次
X+                                    X，可以重复1次或多次
X{n} X{n,} X{n,m}          X重复n次，至少重复n次，重复n到m次

---

量词后缀
?                                   设默认（贪婪）匹配为reluctant匹配
+                                   设默认（贪婪）匹配为possessive匹配

---

集合操作
XY                                  X的匹配后面跟着Y的匹配
X|Y                                 X或Y的匹配

---

分组
(X)                                匹配X并且在一个自动计数的分组中捕获它
/n                                  与第n个分组的匹配

---

转义
/c                                   字符c（必须不是字母）
/Q.../E                            逐字地引用...
（？...）                       特殊构造，看Pattern类的API

---

    正则表达式的最简单使用是测试一个特殊的字符串是否与之匹配。这里有一个Java写的测试程序。首先从表示正则表达式的字符串构造一个Pattern对象。然后从该模式获得一个Matcher对象，并且调用它的matches()方法：

表12.9 预定义的字符类名（Predefined Character Class Names）

---

Lower                         小写的ASII字符[a-z]
Upper                         大写的ASCII字符[A-Z]
Alpha                          ASCII字母[A-Za-z]
Digit                            ASCII 数字 [0-9]
Alnum                         ASCII 字母或数字[A-Za-z0-9]
Xdigit                         十六进制数字[0-9A-Fa-f]
Print or Graph          可打印的ASCII字符[/x21-/x7E]
Punct                         非字母或数字ASCII [/p{Print}&&/P{Alnum}]
ASCII                         所有ASCII字符 [/x00-/x7F]
Cntrl                          ASCII控制字符[/x00-/x1F]
Blank                         空格符或制表符[ /t]
Space                        空白符 [ /t/n/r/f/0x0B]
javaLowerCase       取决于Character.isLowerCase()的小写字符
javaUpperCase      取决于Character.isUpperCase()的大写字符
javaWhitespace     取决于Character.isWhitespace()的空白符
javaMirrored            取决于Character.isMirrored()的Mirrored（？）
InBlock                      这里的Block是unicode字符的块名，用空格隔开，比如BasicLatin 或 Mongolian。块名列表                                  参考http://www.unicode.org
Category 或InCategory     这里的Category是Unicode字符的种类名，比如L（字母）或者Sc（货币符号）。种类                                        名列表参考http://www.unicode.org

---

    matcher的输入可以是实现CharSequence接口的任何类对象，像String，StringBuilder或CharBuffer。

当编译模式时，可以设置一个或多个标志，例如

下面六 个标志都是支持的：

如果正则表达式包含分组，Matcher对象能够揭示分组边界 。方法

返回某个特殊分组的起始索引和结尾后索引（past-the-end index ）。
通过调用String group(int groupIndex)，你可以简单地得到匹配的字符串。
第0个分组代表所有的分组，第一个实际分组的索引是1。调用groupCount来获得总的分组数。

使用开放圆括号来安排嵌套分组。例如，给定模式((1?[0-9]):([0-5][0-9]))[ap]m，并且输入11:59am,Matcher对象报告下列分组
((1?[0-9]):([0-5][0-9]))[ap]m
并输入
11:59am
matcher报告下列分组

---

分组索引  起始  结束  字符串

---

0              0          7      11;59am
1              0          5      11:59
2              0          2      11
3              3          5      59

---

 
例12－9提示输入一个模式和一个欲匹配的字符串。它将输出输入的字符串是否匹配模式。如果输入匹配包含分组的模式，程序将会使用圆括号来打印分组边界，如((11):(59))am

Example 12-9. RegexTest.java
 1. import java.util.*;
 2. import java.util.regex.*;
 3.
 4. /**
 5.    This program tests regular expression matching.
 6.    Enter a pattern and strings to match, or hit Cancel
 7.    to exit. If the pattern contains groups, the group
 8.    boundaries are displayed in the match.
 9. */
10. public class RegExTest
11. {
12.   public static void main(String[] args)
13.   {
14.      Scanner in = new Scanner(System.in);
15.      System.out.println("Enter pattern: ");
16.      String patternString = in.nextLine();
17.
18.      Pattern pattern = null;
19.      try
20.      {
21.         pattern = Pattern.compile(patternString);
22.      }
23.      catch (PatternSyntaxException e)
24.      {
25.         System.out.println("Pattern syntax error");
26.         System.exit(1);
27.      }
28.
29.      while (true)
30.      {
31.         System.out.println("Enter string to match: ");
32.         String input = in.nextLine();
33.         if (input == null || input.equals("")) return;
34.         Matcher matcher = pattern.matcher(input);
35.         if (matcher.matches())
36.         {
37.            System.out.println("Match");
38.            int g = matcher.groupCount();
39.            if (g > 0)
40.            {
41.               for (int i = 0; i < input.length(); i++)
42.               {
43.                  for (int j = 1; j <= g; j++)
44.                     if (i == matcher.start(j))
45.                        System.out.print('(');
46.                  System.out.print(input.charAt(i));
47.                  for (int j = 1; j <= g; j++)
48.                     if (i + 1 == matcher.end(j))
49.                        System.out.print(')');
50.               }
51.               System.out.println();
52.            }
53.         }
54.         else
55.            System.out.println("No match");
56.      }
57.   }
58. }

通常地，你不希望匹配整个输入到某个正则表达式，而是希望在输入中找出一个或多个匹配的子字符串。使用Matcher类的find方法来寻找下一个匹配。如果它返回True，再使用start和end方法找出匹配的范围。

例12-10用到了这种机制。它在一个网页中定位所有的超文本引用并打印它们。为运行程序，在命令行提供一个URL，比如
java HrefMatch http://www.horstmann.com

Example 12-10. HrefMatch.java
 1. import java.io.*;
 2. import java.net.*;
 3. import java.util.regex.*;
 4.
 5. /**
 6.    This program displays all URLs in a web page by
 7.    matching a regular expression that describes the
 8.    <a href=...> HTML tag. Start the program as
 9.    java HrefMatch URL
10. */
11. public class HrefMatch
12. {
13.    public static void main(String[] args)
14.    {
15.       try
16.       {
17.          // get URL string from command line or use default
18.          String urlString;
19.          if (args.length > 0) urlString = args[0];
20.          else urlString = "http://java.sun.com ";
21.
22.          // open reader for URL
23.          InputStreamReader in = new InputStreamReader(new URL(urlString).openStream());
24.
25.          // read contents into string buffer
26.          StringBuilder input = new StringBuilder();
27.          int ch;
28.          while ((ch = in.read()) != -1) input.append((char) ch);
29.
30.          // search for all occurrences of pattern
31.          String patternString = "<a//s+href//s*=//s*(/"[^/"]*/"|[^//s>])//s*>";
32.          Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
33.          Matcher matcher = pattern.matcher(input);
34.
35.          while (matcher.find())
36.          {
37.             int start = matcher.start();
38.             int end = matcher.end();
39.             String match = input.substring(start, end);
40.             System.out.println(match);
41.          }
42.       }
43.       catch (IOException e)
44.       {
45.          e.printStackTrace();
46.       }
47.       catch (PatternSyntaxException e)
48.       {
49.          e.printStackTrace();
50.       }
51.    }
52. }

   Matcher类的replaceAll方法 用一个替换字符串代替 出现的所有正则表达式的匹配。比如，下列指令用#替换所有数字序列

替换字符串可以包含模式中的分组引用：$n被第n个分组替换。替换文本中出现$时，使用/$来包含它。
replaceFirst方法只替换模式的第一次出现。

最后讲一点，Pattern类有一个split方法，它类似于字符串tokenizer。它使用正则表达式匹配作边界，将输入分离成字符串数组。比如，下面的指令将输入分离成记号（token），

类

---

java.util.regex.Pattern 1.4

---

方法
static Pattern compile(String expression)
static Pattern compile(String expression, int flags)
编译正则表达式字符串到pattern对象用以匹配的快速处理
参数:
 expression 正则表达式
 flags            下列标志中的一个或多个 CASE_INSENSITIVE, UNICODE_CASE, MULTILINE, UNIX_LINES, DOTALL, and CANON_EQ
 
Matcher matcher(CharSequence input)
返回一个matcher对象，它可以用来在一个输入中定位模式匹配

String[] split(CharSequence input)
String[] split(CharSequence input, int limit)
将输入字符串分离成记号，并由pattern来指定分隔符的形式。返回记号数组。分隔符并不是记号的一部分。
参数:
input 分离成记号的字符串
limit 生成的最大字符串数。

---

 类

---

java.util.regex.Matcher 1.4

---

方法

---

boolean matches()
返回输入是否与模式匹配

boolean lookingAt()
如果输入的起始匹配模式则返回True

boolean find()
boolean find(int start)
尝试查找下一个匹配，并在找到匹配时返回True
参数:
 start  开始搜索的索引
 
int start()
int end()
返回当前匹配的起始位置和结尾后位置

String group()
返回当前匹配

int groupCount()
返回输入模式中的分组数

int start(int groupIndex)
int end(int groupIndex)
返回一个给定分组当前匹配中的起始位置和结尾后位置
参数:
 groupIndex分组索引（从1开始），0表示整个匹配

String group(int groupIndex)
返回匹配一个给定分组的字符串
参数:
 groupIndex
 分组索引（从1开始），0表示整个匹配

String replaceAll(String replacement)
String replaceFirst(String replacement)
返回从matcher输入得到的字符串，但已经用替换表达式替换所有或第一个匹配
参数:
 replacement 替换字符串

Matcher reset()
Matcher reset(CharSequence input)
复位mather状态。

• 23:43
• 浏览 (340)
• 评论 (0)
• 分类: RegEx

Java正则表达式详解

文章分类:Java编程

如果你曾经用过Perl或任何其他内建正则表达式支持的语言，你一定知道用正则表达式处理文本和匹配模式是多么简单。如果你不熟悉这个术语，那么“正则表达式”（Regular Expression）就是一个字符构成的串，它定义了一个用来搜索匹配字符串的模式。

许多语言，包括Perl、PHP、Python、JavaScript和JScript，都支持用正则表达式处理文本，一些文本编辑器用正则表达式实现高级“搜索-替换”功能。那么Java又怎样呢？本文写作时，一个包含了用正则表达式进行文本处理的Java规范需求（Specification Request）已经得到认可，你可以期待在JDK的下一版本中看到它。

然而，如果现在就需要使用正则表达式，又该怎么办呢？你可以从Apache.org下载源代码开放的Jakarta-ORO库。本文接下来的内容先简要地介绍正则表达式的入门知识，然后以Jakarta-ORO API为例介绍如何使用正则表达式。

一、正则表达式基础知识

我们先从简单的开始。假设你要搜索一个包含字符“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字符。如果字符串正确匹配，接下来如何提取出月份部分呢？只需在月份周围加上一个圆括号创建一个组，然后用ORO API（本文后面详细讨论）提取出它的值。修改后的正则表达式如图六所示：

图六：匹配所有Month DD,YYYY格式的日期，定义月份值为第一个组

1.7 其它符号

为简便起见，你可以使用一些为常见正则表达式创建的快捷符号。如表二所示：

表二：常用符号

例如，在前面社会安全号码的例子中，所有出现“[0-9]”的地方我们都可以使用“/d”。修改后的正则表达式如图七所示：

图七：匹配所有123-12-1234格式的社会安全号码

二、Jakarta-ORO库

有许多源代码开放的正则表达式库可供Java程序员使用，而且它们中的许多支持Perl 5兼容的正则表达式语法。我在这里选用的是Jakarta-ORO正则表达式库，它是最全面的正则表达式API之一，而且它与Perl 5正则表达式完全兼容。另外，它也是优化得最好的API之一。

Jakarta-ORO库以前叫做OROMatcher，Daniel Savarese大方地把它赠送给了Jakarta Project。你可以按照本文最后参考资源的说明下载它。

我首先将简要介绍使用Jakarta-ORO库时你必须创建和访问的对象，然后介绍如何使用Jakarta-ORO API。

▲ PatternCompiler对象

首先，创建一个Perl5Compiler类的实例，并把它赋值给PatternCompiler接口对象。Perl5Compiler是PatternCompiler接口的一个实现，允许你把正则表达式编译成用来匹配的Pattern对象。

▲ Pattern对象

要把正则表达式编译成Pattern对象，调用compiler对象的compile()方法，并在调用参数中指定正则表达式。例如，你可以按照下面这种方式编译正则表达式“t[aeio]n”：

默认情况下，编译器创建一个大小写敏感的模式（pattern）。因此，上面代码编译得到的模式只匹配“tin”、“tan”、 “ten”和“ton”，但不匹配“Tin”和“taN”。要创建一个大小写不敏感的模式，你应该在调用编译器的时候指定一个额外的参数：

创建好Pattern对象之后，你就可以通过PatternMatcher类用该Pattern对象进行模式匹配。

▲ PatternMatcher对象

PatternMatcher对象根据Pattern对象和字符串进行匹配检查。你要实例化一个 Perl5Matcher类并把结果赋值给PatternMatcher接口。Perl5Matcher类是PatternMatcher接口的一个实现，它根据Perl 5正则表达式语法进行模式匹配：

使用PatternMatcher对象，你可以用多个方法进行匹配操作，这些方法的第一个参数都是需要根据正则表达式进行匹配的字符串：

· boolean matches(String input, Pattern pattern)：当输入字符串和正则表达式要精确匹配时使用。换句话说，正则表达式必须完整地描述输入字符串。

· boolean matchesPrefix(String input, Pattern pattern)：当正则表达式匹配输入字符串起始部分时使用。

· boolean contains(String input, Pattern pattern)：当正则表达式要匹配输入字符串的一部分时使用（即，它必须是一个子串）。

另外，在上面三个方法调用中，你还可以用PatternMatcherInput对象作为参数替代String对象；这时，你可以从字符串中最后一次匹配的位置开始继续进行匹配。当字符串可能有多个子串匹配给定的正则表达式时，用PatternMatcherInput对象作为参数就很有用了。用PatternMatcherInput对象作为参数替代String时，上述三个方法的语法如下：

· boolean matches(PatternMatcherInput input, Pattern pattern)

· boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)

· boolean contains(PatternMatcherInput input, Pattern pattern)

三、应用实例

下面我们来看看Jakarta-ORO库的一些应用实例。

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服务器从widgets.acme.com移到了newserver.acme.com。现在你要修改一些页面中的链接：

执行这个搜索的正则表达式如图十三所示：

图十三：匹配修改前的链接

如果能够匹配这个正则表达式，你可以用下面的内容替换图十三的链接：

注意#字符的后面加上了$1。Perl正则表达式语法用$1、$2等表示已经匹配且提取出来的组。图十三的表达式把所有作为一个组匹配和提取出来的内容附加到链接的后面。

现在，返回Java。就象前面我们所做的那样，你必须创建测试字符串，创建把正则表达式编译到Pattern对象所必需的对象，以及创建一个PatternMatcher对象：

接下来，用com.oroinc.text.regex包Util类的substitute()静态方法进行替换，输出结果字符串：

Util.substitute()方法的语法如下：

这个调用的前两个参数是以前创建的PatternMatcher和Pattern对象。第三个参数是一个 Substiution对象，它决定了替换操作如何进行。本例使用的是Perl5Substitution对象，它能够进行Perl5风格的替换。第四个参数是想要进行替换操作的字符串，最后一个参数允许指定是否替换模式的所有匹配子串（Util.SUBSTITUTE_ALL），或只替换指定的次数。

【结束语】 在这篇文章中，我为你介绍了正则表达式的强大功能。只要正确运用，正则表达式能够在字符串提取和文本修改中起到很大的作用。另外，我还介绍了如何在Java程序中通过Jakarta-ORO库利用正则表达式。至于最终采用老式的字符串处理方式（使用StringTokenizer，charAt，和substring），还是采用正则表达式，这就有待你自己决定了。