JAVA 正则表达式（超详细）

梦里梦外; 2022-08-13 00:49 191阅读 0赞

### (PS:这篇文章为转载，我不喜欢转载的但我觉得这篇文章实在是超赞了，就转了过来，这篇可以说是学习JAVA正则表达的必读篇。作者是个正真有功力的人，阅读愉快) ###

在Sun的Java JDK 1.40版本中，Java自带了支持正则表达式的包，本文就抛砖引玉地介绍了如何使用java.util.regex包。

可粗略估计一下，除了偶尔用Linux的外，其他Linu x用户都会遇到正则表达式。正则表达式是个极端强大工具，而且在字符串模式-匹配和字符串模式-替换方面富有弹性。在Unix世界里，正则表达式几乎没有什么限制，可肯定的是，它应用非常之广泛。

正则表达式的引擎已被许多普通的Unix工具所实现，包括grep，awk，vi和Emacs等。此外，许多使用比较广泛的脚本语言也支持正则表达式，比如Python，Tcl，JavaScript，以及最著名的Perl。

我很早以前就是个Perl方面的黑客，如果你和我一样话，你也会非常依赖你手边的这些强大的text-munging工具。近几年来，像其他程序开发者一样，我也越来越关注Java的开发。

Java作为一种开发语言，有许多值得推荐的地方，但是它一直以来没有自带对正则表达式的支持。直到最近，借助于第三方的类库，Java开始支持正则表达式，但这些第三方的类库都不一致、兼容性差，而且维护代码起来很糟糕。这个缺点，对我选择Java作为首要的开发工具来说，一直是个巨大的顾虑之处。

你可以想象，当我知道Sun的Java JDK 1.40版本包含了java.util.regex(一个完全开放、自带的正则表达式包)时，是多么的高兴!很搞笑的说，我花好些时间去挖掘这个被隐藏起来的宝石。我非常惊奇的是，Java这样的一个很大改进(自带了java.util.regex包)为什么不多公开一点呢?!

最近，Java双脚都跳进了正则表达式的世界。java.util.regex包在支持正则表达也有它的过人之处，另外Java也提供详细的相关说明文档。使得朦朦胧胧的regex神秘景象也慢慢被拨开。有一些正则表达式的构成(可能最显著的是，在于糅合了字符类库)在Perl都找不到。

在regex包中，包括了两个类，Pattern(模式类)和Matcher(匹配器类)。Pattern类是用来表达和陈述所要搜索模式的对象，Matcher类是真正影响搜索的对象。另加一个新的例外类，PatternSyntaxException，当遇到不合法的搜索模式时，会抛出例外。

即使对正则表达式很熟悉，你会发现，通过java使用正则表达式也相当简单。要说明的一点是，对那些被Perl的单行匹配所宠坏的Perl狂热爱好者来说，在使用java的regex包进行替换操作时，会比他们所以前常用的方法费事些。

本文的局限之处，它不是一篇正则表达式用法的完全教程。如果读者要对正则表达进一步了解的话，推荐阅读Jeffrey Frieldl的Mastering Regular Expressions，该书由O’Reilly出版社出版。我下面就举一些例子来教读者如何使用正则表达式，以及如何更简单地去使用它。

设计一个简单的表达式来匹配任何电话号码数字可能是比较复杂的事情，原因在于电话号码格式有很多种情况。所有必须选择一个比较有效的模式。比如:(212) 555-1212， 212-555-1212和212 555 1212，某些人会认为它们都是等价的。

首先让我们构成一个正则表达式。为简单起见，先构成一个正则表达式来识别下面格式的电话号码数字:(nnn)nnn-nnnn。

第一步，创建一个pattern对象来匹配上面的子字符串。一旦程序运行后，如果需要的话，可以让这个对象一般化。匹配上面格式的正则表达可以这样构成:(/d\{3\})/s/d\{3\}-/d\{4\}，其中/d单字符类型用来匹配从0到9的任何数字，另外\{3\}重复符号，是个简便的记号，用来表示有3个连续的数字位，也等效于(/d/d/d)。/s也另外一个比较有用的单字符类型，用来匹配空格，比如Space键，tab键和换行符。

是不是很简单?但是，如果把这个正则表达式的模式用在java程序中，还要做两件事。对java的解释器来说，在反斜线字符(/)前的字符有特殊的含义。在java中，与regex有关的包，并不都能理解和识别反斜线字符(/)，尽管可以试试看。但为避免这一点，即为了让反斜线字符(/)在模式对象中被完全地传递，应该用双反斜线字符(/)。此外圆括号在正则表达中两层含义，如果想让它解释为字面上意思(即圆括号)，也需要在它前面用双反斜线字符(/)。也就是像下面的一样:

//(//d\{3\}//)//s//d\{3\}-//d\{4\}

现在介绍怎样在java代码中实现刚才所讲的正则表达式。要记住的事，在用正则表达式的包时，在你所定义的类前需要包含该包，也就是这样的一行:

import java.util.regex.\*;

下面的一段代码实现的功能是，从一个文本文件逐行读入，并逐行搜索电话号码数字，一旦找到所匹配的，然后输出在控制台。

BufferedReader in;

Pattern pattern = Pattern.compile("//(//d\{3\}//)//s//d\{3\}-//d\{4\}");

in = new BufferedReader(new FileReader("phone"));

String s;

while ((s = in.readLine()) != null)

Matcher matcher = pattern.matcher(s);

if (matcher.find())

System.out.println(matcher.group());

in.close();

对那些熟悉用Python或Javascript来实现正则表达式的人来说，这段代码很平常。在Python和Javascript这些语言中，或者其他的语言，这些正则表达式一旦明确地编译过后，你想用到哪里都可以。与Perl的单步匹配相比，看起来多多做了些工作，但这并不很费事。

find()方法，就像你所想象的，用来搜索与正则表达式相匹配的任何目标字符串，group()方法，用来返回包含了所匹配文本的字符串。应注意的是，上面的代码，仅用在每行只能含有一个匹配的电话号码数字字符串时。可以肯定的说，java的正则表达式包能用在一行含有多个匹配目标时的搜索。本文的原意在于举一些简单的例子来激起读者进一步去学习java自带的正则表达式包，所以对此就没有进行深入的探讨。

这相当漂亮吧! 但是很遗憾的是，这仅是个电话号码匹配器。很明显，还有两点可以改进。如果在电话号码的开头，即区位号和本地号码之间可能会有空格。我们也可匹配这些情况，则通过在正则表达式中加入/s?来实现，其中?元字符表示在模式可能有0或1个空格符。

第二点是，在本地号码位的前三位和后四位数字间有可能是空格符，而不是连字号，更有胜者，或根本就没有分隔符，就是7位数字连在一起。对这几种情况，我们可以用(-|)?来解决。这个结构的正则表达式就是转换器，它能匹配上面所说的几种情况。在()能含有管道符|时，它能匹配是否含有空格符或连字符，而尾部的?元字符表示是否根本没有分隔符的情况。

最后，区位号也可能没有包含在圆括号内，对此可以简单地在圆括号后附上?元字符，但这不是一个很好的解决方法。因为它也包含了不配对的圆括号，比如"(555" 或 "555)"。相反，我们可以通过另一种转换器来强迫让电话号码是否带有有圆括号:(/(/d\{3\}/)|/d\{3\})。如果我们把上面代码中的正则表达式用这些改进后的来替换的话，上面的代码就成了一个非常有用的电话号码数字匹配器:

Pattern pattern =

Pattern.compile("(//(//d\{3\}//)|//d\{3\})//s?//d\{3\}(-|)?//d\{4\}");

可以确定的是，你可以自己试着进一步改进上面的代码。

现在看看第二个例子，它是从Friedl的中改编过来的。其功能是用来检查文本文件中是否有重复的单词，这在印刷排版中会经常遇到，同样也是个语法检查器的问题。

匹配单词，像其他的一样，也可以通过好几种的正则表达式来完成。可能最直接的是/b/w+/b，其优点在于只需用少量的regex元字符。其中/w元字符用来匹配从字母a到u的任何字符。+元字符表示匹配匹配一次或多次字符，/b元字符是用来说明匹配单词的边界，它可以是空格或任何一种不同的标点符号(包括逗号，句号等)。

现在，我们怎样来检查一个给定的单词是否被重复了三次?为完成这个任务，需充分利用正则表达式中的所熟知的向后扫描。如前面提到的，圆括号在正则表达式中有几种不同的用法，一个就是能提供组合类型，组合类型用来保存所匹配的结果或部分匹配的结果(以便后面能用到)，即使遇到有相同的模式。在同样的正则表达中，可能(也通常期望)不止有一个组合类型。在第n个组合类型中匹配结果可以通过向后扫描来获取到。向后扫描使得搜索重复的单词非常简单:/b(/w+)/s+/1/b。

圆括号形成了一个组合类型，在这个正则表示中它是第一组合类型(也是仅有的一个)。向后扫描/1，指的是任何被/w+所匹配的单词。我们的正则表达式因此能匹配这样的单词，它有一个或多个空格符，后面还跟有一个与此相同的单词。注意的是，尾部的定位类型(/b)必不可少，它可以防止发生错误。如果我们想匹配"Paris in the the spring"，而不是匹配"Java's regex package is the theme of this article"。根据java现在的格式，则上面的正则表达式就是:Pattern pattern =Pattern.compile("//b(//w+)//s+//1//b");

最后进一步的修改是让我们的匹配器对大小写敏感。比如，下面的情况:"The the theme of this article is the Java's regex package."，这一点在regex中能非常简单地实现，即通过使用在Pattern类中预定义的静态标志CASE\_INSENSITIVE :

Pattern pattern =Pattern.compile("//b(//w+)//s+//1//b",

Pattern.CASE\_INSENSITIVE);

有关正则表达式的话题是非常丰富，而且复杂的，用Java来实现也非常广泛，则需要对regex包进行的彻底研究，我们在这里所讲的只是冰山一角。即使你对正则表达式比较陌生，使用regex包后会很快发现它强大功能和可伸缩性。如果你是个来自Perl或其他语言王国的老练的正则表达式的黑客，使用过regex包后，你将会安心地投入到java的世界，而放弃其他的工具，并把java的regex包看成是手边必备的利器。

<table style="table-layout:fixed"> 
 <tbody> 
  <tr> 
   <td> 
    <div> 
     <h4><a rel="nofollow"></a>CharSequence</h4> 
     <p>JDK 1.4定义了一个新的接口，叫<span>CharSequence</span>。它提供了<span>String</span>和<span>StringBuffer</span>这两个类的字符序列的抽象：</p> 
     <blockquote> 
      <pre><span style="color:#0000ff">interface</span> CharSequence {
  charAt(<span style="color:#0000ff">int</span> i);
  length();
  subSequence(<span style="color:#0000ff">int</span> start, <span style="color:#0000ff">int</span> end);
  toString();
}</pre> 
     </blockquote> 
     <p>为了实现这个新的<span>CharSequence</span>接口，<span>String</span>，<span>StringBuffer</span>以及<span>CharBuffer</span>都作了修改。很多正则表达式的操作都要拿<span>CharSequence</span>作参数。</p> 
     <h3><a rel="nofollow"></a><span>Pattern</span>和<span>Matcher</span></h3> 
     <p>先给一个例子。下面这段程序可以测试正则表达式是否匹配字符串。第一个参数是要匹配的字符串，后面是正则表达式。正则表达式可以有多个。在Unix/Linux环境下，命令行下的正则表达式还必须用引号。</p> 
     <table> 
      <tbody> 
       <tr> 
        <td> <pre><span style="color:#009900">//: c12:TestRegularExpression.java</span>
<span style="color:#009900">// Allows you to easly try out regular expressions.</span>
<span style="color:#009900">// {Args: abcabcabcdefabc "abc+" "(abc)+" "(abc){2,}" }</span>
<span style="color:#0000ff">import</span> java.util.regex.*;
<span style="color:#0000ff">public</span><span style="color:#0000ff">class</span> TestRegularExpression {
<span style="color:#0000ff">public</span><span style="color:#0000ff">static</span><span style="color:#0000ff">void</span> main(String[] args) {
<span style="color:#0000ff">if</span>(args.length &lt; 2) {
      System.out.println(<span style="color:#004488">"Usage:/n"</span> +
<span style="color:#004488">"java TestRegularExpression "</span> +
<span style="color:#004488">"characterSequence regularExpression+"</span>);
      System.exit(0);
    }
    System.out.println(<span style="color:#004488">"Input: /"</span><span style="color:#004488">" + args[0] + "</span>/<span style="color:#004488">""</span>);
<span style="color:#0000ff">for</span>(<span style="color:#0000ff">int</span> i = 1; i &lt; args.length; i++) {
      System.out.println(
<span style="color:#004488">"Regular expression: /"</span><span style="color:#004488">" + args[i] + "</span>/<span style="color:#004488">""</span>);
      Pattern p = Pattern.compile(args[i]);
      Matcher m = p.matcher(args[0]);
<span style="color:#0000ff">while</span>(m.find()) {
        System.out.println(<span style="color:#004488">"Match /"</span>" + m.group() +
<span style="color:#004488">"/"</span> at positions " +
          m.start() + <span style="color:#004488">"-"</span> + (m.end() - 1));
      }
    }
  }
} <span style="color:#009900">///:~</span></pre> </td> 
       </tr> 
      </tbody> 
     </table> 
     <p><strong><span>Java</span>的正则表达式是由<span>java.util.regex</span>的<span>Pattern</span>和<span>Matcher</span>类实现的</strong>。<span>Pattern</span>对象表示经编译的正则表达式。静态的<span>compile( )</span>方法负责将表示正则表达式的字符串编译成<span>Pattern</span>对象。正如上述例程所示的，只要给<span>Pattern</span>的<span>matcher( )</span>方法送一个字符串就能获取一个<span>Matcher</span>对象。此外，<span>Pattern</span>还有一个能快速判断能否在<span>input</span>里面找到<span>regex</span>的</p> 
     <blockquote> 
      <pre><span style="color:#0000ff">static</span><span style="color:#0000ff">boolean</span> matches(?regex, ?input)</pre> 
     </blockquote> 
     <p>以及能返回<span>String</span>数组的<span>split( )</span>方法，它能用<span>regex</span>把字符串分割开来。</p> 
     <p>只要给<span>Pattern.matcher( )</span>方法传一个字符串就能获得<span>Matcher</span>对象了。接下来就能用<span>Matcher</span>的方法来查询匹配的结果了。</p> 
     <blockquote> 
      <pre><span style="color:#0000ff">boolean</span> matches()
<span style="color:#0000ff">boolean</span> lookingAt()
<span style="color:#0000ff">boolean</span> find()
<span style="color:#0000ff">boolean</span> find(<span style="color:#0000ff">int</span> start)</pre> 
     </blockquote> 
     <p><span>matches( )</span>的前提是<span>Pattern</span>匹配整个字符串，而<span>lookingAt( )</span>的意思是<span>Pattern</span>匹配字符串的开头。 </p> 
     <h4><a rel="nofollow"></a>find( )</h4> 
     <p><span>Matcher.find( )</span>的功能是发现<span>CharSequence</span>里的，与pattern相匹配的多个字符序列。例如：</p> 
     <table> 
      <tbody> 
       <tr> 
        <td> <pre><span style="color:#009900">//: c12:FindDemo.java</span>
<span style="color:#0000ff">import</span> java.util.regex.*;
<span style="color:#0000ff">import</span> com.bruceeckel.simpletest.*;
<span style="color:#0000ff">import</span> java.util.*;
<span style="color:#0000ff">public</span><span style="color:#0000ff">class</span> FindDemo {
<span style="color:#0000ff">private</span><span style="color:#0000ff">static</span> Test monitor = <span style="color:#0000ff">new</span> Test();
<span style="color:#0000ff">public</span><span style="color:#0000ff">static</span><span style="color:#0000ff">void</span> main(String[] args) {
    Matcher m = Pattern.compile(<span style="color:#004488">"//w+"</span>)
      .matcher(<span style="color:#004488">"Evening is full of the linnet's wings"</span>);
<span style="color:#0000ff">while</span>(m.find())
      System.out.println(m.group());
<span style="color:#0000ff">int</span> i = 0;
<span style="color:#0000ff">while</span>(m.find(i)) {
      System.out.print(m.group() + <span style="color:#004488">" "</span>);
      i++;
    }
    monitor.expect(<span style="color:#0000ff">new</span> String[] {
<span style="color:#004488">"Evening"</span>,
<span style="color:#004488">"is"</span>,
<span style="color:#004488">"full"</span>,
<span style="color:#004488">"of"</span>,
<span style="color:#004488">"the"</span>,
<span style="color:#004488">"linnet"</span>,
<span style="color:#004488">"s"</span>,
<span style="color:#004488">"wings"</span>,
<span style="color:#004488">"Evening vening ening ning ing ng g is is s full "</span> +
<span style="color:#004488">"full ull ll l of of f the the he e linnet linnet "</span> +
<span style="color:#004488">"innet nnet net et t s s wings wings ings ngs gs s "</span>
    });
  }
} <span style="color:#009900">///:~</span></pre> </td> 
       </tr> 
      </tbody> 
     </table> 
     <p>"<span>//w+</span>"的意思是"一个或多个单词字符"，因此它会将字符串直接分解成单词。<span>find( )</span>像一个迭代器，从头到尾扫描一遍字符串。第二个<span>find( )</span>是带<span>int</span>参数的，正如你所看到的，它会告诉方法从哪里开始找——即从参数位置开始查找。</p> 
     <h4><a rel="nofollow"></a>Groups</h4> 
     <p>Group是指里用括号括起来的，能被后面的表达式调用的正则表达式。Group 0 表示整个表达式，group 1表示第一个被括起来的group，以此类推。所以；</p> 
     <blockquote> 
      <pre>A(B(C))D</pre> 
     </blockquote> 
     <p>里面有三个group：group 0是<span>ABCD</span>， group 1是<span>BC</span>，group 2是<span>C</span>。</p> 
     <p>你可以用下述<span>Matcher</span>方法来使用group：</p> 
     <p><span>public int groupCount( )</span>返回matcher对象中的group的数目。不包括group0。</p> 
     <p><span>public String group( ) </span>返回上次匹配操作(比方说<span>find( )</span>)的group 0(整个匹配)</p> 
     <p><span>public String group(int i)</span>返回上次匹配操作的某个group。如果匹配成功，但是没能找到group，则返回null。</p> 
     <p><span>public int start(int group)</span>返回上次匹配所找到的，group的开始位置。</p> 
     <p><span>public int end(int group)</span>返回上次匹配所找到的，group的结束位置，最后一个字符的下标加一。</p> 
     <table> 
      <tbody> 
       <tr> 
        <td> <pre><span style="color:#009900">//: c12:Groups.java</span>
<span style="color:#0000ff">import</span> java.util.regex.*;
<span style="color:#0000ff">import</span> com.bruceeckel.simpletest.*;
<span style="color:#0000ff">public</span><span style="color:#0000ff">class</span> Groups {
<span style="color:#0000ff">private</span><span style="color:#0000ff">static</span> Test monitor = <span style="color:#0000ff">new</span> Test();
<span style="color:#0000ff">static</span><span style="color:#0000ff">public</span><span style="color:#0000ff">final</span> String poem =
<span style="color:#004488">"Twas brillig, and the slithy toves/n"</span> +
<span style="color:#004488">"Did gyre and gimble in the wabe./n"</span> +
<span style="color:#004488">"All mimsy were the borogoves,/n"</span> +
<span style="color:#004488">"And the mome raths outgrabe./n/n"</span> +
<span style="color:#004488">"Beware the Jabberwock, my son,/n"</span> +
<span style="color:#004488">"The jaws that bite, the claws that catch./n"</span> +
<span style="color:#004488">"Beware the Jubjub bird, and shun/n"</span> +
<span style="color:#004488">"The frumious Bandersnatch."</span>;
<span style="color:#0000ff">public</span><span style="color:#0000ff">static</span><span style="color:#0000ff">void</span> main(String[] args) {
    Matcher m =
      Pattern.compile(<span style="color:#004488">"(?m)(//S+)//s+((//S+)//s+(//S+))___FCKpd___6quot;</span>)
        .matcher(poem);
<span style="color:#0000ff">while</span>(m.find()) {
<span style="color:#0000ff">for</span>(<span style="color:#0000ff">int</span> j = 0; j &lt;= m.groupCount(); j++)
        System.out.print(<span style="color:#004488">"["</span> + m.group(j) + <span style="color:#004488">"]"</span>);
      System.out.println();
    }
    monitor.expect(<span style="color:#0000ff">new</span> String[]{
<span style="color:#004488">"[the slithy toves]"</span> +
<span style="color:#004488">"[the][slithy toves][slithy][toves]"</span>,
<span style="color:#004488">"[in the wabe.][in][the wabe.][the][wabe.]"</span>,
<span style="color:#004488">"[were the borogoves,]"</span> +
<span style="color:#004488">"[were][the borogoves,][the][borogoves,]"</span>,
<span style="color:#004488">"[mome raths outgrabe.]"</span> +
<span style="color:#004488">"[mome][raths outgrabe.][raths][outgrabe.]"</span>,
<span style="color:#004488">"[Jabberwock, my son,]"</span> +
<span style="color:#004488">"[Jabberwock,][my son,][my][son,]"</span>,
<span style="color:#004488">"[claws that catch.]"</span> +
<span style="color:#004488">"[claws][that catch.][that][catch.]"</span>,
<span style="color:#004488">"[bird, and shun][bird,][and shun][and][shun]"</span>,
<span style="color:#004488">"[The frumious Bandersnatch.][The]"</span> +
<span style="color:#004488">"[frumious Bandersnatch.][frumious][Bandersnatch.]"</span>
    });
  }
} <span style="color:#009900">///:~</span></pre> </td> 
       </tr> 
      </tbody> 
     </table> 
     <p>这首诗是<span><cite><strong><span style="font-family:微软雅黑; font-size:12px; color:#d59139">Through the Looking Glass</span></strong></cite></span>的，Lewis Carroll的"Jabberwocky"的第一部分。可以看到这个正则表达式里有很多用括号括起来的group，它是由任意多个连续的非空字符('<span>/S+</span>')和任意多个连续的空格字符('<span>/s+</span>')所组成的，其最终目的是要捕获每行的最后三个单词；'<span>$</span>'表示一行的结尾。但是'<span>$</span>'通常表示整个字符串的结尾，所以这里要明确地告诉正则表达式注意换行符。这一点是由'<span>(?m)</span>'标志完成的(模式标志会过一会讲解)。</p> 
     <h4><a rel="nofollow"></a>start( )和end( )</h4> 
     <p>如果匹配成功，<span>start( )</span>会返回此次匹配的开始位置，<span>end( )</span>会返回此次匹配的结束位置，即最后一个字符的下标加一。如果之前的匹配不成功(或者没匹配)，那么无论是调用<span>start( )</span>还是<span>end( )</span>，都会引发一个<span>IllegalStateException</span>。下面这段程序还演示了<span>matches( )</span>和<span>lookingAt( )</span>：</p> 
     <table> 
      <tbody> 
       <tr> 
        <td> <pre><span style="color:#009900">//: c12:StartEnd.java</span>
<span style="color:#0000ff">import</span> java.util.regex.*;
<span style="color:#0000ff">import</span> com.bruceeckel.simpletest.*;
<span style="color:#0000ff">public</span><span style="color:#0000ff">class</span> StartEnd {
<span style="color:#0000ff">private</span><span style="color:#0000ff">static</span> Test monitor = <span style="color:#0000ff">new</span> Test();
<span style="color:#0000ff">public</span><span style="color:#0000ff">static</span><span style="color:#0000ff">void</span> main(String[] args) {
    String[] input = <span style="color:#0000ff">new</span> String[] {
<span style="color:#004488">"Java has regular expressions in 1.4"</span>,
<span style="color:#004488">"regular expressions now expressing in Java"</span>,
<span style="color:#004488">"Java represses oracular expressions"</span>
    };
    Pattern
      p1 = Pattern.compile(<span style="color:#004488">"re//w*"</span>),
      p2 = Pattern.compile(<span style="color:#004488">"Java.*"</span>);
<span style="color:#0000ff">for</span>(<span style="color:#0000ff">int</span> i = 0; i &lt; input.length; i++) {
      System.out.println(<span style="color:#004488">"input "</span> + i + <span style="color:#004488">": "</span> + input[i]);
      Matcher
        m1 = p1.matcher(input[i]),
        m2 = p2.matcher(input[i]);
<span style="color:#0000ff">while</span>(m1.find())
        System.out.println(<span style="color:#004488">"m1.find() '"</span> + m1.group() +
<span style="color:#004488">"' start = "</span>+ m1.start() + <span style="color:#004488">" end = "</span> + m1.end());
<span style="color:#0000ff">while</span>(m2.find())
        System.out.println(<span style="color:#004488">"m2.find() '"</span> + m2.group() +
<span style="color:#004488">"' start = "</span>+ m2.start() + <span style="color:#004488">" end = "</span> + m2.end());
<span style="color:#0000ff">if</span>(m1.lookingAt()) <span style="color:#009900">// No reset() necessary</span>
        System.out.println(<span style="color:#004488">"m1.lookingAt() start = "</span>
          + m1.start() + <span style="color:#004488">" end = "</span> + m1.end());
<span style="color:#0000ff">if</span>(m2.lookingAt())
        System.out.println(<span style="color:#004488">"m2.lookingAt() start = "</span>
          + m2.start() + <span style="color:#004488">" end = "</span> + m2.end());
<span style="color:#0000ff">if</span>(m1.matches()) <span style="color:#009900">// No reset() necessary</span>
        System.out.println(<span style="color:#004488">"m1.matches() start = "</span>
          + m1.start() + <span style="color:#004488">" end = "</span> + m1.end());
<span style="color:#0000ff">if</span>(m2.matches())
        System.out.println(<span style="color:#004488">"m2.matches() start = "</span>
          + m2.start() + <span style="color:#004488">" end = "</span> + m2.end());
    }
    monitor.expect(<span style="color:#0000ff">new</span> String[] {
<span style="color:#004488">"input 0: Java has regular expressions in 1.4"</span>,
<span style="color:#004488">"m1.find() 'regular' start = 9 end = 16"</span>,
<span style="color:#004488">"m1.find() 'ressions' start = 20 end = 28"</span>,
<span style="color:#004488">"m2.find() 'Java has regular expressions in 1.4'"</span> +
<span style="color:#004488">" start = 0 end = 35"</span>,
<span style="color:#004488">"m2.lookingAt() start = 0 end = 35"</span>,
<span style="color:#004488">"m2.matches() start = 0 end = 35"</span>,
<span style="color:#004488">"input 1: regular expressions now "</span> +
<span style="color:#004488">"expressing in Java"</span>,
<span style="color:#004488">"m1.find() 'regular' start = 0 end = 7"</span>,
<span style="color:#004488">"m1.find() 'ressions' start = 11 end = 19"</span>,
<span style="color:#004488">"m1.find() 'ressing' start = 27 end = 34"</span>,
<span style="color:#004488">"m2.find() 'Java' start = 38 end = 42"</span>,
<span style="color:#004488">"m1.lookingAt() start = 0 end = 7"</span>,
<span style="color:#004488">"input 2: Java represses oracular expressions"</span>,
<span style="color:#004488">"m1.find() 'represses' start = 5 end = 14"</span>,
<span style="color:#004488">"m1.find() 'ressions' start = 27 end = 35"</span>,
<span style="color:#004488">"m2.find() 'Java represses oracular expressions' "</span> +
<span style="color:#004488">"start = 0 end = 35"</span>,
<span style="color:#004488">"m2.lookingAt() start = 0 end = 35"</span>,
<span style="color:#004488">"m2.matches() start = 0 end = 35"</span>
    });
  }
} <span style="color:#009900">///:~</span></pre> </td> 
       </tr> 
      </tbody> 
     </table> 
     <p>注意，只要字符串里有这个模式，<span>find( )</span>就能把它给找出来，但是<span>lookingAt( )</span>和<span>matches( )</span>，只有在字符串与正则表达式一开始就相匹配的情况下才能返回<span>true</span>。<span>matches( )</span>成功的前提是正则表达式与字符串完全匹配，而<span>lookingAt( )</span>成功的前提是，字符串的开始部分与正则表达式相匹配。</p> 
     <h4><a rel="nofollow"></a>匹配的模式(Pattern flags)</h4> 
     <p><span>compile( )</span>方法还有一个版本，它需要一个控制正则表达式的匹配行为的参数：</p> 
     <blockquote> 
      <pre>Pattern Pattern.compile(String regex, <span style="color:#0000ff">int</span> flag)</pre> 
     </blockquote> 
     <span>flag</span>的取值范围如下： 
     <table> 
      <tbody> 
       <tr> 
        <th><span>编译标志</span></th> 
        <th><span>效果</span></th> 
       </tr> 
       <tr> 
        <td><span>Pattern.CANON_EQ</span></td> 
        <td>当且仅当两个字符的"正规分解(canonical decomposition)"都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式"a/u030A"会匹配"?"。默认情况下，不考虑"规范相等性(canonical equivalence)"。</td> 
       </tr> 
       <tr> 
        <td><span>Pattern.CASE_INSENSITIVE<br> (?i)</span></td> 
        <td>默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹配，只要将<span>UNICODE_CASE</span>与这个标志合起来就行了。</td> 
       </tr> 
       <tr> 
        <td><span>Pattern.COMMENTS<br> (?x)</span></td> 
        <td>在这种模式下，匹配时会忽略(正则表达式里的)空格字符(注：不是指表达式里的"//s"，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。</td> 
       </tr> 
       <tr> 
        <td><span>Pattern.DOTALL<br> (?s)</span></td> 
        <td>在这种模式下，表达式'.'可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式'.'不匹配行的结束符。</td> 
       </tr> 
       <tr> 
        <td><span>Pattern.MULTILINE<br> (?m)</span></td> 
        <td>在这种模式下，'^'和'$'分别匹配一行的开始和结束。此外，'^'仍然匹配字符串的开始，'$'也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束。</td> 
       </tr> 
       <tr> 
        <td><span>Pattern.UNICODE_CASE<br> (?u)</span></td> 
        <td>在这个模式下，如果你还启用了<span>CASE_INSENSITIVE</span>标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。</td> 
       </tr> 
       <tr> 
        <td><span>Pattern.UNIX_LINES<br> (?d)</span></td> 
        <td>在这个模式下，只有'/n'才被认作一行的中止，并且与'.'，'^'，以及'$'进行匹配。</td> 
       </tr> 
      </tbody> 
     </table> 
     <p>在这些标志里面，<span>Pattern.CASE_INSENSITIVE</span>，<span>Pattern.MULTILINE</span>，以及<span>Pattern.COMMENTS</span>是最有用的(其中<span>Pattern.COMMENTS</span>还能帮我们把思路理清楚，并且/或者做文档)。注意，你可以用在表达式里插记号的方式来启用绝大多数的模式。这些记号就在上面那张表的各个标志的下面。你希望模式从哪里开始启动，就在哪里插记号。</p> 
     <p>可以用"OR" ('|')运算符把这些标志合使用：</p> 
     <table> 
      <tbody> 
       <tr> 
        <td> <pre><span style="color:#009900">//: c12:ReFlags.java</span>
<span style="color:#0000ff">import</span> java.util.regex.*;
<span style="color:#0000ff">import</span> com.bruceeckel.simpletest.*;
<span style="color:#0000ff">public</span><span style="color:#0000ff">class</span> ReFlags {
<span style="color:#0000ff">private</span><span style="color:#0000ff">static</span> Test monitor = <span style="color:#0000ff">new</span> Test();
<span style="color:#0000ff">public</span><span style="color:#0000ff">static</span><span style="color:#0000ff">void</span> main(String[] args) {
    Pattern p =  Pattern.compile(<span style="color:#004488">"^java"</span>,
      Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
    Matcher m = p.matcher(
<span style="color:#004488">"java has regex/nJava has regex/n"</span> +
<span style="color:#004488">"JAVA has pretty good regular expressions/n"</span> +
<span style="color:#004488">"Regular expressions are in Java"</span>);
<span style="color:#0000ff">while</span>(m.find())
      System.out.println(m.group());
    monitor.expect(<span style="color:#0000ff">new</span> String[] {
<span style="color:#004488">"java"</span>,
<span style="color:#004488">"Java"</span>,
<span style="color:#004488">"JAVA"</span>
    });
  }
} <span style="color:#009900">///:~</span></pre> </td> 
       </tr> 
      </tbody> 
     </table> 
     <p>这样创建出来的正则表达式就能匹配以"java"，"Java"，"JAVA"...开头的字符串了。此外，如果字符串分好几行，那它还会对每一行做匹配(匹配始于字符序列的开始，终于字符序列当中的行结束符)。注意，<span>group( )</span>方法仅返回匹配的部分。</p> 
     <h3><a rel="nofollow"></a>split( )</h3> 
     <p>所谓分割是指将以正则表达式为界，将字符串分割成<span>String</span>数组。</p> 
     <blockquote> 
      <pre>String[] split(CharSequence charseq)
String[] split(CharSequence charseq, <span style="color:#0000ff">int</span> limit)</pre> 
     </blockquote> 
     <p>这是一种既快又方便地将文本根据一些常见的边界标志分割开来的方法。</p> 
     <table> 
      <tbody> 
       <tr> 
        <td> <pre><span style="color:#009900">//: c12:SplitDemo.java</span>
<span style="color:#0000ff">import</span> java.util.regex.*;
<span style="color:#0000ff">import</span> com.bruceeckel.simpletest.*;
<span style="color:#0000ff">import</span> java.util.*;
<span style="color:#0000ff">public</span><span style="color:#0000ff">class</span> SplitDemo {
<span style="color:#0000ff">private</span><span style="color:#0000ff">static</span> Test monitor = <span style="color:#0000ff">new</span> Test();
<span style="color:#0000ff">public</span><span style="color:#0000ff">static</span><span style="color:#0000ff">void</span> main(String[] args) {
    String input =
<span style="color:#004488">"This!!unusual use!!of exclamation!!points"</span>;
    System.out.println(Arrays.asList(
      Pattern.compile(<span style="color:#004488">"!!"</span>).split(input)));
<span style="color:#009900">// Only do the first three:</span>
    System.out.println(Arrays.asList(
      Pattern.compile(<span style="color:#004488">"!!"</span>).split(input, 3)));
    System.out.println(Arrays.asList(
<span style="color:#004488">"Aha! String has a split() built in!"</span>.split(<span style="color:#004488">" "</span>)));
    monitor.expect(<span style="color:#0000ff">new</span> String[] {
<span style="color:#004488">"[This, unusual use, of exclamation, points]"</span>,
<span style="color:#004488">"[This, unusual use, of exclamation!!points]"</span>,
<span style="color:#004488">"[Aha!, String, has, a, split(), built, in!]"</span>
    });
  }
} <span style="color:#009900">///:~</span></pre> </td> 
       </tr> 
      </tbody> 
     </table> 
     <p>第二个<span>split( )</span>会限定分割的次数。</p> 
     <p>正则表达式是如此重要，以至于有些功能被加进了<span>String</span>类，其中包括<span>split( )</span>(已经看到了)，<span>matches( )</span>，<span>replaceFirst( )</span>以及<span>replaceAll( )</span>。这些方法的功能同<span>Pattern</span>和<span>Matcher</span>的相同。 </p> 
     <h3><a rel="nofollow"></a>替换操作</h3> 
     <p>正则表达式在替换文本方面特别在行。下面就是一些方法：</p> 
     <p><span>replaceFirst(String replacement)</span>将字符串里，第一个与模式相匹配的子串替换成<span>replacement</span>。 </p> 
     <p><span>replaceAll(String replacement)</span>，将输入字符串里所有与模式相匹配的子串全部替换成<span>replacement</span>。</p> 
     <p><span>appendReplacement(StringBuffer sbuf, String replacement)</span>对<span>sbuf</span>进行逐次替换，而不是像<span>replaceFirst( )</span>或<span>replaceAll( )</span>那样，只替换第一个或全部子串。这是个非常重要的方法，因为它可以调用方法来生成<span>replacement</span>(<span>replaceFirst( )</span>和<span>replaceAll( )</span>只允许用固定的字符串来充当<span>replacement</span>)。有了这个方法，你就可以编程区分group，从而实现更强大的替换功能。</p> 
     <p>调用完<span>appendReplacement( )</span>之后，为了把剩余的字符串拷贝回去，必须调用<span>appendTail(StringBuffer sbuf, String replacement)</span>。 </p> 
     <p>下面我们来演示一下怎样使用这些替换方法。说明一下，这段程序所处理的字符串是它自己开头部分的注释，是用正则表达式提取出来并加以处理之后再传给替换方法的。</p> 
     <table> 
      <tbody> 
       <tr> 
        <td> <pre><span style="color:#009900">//: c12:TheReplacements.java</span>
<span style="color:#0000ff">import</span> java.util.regex.*;
<span style="color:#0000ff">import</span> java.io.*;
<span style="color:#0000ff">import</span> com.bruceeckel.util.*;
<span style="color:#0000ff">import</span> com.bruceeckel.simpletest.*;
<span style="color:#009900">/*! Here's a block of text to use as input to
    the regular expression matcher. Note that we'll
    first extract the block of text by looking for
    the special delimiters, then process the
    extracted block. !*/</span>
<span style="color:#0000ff">public</span><span style="color:#0000ff">class</span> TheReplacements {
<span style="color:#0000ff">private</span><span style="color:#0000ff">static</span> Test monitor = <span style="color:#0000ff">new</span> Test();
<span style="color:#0000ff">public</span><span style="color:#0000ff">static</span><span style="color:#0000ff">void</span> main(String[] args) <span style="color:#0000ff">throws</span> Exception {
    String s = TextFile.read(<span style="color:#004488">"TheReplacements.java"</span>);
<span style="color:#009900">// Match the specially-commented block of text above:</span>
    Matcher mInput =
      Pattern.compile(<span style="color:#004488">"</span><span style="color:#004488">///*!(.*)!//*</span><span style="color:#004488">/"</span>, Pattern.DOTALL)
        .matcher(s);
<span style="color:#0000ff">if</span>(mInput.find())
      s = mInput.group(1); <span style="color:#009900">// Captured by parentheses</span>
<span style="color:#009900">// Replace two or more spaces with a single space:</span>
    s = s.replaceAll(<span style="color:#004488">" {2,}"</span>, <span style="color:#004488">" "</span>);
<span style="color:#009900">// Replace one or more spaces at the beginning of each</span>
<span style="color:#009900">// line with no spaces. Must enable MULTILINE mode:</span>
    s = s.replaceAll(<span style="color:#004488">"(?m)^ +"</span>, <span style="color:#004488">""</span>);
    System.out.println(s);
    s = s.replaceFirst(<span style="color:#004488">"[aeiou]"</span>, <span style="color:#004488">"(VOWEL1)"</span>);
    StringBuffer sbuf = <span style="color:#0000ff">new</span> StringBuffer();
    Pattern p = Pattern.compile(<span style="color:#004488">"[aeiou]"</span>);
    Matcher m = p.matcher(s);
<span style="color:#009900">// Process the find information as you</span>
<span style="color:#009900">// perform the replacements:</span>
<span style="color:#0000ff">while</span>(m.find())
      m.appendReplacement(sbuf, m.group().toUpperCase());
<span style="color:#009900">// Put in the remainder of the text:</span>
    m.appendTail(sbuf);
    System.out.println(sbuf);
    monitor.expect(<span style="color:#0000ff">new</span> String[]{
<span style="color:#004488">"Here's a block of text to use as input to"</span>,
<span style="color:#004488">"the regular expression matcher. Note that we'll"</span>,
<span style="color:#004488">"first extract the block of text by looking for"</span>,
<span style="color:#004488">"the special delimiters, then process the"</span>,
<span style="color:#004488">"extracted block. "</span>,
<span style="color:#004488">"H(VOWEL1)rE's A blOck Of tExt tO UsE As InpUt tO"</span>,
<span style="color:#004488">"thE rEgUlAr ExprEssIOn mAtchEr. NOtE thAt wE'll"</span>,
<span style="color:#004488">"fIrst ExtrAct thE blOck Of tExt by lOOkIng fOr"</span>,
<span style="color:#004488">"thE spEcIAl dElImItErs, thEn prOcEss thE"</span>,
<span style="color:#004488">"ExtrActEd blOck. "</span>
    });
  }
} <span style="color:#009900">///:~</span></pre> </td> 
       </tr> 
      </tbody> 
     </table> 
     <p>用<span>TextFile.read( )</span>方法来打开和读取文件。<span>mInput</span>的功能是匹配'<span>/*!</span>' 和 '<span>!*/</span>' 之间的文本(注意一下分组用的括号)。接下来，我们将所有两个以上的连续空格全都替换成一个，并且将各行开头的空格全都去掉(为了让这个正则表达式能对所有的行，而不仅仅是第一行起作用，必须启用多行模式)。这两个操作都用了<span>String</span>的<span>replaceAll( )</span>(这里用它更方便)。注意，由于每个替换只做一次，因此除了预编译<span>Pattern</span>之外，程序没有额外的开销。</p> 
     <p><span>replaceFirst( )</span>只替换第一个子串。此外，<span>replaceFirst( )</span>和<span>replaceAll( )</span>只能用常量(literal)来替换，所以如果每次替换的时候还要进行一些操作的话，它们是无能为力的。碰到这种情况，得用<span>appendReplacement( )</span>，它能在进行替换的时候想写多少代码就写多少。在上面那段程序里，创建<span>sbuf</span>的过程就是选group做处理，也就是用正则表达式把元音字母找出来，然后换成大写的过程。通常你得在完成全部的替换之后才调用<span>appendTail( )</span>，但是如果要模仿<span>replaceFirst( )</span>(或"replace n")的效果，你也可以只替换一次就调用<span>appendTail( )</span>。它会把剩下的东西全都放进<span>sbuf</span>。</p> 
     <p>你还可以在<span>appendReplacement( )</span>的<span>replacement</span>参数里用"$g"引用已捕获的group，其中'g' 表示group的号码。不过这是为一些比较简单的操作准备的，因而其效果无法与上述程序相比。</p> 
     <h3><a rel="nofollow"></a>reset( )</h3> 
     <p>此外，还可以用<span>reset( )</span>方法给现有的<span>Matcher</span>对象配上个新的<span>CharSequence</span>。</p> 
     <table> 
      <tbody> 
       <tr> 
        <td> <pre><span style="color:#009900">//: c12:Resetting.java</span>
<span style="color:#0000ff">import</span> java.util.regex.*;
<span style="color:#0000ff">import</span> java.io.*;
<span style="color:#0000ff">import</span> com.bruceeckel.simpletest.*;
<span style="color:#0000ff">public</span><span style="color:#0000ff">class</span> Resetting {
<span style="color:#0000ff">private</span><span style="color:#0000ff">static</span> Test monitor = <span style="color:#0000ff">new</span> Test();
<span style="color:#0000ff">public</span><span style="color:#0000ff">static</span><span style="color:#0000ff">void</span> main(String[] args) <span style="color:#0000ff">throws</span> Exception {
    Matcher m = Pattern.compile(<span style="color:#004488">"[frb][aiu][gx]"</span>)
      .matcher(<span style="color:#004488">"fix the rug with bags"</span>);
<span style="color:#0000ff">while</span>(m.find())
      System.out.println(m.group());
    m.reset(<span style="color:#004488">"fix the rig with rags"</span>);
<span style="color:#0000ff">while</span>(m.find())
      System.out.println(m.group());
    monitor.expect(<span style="color:#0000ff">new</span> String[]{
<span style="color:#004488">"fix"</span>,
<span style="color:#004488">"rug"</span>,
<span style="color:#004488">"bag"</span>,
<span style="color:#004488">"fix"</span>,
<span style="color:#004488">"rig"</span>,
<span style="color:#004488">"rag"</span>
    });
  }
} <span style="color:#009900">///:~</span></pre> </td> 
       </tr> 
      </tbody> 
     </table> 
     <p>如果不给参数，<span>reset( )</span>会把<span>Matcher</span>设到当前字符串的开始处。</p> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <tbody> 
  <tr> 
   <td>许多语言，包括Perl、PHP、<a href="http://www.yesky.com/key/856/595856.html" rel="nofollow"><span style="color:#5f659d">Python</span></a>、<a href="http://www.yesky.com/key/1841/581841.html" rel="nofollow"><span style="color:#5f659d">JavaScript</span></a>和<a href="http://www.yesky.com/key/3366/593366.html" rel="nofollow"><span style="color:#5f659d">JScript</span></a>，都支持用正则表达式处理文本，一些文本编辑器用正则表达式实现高级“搜索-替换”功能。那么Java又怎样呢？本文写作时，一个包含了用正则表达式进行文本处理的Java规范需求（Specification Request）已经得到认可，你可以期待在JDK的下一版本中看到它。</td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <tbody> 
  <tr> 
   <td><strong><span style="font-size:18px">一、正则表达式基础知识</span></strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>我们先从简单的开始。假设你要搜索一个包含字符“cat”的字符串，搜索用的正则表达式就是“cat”。如果搜索对大小写不敏感，单词“<a href="http://www.yesky.com/key/4169/594169.html" rel="nofollow"><span style="color:#5f659d">catalog</span></a>”、“Catherine”、“sophisticated”都可以匹配。也就是说：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>假设你在玩英文拼字游戏，想要找出三个字母的单词，而且这些单词必须以“t”字母开头，以“n”字母结束。另外，假设有一本英文字典，你可以用正则表达式搜索它的全部内容。要构造出这个正则表达式，你可以使用一个通配符——句点符号“.”。这样，完整的表达式就是“t.n”，它匹配“tan”、“ten”、“tin”和“ton”，还匹配“t#n”、“tpn”甚至“t n”，还有其他许多无意义的组合。这是因为句点符号匹配所有字符，包括空格、Tab字符甚至换行符：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>1.2 方括号符号</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（“[]”）里面指定看来有意义的字符。此时，只有方括号里面指定的字符才参与匹配。也就是说，正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”。但“Toon”不匹配，因为在方括号之内你只能匹配单个字符：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>如果除了上面匹配的所有单词之外，你还想要匹配“toon”，那么，你可以使用“|”操作符。“|”操作符的基本意义就是“或”运算。要匹配“toon”，使用“t(a|e|i|o|oo)n”正则表达式。这里不能使用方扩号，因为方括号只允许匹配单个字符；这里必须使用圆括号“()”。圆括号还可以用来分组，具体请参见后面介绍。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>1.4 表示匹配次数的符号</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>表一显示了表示匹配次数的符号，这些符号用来确定紧靠该符号左边的符号出现的次数：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>假设我们要在文本文件中搜索美国的社会安全号码。这个号码的格式是999-99-9999。用来匹配它的正则表达式如图一所示。在正则表达式中，连字符（“-”）有着特殊的意义，它表示一个范围，比如从0到9。因此，匹配社会安全号码中的连字符号时，它的前面要加上一个转义字符“/”。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图一：匹配所有123-12-1234形式的社会安全号码</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>假设进行搜索的时候，你希望连字符号可以出现，也可以不出现——即，999-99-9999和999999999都属于正确的格式。这时，你可以在连字符号后面加上“？”数量限定符号，如图二所示：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图二：匹配所有123-12-1234和123121234形式的社会安全号码</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>下面我们再来看另外一个例子。美国汽车牌照的一种格式是四个数字加上二个字母。它的正则表达式前面是数字部分“[0-9]{4}”，再加上字母部分“[A-Z]{2}”。图三显示了完整的正则表达式。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图三：匹配典型的美国汽车牌照号码，如8836KV</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>“^”符号称为“否”符号。如果用在方括号内，“^”表示不想要匹配的字符。例如，图四的正则表达式匹配所有单词，但以“X”字母开头的单词除外。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图四：匹配所有单词，但“X”开头的除外</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>1.6 圆括号和空白符号</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>假设要从格式为“June 26, 1951”的生日日期中提取出月份部分，用来匹配该日期的正则表达式可以如图五所示：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图五：匹配所有Moth DD,YYYY格式的日期</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>新出现的“/s”符号是空白符号，匹配所有的空白字符，包括Tab字符。如果字符串正确匹配，接下来如何提取出月份部分呢？只需在月份周围加上一个圆括号创建一个组，然后用ORO API（本文后面详细讨论）提取出它的值。修改后的正则表达式如图六所示：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图六：匹配所有Month DD,YYYY格式的日期，定义月份值为第一个组</p> </td> 
  </tr> 
 </tbody> 
</table>

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

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

<table> 
 <tbody> 
  <tr> 
   <td> <p>图七：匹配所有123-12-1234格式的社会安全号码</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong><span style="font-size:18px">二、Jakarta-ORO库</span></strong></td> 
  </tr> 
 </tbody> 
</table>

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

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

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

<table> 
 <tbody> 
  <tr> 
   <td><strong>▲ PatternCompiler对象</strong></td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <tbody> 
  <tr> 
   <td><strong>▲ Pattern对象</strong></td> 
  </tr> 
 </tbody> 
</table>

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

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

<table> 
 <tbody> 
  <tr> 
   <td>创建好Pattern对象之后，你就可以通过PatternMatcher类用该Pattern对象进行模式匹配。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>▲ PatternMatcher对象</strong></td> 
  </tr> 
 </tbody> 
</table>

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

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

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

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

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

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

<table> 
 <tbody> 
  <tr> 
   <td>· boolean matches(PatternMatcherInput input, Pattern pattern)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>· boolean matchesPrefix(PatternMatcherInput input, Pattern pattern)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>· boolean contains(PatternMatcherInput input, Pattern pattern)</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>下面我们来看看Jakarta-ORO库的一些应用实例。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>3.1 日志文件处理</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>任务：分析一个Web服务器日志文件，确定每一个用户花在网站上的时间。在典型的BEA WebLogic日志文件中，日志记录的格式如下：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>分析这个日志记录，可以发现，要从这个日志文件提取的内容有两项：IP地址和页面访问时间。你可以用分组符号（圆括号）从日志记录提取出IP地址和时间标记。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>首先我们来看看IP地址。IP地址有4个字节构成，每一个字节的值在0到255之间，各个字节通过一个句点分隔。因此，IP地址中的每一个字节有至少一个、最多三个数字。图八显示了为IP地址编写的正则表达式：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图八：匹配IP地址</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>IP地址中的句点字符必须进行转义处理（前面加上“/”），因为IP地址中的句点具有它本来的含义，而不是采用正则表达式语法中的特殊含义。句点在正则表达式中的特殊含义本文前面已经介绍。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>日志记录的时间部分由一对方括号包围。你可以按照如下思路提取出方括号里面的所有内容：首先搜索起始方括号字符（“[”），提取出所有不超过结束方括号字符（“]”）的内容，向前寻找直至找到结束方括号字符。图九显示了这部分的正则表达式。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图九：匹配至少一个字符，直至找到“]”</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>现在，把上述两个正则表达式加上分组符号（圆括号）后合并成单个表达式，这样就可以从日志记录提取出IP地址和时间。注意，为了匹配“- -”（但不提取它），正则表达式中间加入了“/s-/s-/s”。完整的正则表达式如图十所示。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图十：匹配IP地址和时间标记</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>现在正则表达式已经编写完毕，接下来可以编写使用正则表达式库的Java代码了。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>为使用Jakarta-ORO库，首先创建正则表达式字符串和待分析的日志记录字符串：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>这里使用的正则表达式与图十的正则表达式差不多完全相同，但有一点例外：在Java中，你必须对每一个向前的斜杠（“/”）进行转义处理。图十不是Java的表示形式，所以我们要在每个“/”前面加上一个“/”以免出现编译错误。遗憾的是，转义处理过程很容易出现错误，所以应该小心谨慎。你可以首先输入未经转义处理的正则表达式，然后从左到右依次把每一个“/”替换成“//”。如果要复检，你可以试着把它输出到屏幕上。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>初始化字符串之后，实例化PatternCompiler对象，用PatternCompiler编译正则表达式创建一个Pattern对象：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>现在，创建PatternMatcher对象，调用PatternMatcher接口的contain()方法检查匹配情况：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>接下来，利用PatternMatcher接口返回的MatchResult对象，输出匹配的组。由于logEntry字符串包含匹配的内容，你可以看到类如下面的输出：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>3.2 HTML处理实例一</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>下面一个任务是分析HTML页面内FONT标记的所有属性。HTML页面内典型的FONT标记如下所示：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>程序将按照如下形式，输出每一个FONT标记的属性：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>在这种情况下，我建议你使用两个正则表达式。第一个如图十一所示，它从字体标记提取出“"face="Arial, Serif" size="+2" color="red"”。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图十一：匹配FONT标记的所有属性</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>第二个正则表达式如图十二所示，它把各个属性分割成名字-值对。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图十二：匹配单个属性，并把它分割成名字-值对</p> </td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>分割结果为：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>现在我们来看看完成这个任务的Java代码。首先创建两个正则表达式字符串，用Perl5Compiler把它们编译成Pattern对象。编译正则表达式的时候，指定Perl5Compiler.CASE_INSENSITIVE_MASK选项，使得匹配操作不区分大小写。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>接下来，创建一个执行匹配操作的Perl5Matcher对象。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>假设有一个String类型的变量html，它代表了HTML文件中的一行内容。如果html字符串包含FONT标记，匹配器将返回true。此时，你可以用匹配器对象返回的MatchResult对象获得第一个组，它包含了FONT的所有属性：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>接下来创建一个PatternMatcherInput对象。这个对象允许你从最后一次匹配的位置开始继续进行匹配操作，因此，它很适合于提取FONT标记内属性的名字-值对。创建PatternMatcherInput对象，以参数形式传入待匹配的字符串。然后，用匹配器实例提取出每一个FONT的属性。这通过指定PatternMatcherInput对象（而不是字符串对象）为参数，反复地调用PatternMatcher对象的contains()方法完成。PatternMatcherInput对象之中的每一次迭代将把它内部的指针向前移动，下一次检测将从前一次匹配位置的后面开始。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>本例的输出结果如下：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><strong>3.3 HTML处理实例二</strong></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>下面我们来看看另一个处理HTML的例子。这一次，我们假定Web服务器从widgets.acme.com移到了newserver.acme.com。现在你要修改一些页面中的链接：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>执行这个搜索的正则表达式如图十三所示：</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td> <p>图十三：匹配修改前的链接</p> </td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <tbody> 
  <tr> 
   <td>注意#字符的后面加上了<a href="http://www.yesky.com/key/1081/571081.html" rel="nofollow"><span style="color:#5f659d">$1</span></a>。Perl正则表达式语法用$1、$2等表示已经匹配且提取出来的组。图十三的表达式把所有作为一个组匹配和提取出来的内容附加到链接的后面。</td> 
  </tr> 
 </tbody> 
</table>

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

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

<table> 
 <tbody> 
  <tr> 
   <td>Util.substitute()方法的语法如下：</td> 
  </tr> 
 </tbody> 
</table>

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

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