Java学习之道：正则表达式（二）

桃扇骨 2021-09-30 07:16 298阅读 0赞

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td><strong>3.3 HTML处理实例二</strong></td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>下面我们来看看另一个处理HTML的例子。这一次，我们假定Web服务器从widgets.acme.com移到了newserver.acme.com。现在你要修改一些页面中的链接：</td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>执行这个搜索的正则表达式如图十三所示：</td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td> <p style="margin-top:0px; margin-bottom:0px; padding-top:0px; padding-bottom:0px"> 图十三：匹配修改前的链接</p> </td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>如果能够匹配这个正则表达式，你可以用下面的内容替换图十三的链接：</td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>&lt;a href="http://blog.pfan.cn/lovebugs/53724.html" "="" style="color: rgb(51, 102, 153); text-decoration: none;"&gt;<img alt="" src="http://edu.yesky.com/imagelist/05/10/s82f65t25m75.jpg" style="border:0px none"></td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>注意#字符的后面加上了<a href="http://www.yesky.com/key/1081/571081.html" style="color:rgb(51,102,153); text-decoration:none" rel="nofollow"><span style="color:rgb(95,101,157)">$1</span></a>。Perl正则表达式语法用$1、$2等表示已经匹配且提取出来的组。图十三的表达式把所有作为一个组匹配和提取出来的内容附加到链接的后面。</td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>现在，返回Java。就象前面我们所做的那样，你必须创建测试字符串，创建把正则表达式编译到Pattern对象所必需的对象，以及创建一个PatternMatcher对象：<img height="184" alt="" src="http://edu.yesky.com/imagelist/05/10/qg1rzozee4bf.jpg" width="510" style="border:0px none; width:500px"></td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>接下来，用com.oroinc.text.regex包Util类的substitute()静态方法进行替换，输出结果字符串：</td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>Util.substitute()方法的语法如下：</td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>这个调用的前两个参数是以前创建的PatternMatcher和Pattern对象。第三个参数是一个Substiution对象，它决定了替换操作如何进行。本例使用的是Perl5Substitution对象，它能够进行Perl5风格的替换。第四个参数是想要进行替换操作的字符串，最后一个参数允许指定是否替换模式的所有匹配子串（Util.SUBSTITUTE_ALL），或只替换指定的次数。</td> 
  </tr> 
 </tbody> 
</table>

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td><strong>【结束语】</strong>在这篇文章中，我为你介绍了正则表达式的强大功能。只要正确运用，正则表达式能够在字符串提取和文本修改中起到很大的作用。另外，我还介绍了如何在Java程序中通过Jakarta-ORO库利用正则表达式。至于最终采用老式的字符串处理方式（使用StringTokenizer，charAt，和substring），还是采用正则表达式，这就有待你自己决定了。</td> 
  </tr> 
 </tbody> 
</table>

Jakarta-ORO篇

[陈广佳][Link 1] ([cgjmail@163.net][cgjmail_163.net])  
电子信息工程系工科学士  
2001 年 12 月

> 由于工作的需要，本人经常要面对大量的文字电子资料的整理工作，因此曾对在JAVA中正则表达式的应用有所关注，并对其有一定的了解，希望通过本文与同行进行有关方面的心得交流。

正则表达式：  
正则表达式是一种可以用于模式匹配和替换的强有力的工具，一个正则表达式就是由普通的字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式，它描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

正则表达式在字符数据处理中起着非常重要的作用，我们可以用正则表达式完成大部分的数据分析处理工作，如:判断一个串是否是数字、是否是有效的Email地址，从海量的文字资料中提取有价值的数据等等，如果不使用正则表达式，那么实现的程序可能会很长，并且容易出错。对这点本人深有体会，面对大量工具书电子档资料的整理工作，如果不懂得应用正则表达式来处理，那么将是很痛苦的一件事情，反之则将可以轻松地完成，获得事半功倍的效果。

由于本文目的是要介绍如何在JAVA里运用正则表达式，因此对刚接触正则表达式的读者请参考有关资料，在此因篇幅有限不作介绍。

JAVA对正则表达式的支持：  
在JDK1.3或之前的JDK版本中并没有包含正则表达式库可供JAVA程序员使用，之前我们一般都在使用第三方提供的正则表达式库，这些第三方库中有源代码开放的，也有需付费购买的，而现时在JDK1.4的测试版中也已经包含有正则表达式库---java.util.regex。

故此现在我们有很多面向JAVA的正则表达式库可供选择，以下我将介绍两个较具代表性的** Jakarta-ORO**和**java.util.regex**，首先当然是本人一直在用的** Jakarta-ORO：**

Jakarta-ORO正则表达式库

1．简介：  
Jakarta-ORO是最全面以及优化得最好的正则表达式API之一，Jakarta-ORO库以前叫做OROMatcher，是由Daniel F. Savarese编写，后来他将其赠与Jakarta Project，读者可在Apache.org的网站[下载][Link 2]该API包。

许多源代码开放的正则表达式库都是支持Perl5兼容的正则表达式语法，Jakarta-ORO正则表达式库也不例外，他与Perl 5正则表达式完全兼容。

2．对象与其方法：  
★PatternCompiler对象：  
我们在使用Jakarta-ORO API包时，最先要做的是，创建一个Perl5Compiler类的实例，并把它赋值给PatternCompiler接口对象。Perl5Compiler是PatternCompiler接口的一个实现，允许你把正则表达式编译成用来匹配的Pattern对象。

`PatternCompiler compiler=new Perl5Compiler();`

★Pattern对象：  
要把所对应的正则表达式编译成Pattern对象，需要调用compiler对象的compile()方法，并在调用参数中指定正则表达式。举个例子，你可以按照下面这种方式编译正则表达式"s\[ahkl\]y"：

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td> <pre style="margin-top:0px; margin-bottom:0px; padding:0px; white-space:pre-wrap; word-wrap:break-word"><code> Pattern pattern=null;
        try {
                pattern=compiler.compile("s[ahkl]y ");
        } catch (MalformedPatternException e) {
                e.printStackTrace();
        }</code> </pre> </td> 
  </tr> 
 </tbody> 
</table>

在默认的情况下，编译器会创建一个对大小写敏感的模式（pattern）。因此，上面代码编译得到的模式只匹配"say"、"shy"、 "sky"和"sly"，但不匹配"Say"和"skY"。要创建一个大小写不敏感的模式，你应该在调用编译器的时候指定一个额外的参数:  
`pattern=compiler.compile("s[ahkl]y",Perl5Compiler.CASE_INSENSITIVE_MASK);`

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

★PatternMatcher对象:

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

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

1.  boolean matches(String input, Pattern pattern)：当要求输入的字符串input和正则表达式pattern精确匹配时使用该方法。也就是说当正则表达式完整地描述输入字符串时返回真值。
2.  boolean matchesPrefix(String input, Pattern pattern)：要求正则表达式匹配输入字符串起始部分时使用该方法。也就是说当输入字符串的起始部分与正则表达式匹配时返回真值。
3.  boolean contains(String input, Pattern pattern)：当正则表达式要匹配输入字符串的一部分时使用该方法。当正则表达式为输入字符串的子串时返回真值。

但以上三种方法只会查找输入字符串中匹配正则表达式的第一个对象，如果当字符串可能有多个子串匹配给定的正则表达式时，那么你就可以在调用上面三个方法时用PatternMatcherInput对象作为参数替代String对象，这样就可以从字符串中最后一次匹配的位置开始继续进行匹配，这样就方便的多了。

用PatternMatcherInput对象作为参数替代String时，上述三个方法的语法如下：

1.  boolean matches(PatternMatcherInput input, Pattern pattern)
2.  boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)
3.  boolean contains(PatternMatcherInput input, Pattern pattern)

★Util.substitute()方法:  
查找后需要要进行替换，我们就要用到Util.substitute()方法，其语法如下：

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td> <pre style="margin-top:0px; margin-bottom:0px; padding:0px; white-space:pre-wrap; word-wrap:break-word"><code>public static String substitute(PatternMatcher matcher,
       Pattern pattern,Substitution sub,String input,
       int numSubs) </code> </pre> </td> 
  </tr> 
 </tbody> 
</table>

前两个参数分别为PatternMatcher和Pattern对象。而第三个参数是个Substiution对象，由它来决定替换操作如何进行。第四个参数是要进行替换操作的目标字符串，最后一个参数用来指定是否替换模式的所有匹配子串（Util.SUBSTITUTE\_ALL），或只进行指定次数的替换。

在这里我相信有必要详细解说一下第三个参数Substiution对象，因为它将决定替换将怎样进行。

**Substiution**:  
Substiution是一个接口类，它为你提供了在使用Util.substitute()方法时控制替换方式的手段，它有两个标准的实现类：StringSubstitution与Perl5Substitution。当然，同时你也可以生成自己的实现类来定制你所需要的特殊替换动作。

**StringSubstitution：**  
StringSubstitution 实现的是简单的纯文字替换手段，它有两个构造方法：

StringSubstitution()->缺省的构造方法，初始化一个包含零长度字符串的替换对象。

StringSubstitution(java.lang.String substitution)->初始化一个给定字符串的替换对象。

**Perl5Substitution：**  
Perl5Substitution 是StringSubstitution的子类，它在实现纯文字替换手段的同时也允许进行针对MATH类里各匹配组的PERL5变量的替换，所以他的替换手段比其直接父类StringSubstitution更为多元化。

它有三个构造器：

**Perl5Substitution()**

**Perl5Substitution**(java.lang.String substitution)

**Perl5Substitution**(java.lang.String substitution, int numInterpolations)

前两种构造方法与StringSubstitution一样，而第三种构造方法下面将会介绍到。

在**Perl5Substitution**的替换字符串中可以包含用来替代在正则表达式里由小扩号围起来的匹配组的变量，这些变量是由$1, $2,$3等形式来标识。我们可以用一个例子来解释怎样使用替换变量来进行替换：

假设我们有正则表达式模式为b/d+:（也就是b\[0-9\]+:），而我们想把所有匹配的字符串中的"b"都改为"a",而"："则改为"-"，而其余部分则不作修改，如我们输入字符串为"EXAMPLE b123:"，经过替换后就应该变成"EXAMPLE a123-"。要做到这点，我们就首先要把不做替换的部分用分组符号小括号包起来，这样正则表达式就变为"b(/d+):"，而构造Perl5Substitution对象时其替换字符串就应该是"a$1-"，也就是构造式为Perl5Substitution（"a$1-"），表示在使用Util.substitute()方法时只要在目标字符串里找到和正则表达式" b(/d+): "相匹配的子串都用替换字符串来替换，而变量$1表示如果和正则表达式里第一个组相匹配的内容则照般原文插到$1所在的为置，如在"EXAMPLE b123："中和正则表达式相匹配的部分是"b123："，而其中和第一分组"(/d+)"相匹配的部分则是"123"，所以最后替换结果为"EXAMPLE a123-"。

有一点需要清楚的是，如果你把构造器Perl5Substitution(java.lang.String substitution,int numInterpolations)

中的numInterpolations参数设为INTERPOLATE\_ALL，那么当每次找到一个匹配字串时，替换变量（$1，$2等）所指向的内容都根据目前匹配字串来更新，但是如果numInterpolations参数设为一个正整数N时，那么在替换时就只会在前N次匹配发生时替换变量会跟随匹配对象来调整所代表的内容，但N次之后就以一致以第N次替换变量所代表内容来做为以后替换结果。

举个例子会更好理解：

假如沿用以上例子中的正则表达式模式以及替换内容来进行替换工作，设目标字符串为"Tank b123: 85 Tank b256: 32 Tank b78: 22"，并且设numInterpolations参数为INTERPOLATE\_ALL，而Util.substitute()方法中的numSub变量设为SUBSTITUTE\_ALL（请参考上文Util.substitute()方法内容），那么你获得的替换结果将会是：  
`Tank a123- 85 Tank a256- 32 Tank a78- 22`

但是如果你把numInterpolations设为2，并且numSubs依然设为SUBSTITUTE\_ALL，那么这时你获得的结果则会是：  
`Tank a123- 85 Tank a256- 32 Tank a256- 22`

你要注意到最后一个替换所用变量$1所代表的内容与第二个$1一样为"256"，而不是预期的"78"，因为在替换进行中，替换变量$1只根据匹配内容进行了两次更新，最后一次就使第二次匹配时所更新的结果，那么我们可以由此知道，如果numInterpolations设为1，那么结果将是：  
`Tank a123- 85 Tank a123- 32 Tank a123- 22`

3．应用示例：  
刚好前段时间公司准备出一个《伊索预言》的英语学习互动教材，其中有电子档资料的整理工作，我们就以此为例来看一下Jakarta-ORO与JDBC2.0 API结合起来对数据库内的资料进行简单提取与整理的实现。假设由录入部的同事送过来的存放在MS SQLSERVER 7数据库里的电子档的表结构如下（注：或许在不同的DBMS中有相应的正则表达式的应用，但这不在本文讨论范围内）：

表名：AESOP, 表中每条记录包含有三列:  
ID（int）：单词索引号  
WORD（varchar）：单词  
CONTENT(varchar)：存放单词的相关解释与例句等内容

其中CONTENT列中内容的格式如下：  
\[音标\] \[词性\] （解释）\{(例句一/例句解释/例句中该词的词性: 单词在句中的意思) (例句二/例句解释/例句中该词的词性: 单词在句中的意思)\}

如对应单词Kevin,CONTENT中的内容如下：  
\['kevin\] \[名词\]（人名凯文）\{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin is living in ZhuHai now./凯文现住在珠海/名词: 凯文)\}

我们的例子主要针对CONTENT列中内容进行字符串处理。

★查找单个匹配：  
首先，让我们尝试把CONTNET列中的\[音标\]字段的内容列示出来，由于所有单词的记录中都有这一项并且都在字串开始位置，所以这个查找工作比较简单：

1.  **确定相应的正则表达式：/\[\[^\]\]+/\]**
    
    这个是很简单的正则表达式，其意思是要求相匹配的字符串必须为以一对中括号包含的所有内容，如\['kevin\] 、\[名词\]等，但内容中不包括"\]"符号，也就是要避免出现"\[\]\[\]"会作为一个匹配对象的情况出现（有关正则表达式的基础知识请参照有关资料，这里不再详述）。
    
    注意，在Java中，你必须对每一个向前的斜杠（"/"）进行转义处理。所以我们要在上面的正则表达式里每个"/"前面加上一个"/"以免出现编译错误，也就是在JAVA中初始化正则表达式的字符串的语句应该为：
    
    String restring=" //\[\[^\]\]+//\]";
    
    并且在表达式里每个符号中间不能有空格，否则就会同样出现编译错误。
2.  **实例化PatternCompiler对象，创建Pattern对象**
    
    PatternCompiler compiler=new Perl5Compiler();
    
    Pattern pattern=compiler.compile(restring);
3.  **创建PatternMatcher对象，调用PatternMatcher接口的contain()方法检查匹配情况：**
    
    <table> 
     <tbody> 
      <tr> 
       <td> <pre style="margin-top:0px; margin-bottom:0px; padding:0px; white-space:pre-wrap; word-wrap:break-word"><code> PatternMatcher matcher=new Perl5Matcher();
            if (matcher.contains(content,pattern)) {
                     //处理代码片段
            } </code> </pre> </td> 
      </tr> 
     </tbody> 
    </table>
    
      
      
    
    
    这里matcher.contains(content,pattern)中的参数 content是从数据库里取来的字符串变量。该方法只会查到第一个匹配的对象字符串，但是由于音标项均在CONETNET内容字符串中的起始位置，所以用这个方法就已经可以保证把每条记录里的音标项找出来了,但更为直接与合理的办法是使用boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)方法，该方法验证目标字符串是否以正则表达式所匹配的字串为起始。
    
    具体实现的完整的程序代码如下：
    
    <table> 
     <tbody> 
      <tr> 
       <td> <pre style="margin-top:0px; margin-bottom:0px; padding:0px; white-space:pre-wrap; word-wrap:break-word"><code>package RegularExpressions;
    //import……
    import org.apache.oro.text.regex.*;
    //使用Jakarta-ORO正则表达式库前需要把它加到CLASSPATH里面，如果用IDE是//JBUILDER，那么也可以在JBUILDER里直接自建新库。
    
    public class yisuo{
      public static void main(String[] args){
      try{     
    //使用JDBC DRIVER进行DBMS连接，这里我使用的是一个第三方JDBC 
    //DRIVER，Microsoft本身也有一个面向SQLSERVER7/2000的免费JDBC //DRIVER，但其性能真的是奇差，不用也罢。
            Class.forName("com.jnetdirect.jsql.JSQLDriver");
              Connection con=DriverManager.getConnection
              ("jdbc:JSQLConnect://kevin:1433","kevin chen","re");
              Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
              ResultSet.CONCUR_UPDATABLE);
    //为使用Jakarta-ORO库而创建相应的对象
    String rsstring=" //[[^]]+//]"; 
              PatternCompiler orocom=new Perl5Compiler();
              Pattern pattern=orocom.compile(rsstring);
              PatternMatcher matcher=new Perl5Matcher();
              ResultSet uprs = stmt.executeQuery("SELECT * FROM aesop");
              while (uprs.next()) {
    Stirng  word=uprs.getString("word");
              Stirng  content=uprs.getString("content");
                if(matcher.contains(content,pattern)){
              //或if(matcher.matchesPrefix(content,pattern)){
                    MatchResult result=matcher.getMatch();
                    Stirng pure=result.toString();
                    System.out.println(word+"的音标为："+pure);
                }
              }
           }
      catch(Exception e) {
                 System.out.println(e);
           }
      }
    }</code> </pre> </td> 
      </tr> 
     </tbody> 
    </table>
    
      
      
    
    
    输出结果为：kevin的音标为\['kevin\]

在这个处理中我是用toString()方法来取得结果，但是如果正则表达式里是用了分组符号（圆括号），那么就可以用group(int gid)的方法来取得相应各组匹配的结果，如正则表达式改为" (/\[\[^\]\]+/\])"，那么就可以用以下方法来取得结果：pure=result.group(0);

用程序验证，输出结果同样为：kevin的音标为\['kevin\]

而如果正则表达式为（/\[\[^\]\]+/\]）（/\[\[^\]\]+/\]），则会查找到两个连续的方括号所包含的内容，也就找到\[音标\] \[词性\]两项，但是两项的结果分别在两个组里面，分别由下面语句获得结果：

result.group(0)->返回\[音标\] \[词性\]两项内容，也就是与整个正则表达式相匹配的结果字符串，在这里也就为\['kevin\] \[名词\]

result.group(1) ->返回\[音标\]项内容，结果应是\['kevin\]

result.group(2) ->返回\[词性\]项内容，结果应是\[名词\]

继续用程序验证，发现输出并不正确，主要是当内容有中文时就不能成功匹配，考虑到可能是Jakarta-ORO正则表达式库版本不支持中文的问题，回看一下原来我一直用的还是2.0.1的老版本，马上到Jakarta.org上下载最新的2.0.4版本装上再用程序验证，得出的结果就和预期一样正确。

★查找多个匹配：  
经过第一步的尝试使用Jakarta-ORO后，我们已经知道了如何正确使用该API包来查找目标字符串里一个匹配的子串，下面我们接着来看一看当目标字符串里包含不止一个匹配的子串时我们如何把它们一个接一个找出来进行相应的处理。

首先我们先试个简单的应用，假设我们想把CONTNET字段内容里所有用方括号包起来的字串都找出来，很清楚地，CONTNET字段的内容里面就只有两项匹配的内容：\[音标\]和 \[词性\]，刚才我们其实已经把它们分别找出来了，但是我们所用的方法是分组方法，把"\[音标\] \[词性\]"作为一整个正则表达式匹配的内容先找到，再根据分组把\[音标\]和 \[词性\]分别挑出来。但是现在我们需要做的是把\[音标\]和\[词性\]分别做为与同一个正则表达式匹配的内容，先找到一个接着再找下一个，也就是刚才我们的表达式为（/\[\[^\]\]+/\]）（/\[\[^\]\]+/\]）,而现在应为" /\[\[^\]\]+/\] "。

我们已经知道在匹配操作的三个方法里只要用PatternMatcherInput对象作为参数替代String对象就可以从字符串中最后一次匹配的位置开始继续进行匹配，实现的程序片段如下：

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td> <pre style="margin-top:0px; margin-bottom:0px; padding:0px; white-space:pre-wrap; word-wrap:break-word"><code>PatternMatcherInput input=new PatternMatcherInput(content);
            while (matcher.contains(input,pattern)) {
                result=matcher.getMatch();
                System.out.println(result.group(0)) 
            } </code> </pre> </td> 
  </tr> 
 </tbody> 
</table>

输出结果为:\['kevin\]  
\[名词\]

接着我们来做复杂一点的处理，就是我们要先把下面内容：  
\['kevin\] \[名词\]（人名凯文）\{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin is living in ZhuHai now. /凯文现住在珠海/名词: 凯文)\}中的整个例句部分（也就是由大括号所包含的部分）找出来，再分别把例句一和例句二找出，而各例句中的各项内容（英文句、中文句、词性、解释）也要分项列出。

第一步当然是要定出相应的正则表达式，需要有两个，一是和整个例句部分（也就是由大括号包起来的部分）匹配的正则表达式："/\{.+/\}",

另一个则要和每个例句部分匹配（也就是小括号中的内容），：/((\[^)\]+/)

而且由于要把例句的各项分离出来，所以要再把里面的各部分用分组的方法匹配出来：" (\[^(\]+)/(.+)/(.+):(\[^)\]+) "。

为了简便起见，我们不再和从数据库里读出，而是构造一个包含同样内容的字符串变量，程序片段如下：

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td> <pre style="margin-top:0px; margin-bottom:0px; padding:0px; white-space:pre-wrap; word-wrap:break-word"><code>try{
         String content="['kevin] [名词]（人名凯文）{(Kevin loves comic./凯文爱漫画/名词:凯文) (Kevin is living in ZhuHai now./凯文现住在珠海/名词: 凯文)}";
         String ps1="//{.+//}";
         String ps2="//([^)]+//)";
         String ps3="([^(]+)/(.+)/(.+):([^)]+)";
         String sentence;
         PatternCompiler orocom=new Perl5Compiler();
         Pattern pattern1=orocom.compile(ps1);
         Pattern pattern2=orocom.compile(ps2);
         Pattern pattern3=orocom.compile(ps3);
         PatternMatcher matcher=new Perl5Matcher();
//先找出整个例句部分
            if (matcher.contains(content,pattern1)) {
            MatchResult result=matcher.getMatch();
            String example=result.toString();
            PatternMatcherInput input=new PatternMatcherInput(example);
        //分别找出例句一和例句二
            while (matcher.contains(input,pattern2)){
                result=matcher.getMatch();
                sentence=result.toString();
        //把每个例句里的各项用分组的办法分隔出来
                if (matcher.contains(sentence,pattern3)){
                  result=matcher.getMatch();
                  System.out.println("英文句: "+result.group(1));
                  System.out.println("句子中文翻译: "+result.group(2));
                  System.out.println("词性: "+result.group(3));
                  System.out.println("意思: "+result.group(4));
                }
            }
        }
       }
  catch(Exception e) {
             System.out.println(e);
       } </code> </pre> </td> 
  </tr> 
 </tbody> 
</table>

输出结果为：  
英文句: Kevin loves comic.  
句子中文翻译: 凯文爱漫画  
词性: 名词  
意思: 凯文  
英文句: Kevin is living in ZhuHai now.  
句子中文翻译: 凯文现住在珠海  
词性: 名词  
意思: 凯文

★查找替换：  
以上的两个应用都是单纯在查找字符串匹配方面的，我们再来看一下查找后如何对目标字符串进行替换。

例如我现在想把第二个例句进行改动，换为：Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。

也就是把  
\['kevin\] \[名词\]（人名凯文）\{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin is living in ZhuHai now. /凯文现住在珠海/名词: 凯文)\}

改为：  
\['kevin\] \[名词\]（人名凯文）\{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。)\}

之前，我们已经了解Util.substitute()方法与Substiution接口，以及Substiution的两个实现类StringSubstitution和Perl5Substitution，我们就来看看怎么用Util.substitute()方法配合Perl5Substitution来完成我们上面提出的替换要求，确定正则表达式：

我们要先找到其中的整个例句部分，也就是由大括号包起来的字串，并且把两个例句分别分组，所以正则表达式为："/\{(/(\[^)\]+/))(/(\[^)\]+/))/\}"，如果用替换变量来代替分组，那么上面的表达式可以看为"/\{$1$2/\}",这样就可以更容易看出替换变量与分组间的关系。

根据上面的正则表达式Perl5Substitution类可以这样构造：  
Perl5Substitution("\{$1( Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。)\}")

再根据这个Perl5Substitution对象来使用Util.substitute()方法便可以完成替换了，实现的代码片段如下：

输出结果是正确的，为：  
\['kevin\] \[名词\]（人名凯文）\{(Kevin loves comic./凯文爱漫画/名词: 凯文)( Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。)\}

至于有关使用numInterpolations参数的构造器用法，读者只要根据上面的介绍自己动手试一下就会清楚了，在此就不再例述。

总结：  
本文首先介绍了Jakarta-ORO正则表达式库的对象与方法，并且接着举例让读者对实际应用有进一步的了解，虽然例子都比较简单，但希望读者们在看了该文后对Jakarta-ORO正则表达式库有一定的认知，在实际工作中有所帮助与启发。

其实在Jakarta org里除了Jakarta-ORO外还有一个百分百的纯JAVA正则表达式库，就是由Jonathan Locke赠与Jakarta ORG的Regexp，在该包里面包含了完整的文档以及一个用于调试的Applet例子，对其有兴趣的读者可以到此[下载][Link 3]。

参考资料：

*  本文的[主要参考文章][Link 4]，该文在介绍Jakarta-ORO的同时也为读者详尽解析了正则表达式的基本语法。
 *  一个基于PERL的[正则表达式详尽教程][Link 5]（虽然该教程是基于PERL的，但是你并不需要有PERL的经验，虽然那会有所帮助），以及一个不错的[正则表达式简例教程][Link 6]。
 *  最不可缺少的当然是Jakarta-ORO的帮助文档[http://jakarta.apache.org/oro/api/][http_jakarta.apache.org_oro_api]

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td><a style="color:rgb(21,118,174)" rel="nofollow"></a>关于作者&nbsp;<br> 陈广佳 Kevin Chen,汕头大学电子信息工程系工科学士，台湾大新出版社珠海区开发部，现正围绕中日韩电子资料使用JAVA开发电子词典等相关项目。可通过E-mail:<a href="mailto:cgjmail@163.net" style="color:rgb(51,102,153); text-decoration:none" rel="nofollow">cgjmail@163.net</a>于他联系。</td> 
  </tr> 
 </tbody> 
</table>

java.util.regex篇

[陈广佳][Link 7] ([cgjmail@163.net][cgjmail_163.net])  
电子信息工程系工科学士  
2001 年 12 月

> 现在JDK1.4里终于有了自己的正则表达式API包，JAVA程序员可以免去找第三方提供的正则表达式库的周折了，我们现在就马上来了解一下这个SUN提供的迟来恩物- -对我来说确实如此。

1.简介：  
java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。

它包括两个类：**Pattern**和**Matcher**

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td><strong>Pattern</strong></td> 
   <td>一个Pattern是一个正则表达式经编译后的表现模式。</td> 
  </tr> 
  <tr> 
   <td><strong>Matcher</strong></td> 
   <td>一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。</td> 
  </tr> 
 </tbody> 
</table>

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

以下我们就分别来看看这两个类：

2.Pattern类:  
Pattern的方法如下：

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td align="right">static Pattern</td> 
   <td><strong>compile</strong>(String regex)<br> 将给定的正则表达式编译并赋予给Pattern类</td> 
  </tr> 
  <tr> 
   <td align="right">static Pattern</td> 
   <td><strong>compile</strong>(String regex, int flags)<br> 同上，但增加flag参数的指定，可选的flag参数包括：CASE INSENSITIVE,MULTILINE,DOTALL,UNICODE CASE， CANON EQ</td> 
  </tr> 
  <tr> 
   <td align="right">int</td> 
   <td><strong>flags</strong>()<br> 返回当前Pattern的匹配flag参数.</td> 
  </tr> 
  <tr> 
   <td align="right">Matcher</td> 
   <td><strong>matcher</strong>(CharSequence input)<br> 生成一个给定命名的Matcher对象</td> 
  </tr> 
  <tr> 
   <td align="right">static boolean</td> 
   <td><strong>matches</strong>(String regex, CharSequence input)<br> 编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配,该方法适合于该正则表达式只会使用一次的情况，也就是只进行一次匹配工作，因为这种情况下并不需要生成一个Matcher实例。</td> 
  </tr> 
  <tr> 
   <td align="right">String</td> 
   <td><strong>pattern</strong>()<br> 返回该Patter对象所编译的正则表达式。</td> 
  </tr> 
  <tr> 
   <td align="right">String[]</td> 
   <td><strong>split</strong>(CharSequence input)<br> 将目标字符串按照Pattern里所包含的正则表达式为模进行分割。</td> 
  </tr> 
  <tr> 
   <td align="right">String[]</td> 
   <td><strong>split</strong>(CharSequence input, int limit)<br> 作用同上，增加参数limit目的在于要指定分割的段数，如将limi设为2，那么目标字符串将根据正则表达式分为割为两段。</td> 
  </tr> 
 </tbody> 
</table>

一个正则表达式，也就是一串有特定意义的字符，必须首先要编译成为一个Pattern类的实例，这个Pattern对象将会使用** matcher()**方法来生成一个Matcher实例，接着便可以使用该 Matcher实例以编译的正则表达式为基础对目标字符串进行匹配工作，多个Matcher是可以共用一个Pattern对象的。

现在我们先来看一个简单的例子，再通过分析它来了解怎样生成一个Pattern对象并且编译一个正则表达式，最后根据这个正则表达式将目标字符串进行分割：

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td> <pre style="margin-top:0px; margin-bottom:0px; padding:0px; white-space:pre-wrap; word-wrap:break-word"><code>import java.util.regex.*;
public class Replacement{
      public static void main(String[] args) throws Exception {
        // 生成一个Pattern,同时编译一个正则表达式
        Pattern p = Pattern.compile("[/]+");
        //用Pattern的split()方法把字符串按"/"分割
        String[] result = p.split(
"Kevin has seen《LEON》seveal times,because it is a good film."
+"/ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部"
+"好电影。/名词:凯文。");
        for (int i=0; i&lt;result.length; i++)
            System.out.println(result[i]);
      }
} </code> </pre> </td> 
  </tr> 
 </tbody> 
</table>

输出结果为：

> Kevin has seen《LEON》seveal times,because it is a good film.  
> 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。  
> 名词:凯文。

很明显，该程序将字符串按"/"进行了分段，我们以下再使用 **split**(CharSequence input, int limit)方法来指定分段的段数，程序改动为：  
`tring[] result = p.split("Kevin has seen《LEON》seveal times,because it is a good film./ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。"，2);`

这里面的参数"2"表明将目标语句分为两段。

输出结果则为：

> Kevin has seen《LEON》seveal times,because it is a good film.  
> 凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。

由上面的例子，我们可以比较出java.util.regex包在构造Pattern对象以及编译指定的正则表达式的实现手法与我们在上一篇中所介绍的Jakarta-ORO 包在完成同样工作时的差别，Jakarta-ORO 包要先构造一个PatternCompiler类对象接着生成一个Pattern对象，再将正则表达式用该PatternCompiler类的compile()方法来将所需的正则表达式编译赋予Pattern类：

PatternCompiler orocom=new Perl5Compiler();

Pattern pattern=orocom.compile("REGULAR EXPRESSIONS");

PatternMatcher matcher=new Perl5Matcher();

但是在java.util.regex包里，我们仅需生成一个Pattern类，直接使用它的compile()方法就可以达到同样的效果:  
`Pattern p = Pattern.compile("[/]+");`

因此似乎java.util.regex的构造法比Jakarta-ORO更为简洁并容易理解。

3.Matcher类:  
Matcher方法如下：

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td align="right">Matcher</td> 
   <td><strong>appendReplacement</strong>(StringBuffer sb, String replacement)<br> 将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里。</td> 
  </tr> 
  <tr> 
   <td align="right">StringBuffer</td> 
   <td><strong>appendTail</strong>(StringBuffer sb)<br> 将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。</td> 
  </tr> 
  <tr> 
   <td align="right">int</td> 
   <td><strong>end</strong>()<br> 返回当前匹配的子串的最后一个字符在原目标字符串中的索引位置 。</td> 
  </tr> 
  <tr> 
   <td align="right">int</td> 
   <td><strong>end</strong>(int group)<br> 返回与匹配模式里指定的组相匹配的子串最后一个字符的位置。</td> 
  </tr> 
  <tr> 
   <td align="right">boolean</td> 
   <td><strong>find</strong>()<br> 尝试在目标字符串里查找下一个匹配子串。</td> 
  </tr> 
  <tr> 
   <td align="right">boolean</td> 
   <td><strong>find</strong>(int start)<br> 重设Matcher对象，并且尝试在目标字符串里从指定的位置开始查找下一个匹配的子串。</td> 
  </tr> 
  <tr> 
   <td align="right">String</td> 
   <td><strong>group</strong>()<br> 返回当前查找而获得的与组匹配的所有子串内容</td> 
  </tr> 
  <tr> 
   <td align="right">String</td> 
   <td><strong>group</strong>(int group)<br> 返回当前查找而获得的与指定的组匹配的子串内容</td> 
  </tr> 
  <tr> 
   <td align="right">int</td> 
   <td><strong>groupCount</strong>()<br> 返回当前查找所获得的匹配组的数量。</td> 
  </tr> 
  <tr> 
   <td align="right">boolean</td> 
   <td><strong>lookingAt</strong>()<br> 检测目标字符串是否以匹配的子串起始。</td> 
  </tr> 
  <tr> 
   <td align="right">boolean</td> 
   <td><strong>matches</strong>()<br> 尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。</td> 
  </tr> 
  <tr> 
   <td align="right">Pattern</td> 
   <td><strong>pattern</strong>()<br> 返回该Matcher对象的现有匹配模式，也就是对应的Pattern 对象。</td> 
  </tr> 
  <tr> 
   <td align="right">String</td> 
   <td><strong>replaceAll</strong>(String replacement)<br> 将目标字符串里与既有模式相匹配的子串全部替换为指定的字符串。</td> 
  </tr> 
  <tr> 
   <td align="right">String</td> 
   <td><strong>replaceFirst</strong>(String replacement)<br> 将目标字符串里第一个与既有模式相匹配的子串替换为指定的字符串。</td> 
  </tr> 
  <tr> 
   <td align="right">Matcher</td> 
   <td><strong>reset</strong>()<br> 重设该Matcher对象。</td> 
  </tr> 
  <tr> 
   <td align="right">Matcher</td> 
   <td><strong>reset</strong>(CharSequence input)<br> 重设该Matcher对象并且指定一个新的目标字符串。</td> 
  </tr> 
  <tr> 
   <td align="right">int</td> 
   <td><strong>start</strong>()<br> 返回当前查找所获子串的开始字符在原目标字符串中的位置。</td> 
  </tr> 
  <tr> 
   <td align="right">int</td> 
   <td><strong>start</strong>(int group)<br> 返回当前查找所获得的和指定组匹配的子串的第一个字符在原目标字符串中的位置。</td> 
  </tr> 
 </tbody> 
</table>

（光看方法的解释是不是很不好理解？不要急，待会结合例子就比较容易明白了）

一个Matcher实例是被用来对目标字符串进行基于既有模式（也就是一个给定的Pattern所编译的正则表达式）进行匹配查找的，所有往Matcher的输入都是通过CharSequence接口提供的，这样做的目的在于可以支持对从多元化的数据源所提供的数据进行匹配工作。

我们分别来看看各方法的使用：

★matches()/lookingAt ()/find()：  
一个Matcher对象是由一个Pattern对象调用其matcher()方法而生成的，一旦该Matcher对象生成,它就可以进行三种不同的匹配查找操作：

1.  matches()方法尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。
2.  lookingAt ()方法将检测目标字符串是否以匹配的子串起始。
3.  find()方法尝试在目标字符串里查找下一个匹配子串。

以上三个方法都将返回一个布尔值来表明成功与否。

★replaceAll ()/appendReplacement()/appendTail()：  
Matcher类同时提供了四个将匹配子串替换成指定字符串的方法：

1.  replaceAll()
2.  replaceFirst()
3.  appendReplacement()
4.  appendTail()

replaceAll()与replaceFirst()的用法都比较简单，请看上面方法的解释。我们主要重点了解一下appendReplacement()和appendTail()方法。

appendReplacement(StringBuffer sb, String replacement) 将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里，而appendTail(StringBuffer sb) 方法则将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。

例如，有字符串fatcatfatcatfat,假设既有正则表达式模式为"cat"，第一次匹配后调用appendReplacement(sb,"dog"),那么这时StringBuffer sb的内容为fatdog，也就是fatcat中的cat被替换为dog并且与匹配子串前的内容加到sb里，而第二次匹配后调用appendReplacement(sb,"dog")，那么sb的内容就变为fatdogfatdog，如果最后再调用一次appendTail（sb）,那么sb最终的内容将是fatdogfatdogfat。

还是有点模糊？那么我们来看个简单的程序：

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td> <pre style="margin-top:0px; margin-bottom:0px; padding:0px; white-space:pre-wrap; word-wrap:break-word"><code>//该例将把句子里的"Kelvin"改为"Kevin"
import java.util.regex.*;
public class MatcherTest{
    public static void main(String[] args) 
                         throws Exception {
        //生成Pattern对象并且编译一个简单的正则表达式"Kelvin"
        Pattern p = Pattern.compile("Kevin");
        //用Pattern类的matcher()方法生成一个Matcher对象
        Matcher m = p.matcher("Kelvin Li and Kelvin Chan are both working in Kelvin Chen's KelvinSoftShop company");
        StringBuffer sb = new StringBuffer();
        int i=0;
        //使用find()方法查找第一个匹配的对象
        boolean result = m.find();
        //使用循环将句子里所有的kelvin找出并替换再将内容加到sb里
        while(result) {
            i++;
            m.appendReplacement(sb, "Kevin");
            System.out.println("第"+i+"次匹配后sb的内容是："+sb);
            //继续查找下一个匹配对象
            result = m.find();
        }
        //最后调用appendTail()方法将最后一次匹配后的剩余字符串加到sb里；
        m.appendTail(sb);
        System.out.println("调用m.appendTail(sb)后sb的最终内容是:"+ sb.toString());
    }
}</code> </pre> </td> 
  </tr> 
 </tbody> 
</table>

最终输出结果为：  
第1次匹配后sb的内容是：Kevin  
第2次匹配后sb的内容是：Kevin Li and Kevin  
第3次匹配后sb的内容是：Kevin Li and Kevin Chan are both working in Kevin  
第4次匹配后sb的内容是：Kevin Li and Kevin Chan are both working in Kevin Chen's Kevin  
调用m.appendTail(sb)后sb的最终内容是：Kevin Li and Kevin Chan are both working in Kevin Chen's KevinSoftShop company.

看了上面这个例程是否对appendReplacement()，appendTail()两个方法的使用更清楚呢，如果还是不太肯定最好自己动手写几行代码测试一下。

★group()/group(int group)/groupCount()：  
该系列方法与我们在上篇介绍的Jakarta-ORO中的MatchResult .group()方法类似(有关Jakarta-ORO请参考上篇的内容)，都是要返回与组匹配的子串内容，下面代码将很好解释其用法：

public class GroupTest{
    public static void main(String[] args) 
                         throws Exception {
        Pattern p = Pattern.compile("(ca)(t)");        
        Matcher m = p.matcher("one cat,two cats in the yard");
        StringBuffer sb = new StringBuffer();
        boolean result = m.find();
        System.out.println("该次查找获得匹配组的数量为："+m.groupCount());
        for(int i=1;i&lt;=m.groupCount();i++){
         System.out.println("第"+i+"组的子串内容为： "+m.group(i));
        }
    }
}</code> </pre> </td> 
  </tr> 
 </tbody> 
</table>

输出为：  
该次查找获得匹配组的数量为：2  
第1组的子串内容为：ca  
第2组的子串内容为：t

Matcher对象的其他方法因比较好理解且由于篇幅有限，请读者自己编程验证。

4．一个检验Email地址的小程序：  
最后我们来看一个检验Email地址的例程，该程序是用来检验一个输入的EMAIL地址里所包含的字符是否合法，虽然这不是一个完整的EMAIL地址检验程序，它不能检验所有可能出现的情况，但在必要时您可以在其基础上增加所需功能。

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td> <pre style="margin-top:0px; margin-bottom:0px; padding:0px; white-space:pre-wrap; word-wrap:break-word"><code>import java.util.regex.*;
public class Email {
   public static void main(String[] args) throws Exception {
      String input = args[0];
      //检测输入的EMAIL地址是否以 非法符号"."或"@"作为起始字符      
      Pattern p = Pattern.compile("^//.|^//@");
      Matcher m = p.matcher(input);
      if (m.find()){
        System.err.println("EMAIL地址不能以'.'或'@'作为起始字符");
      }
      //检测是否以"www."为起始
      p = Pattern.compile("^www//.");
      m = p.matcher(input);
      if (m.find()) {
        System.out.println("EMAIL地址不能以'www.'起始");
      }
      //检测是否包含非法字符
      p = Pattern.compile("[^A-Za-z0-9//.//@_//-~#]+");
      m = p.matcher(input);
      StringBuffer sb = new StringBuffer();
      boolean result = m.find();
      boolean deletedIllegalChars = false;
      while(result) {
         //如果找到了非法字符那么就设下标记
         deletedIllegalChars = true;
         //如果里面包含非法字符如冒号双引号等，那么就把他们消去，加到SB里面
         m.appendReplacement(sb, "");
         result = m.find();
      }
      m.appendTail(sb);
      input = sb.toString();
      if (deletedIllegalChars) {
          System.out.println("输入的EMAIL地址里包含有冒号、逗号等非法字符，请修改");
          System.out.println("您现在的输入为: "+args[0]);
          System.out.println("修改后合法的地址应类似: "+input);
     }
   }
}</code> </pre> </td> 
  </tr> 
 </tbody> 
</table>

例如，我们在命令行输入：java Email www.kevin@163.net

那么输出结果将会是：EMAIL地址不能以'www.'起始

如果输入的EMAIL为@kevin@163.net

则输出为：EMAIL地址不能以'.'或'@'作为起始字符

当输入为：cgjmail\#$%@163.net

那么输出就是：

> 输入的EMAIL地址里包含有冒号、逗号等非法字符，请修改  
> 您现在的输入为: cgjmail\#$%@163.net  
> 修改后合法的地址应类似: cgjmail@163.net

5．总结：  
本文介绍了jdk1.4.0-beta3里正则表达式库--java.util.regex中的类以及其方法，如果结合与上一篇中所介绍的Jakarta-ORO API作比较，读者会更容易掌握该API的使用，当然该库的性能将在未来的日子里不断扩展，希望获得最新信息的读者最好到及时到SUN的网站去了解。

6．结束语：  
本来计划再多写一篇介绍一下需付费的正则表达式库中较具代表性的作品，但觉得既然有了免费且优秀的正则表达式库可以使用，何必还要去找需付费的呢，相信很多读者也是这么想的:，所以有兴趣了解更多其他的第三方正则表达式库的朋友可以自己到网上查找或者到我在参考资料里提供的网址去看看

[Link 1]: http://www-900.ibm.com/developerWorks/cn/java/l-regp/part1/index.shtml#author1
[cgjmail_163.net]: mailto:cgjmail@163.net
[Link 2]: http://jakarta.apache.org/oro/
[Link 3]: http://jakarta.apache.org/regexp/index.html
[Link 4]: http://www.javaworld.com/javaworld/jw-07-2001/jw-0713-regex.html
[Link 5]: http://www.effectiveperl.com/EP.04.pdf
[Link 6]: http://www.zvon.org/other/PerlTutorial/Output/index.html
[http_jakarta.apache.org_oro_api]: http://jakarta.apache.org/oro/api/
[Link 7]: http://www-900.ibm.com/developerWorks/cn/java/l-regp/part2/index.shtml#author1