欧美性猛交XXXX免费看蜜桃,成人网18免费韩国,亚洲国产成人精品区综合,欧美日韩一区二区三区高清不卡,亚洲综合一区二区精品久久

正則表達式

作為本章的結尾，我們來(lái)看一看正則表達式(regular expression)。正則表達式是JDK 1.4的新功能，但是對sed和awk這樣的Unix的標準實(shí)用工具，以及Python，Perl之類(lèi)的語(yǔ)言來(lái)講，它早就已經(jīng)成為其不可或缺的組成部分了(有人甚至認為，它還是Perl能大獲成功的最主要的原因)。單從技術(shù)角度來(lái)講，正則表達式只是一種處理字符串的工具(過(guò)去Java這個(gè)任務(wù)是交由String，StringBuffer以及StringTokenizer處理的)，但是它常常和I/O一起使用，所以放到這里來(lái)講也不算太離題吧。^[66]

正則表達式是一種功能強大但又非常靈活的文本處理工具。它能讓你用編程的方式來(lái)描述復雜的文本模式，然后在字符串里把它找出來(lái)。一旦你找到了這種模式，你就能隨心所欲地處理這些文本了。雖然初看起來(lái)正則表達式的語(yǔ)法有點(diǎn)讓人望而生畏，但它提供了一種精練的動(dòng)態(tài)語(yǔ)言，使我們能用一種通用的方式來(lái)解決各種字符串的問(wèn)題，包括匹配，選擇，編輯以及校驗。

創(chuàng )建正則表達式

你可以從比較簡(jiǎn)單的東西入手學(xué)習正則表達式。要想全面地掌握怎樣構建正則表達式，可以去看JDK文檔的java.util.regex的Pattern類(lèi)的文檔。

正則表達式的強大體現在它能定義字符集(character class)。下面是一些最常見(jiàn)的字符集及其定義的方式，此外還有一些預定義的字符集：

如果你用過(guò)其它語(yǔ)言的正則表達式，那么你一眼就能看出反斜杠的與眾不同。在其它語(yǔ)言里，"\\"的意思是"我只是要在正則表達式里插入一個(gè)反斜杠。沒(méi)什么特別的意思。"但是在Java里，"\\"的意思是"我要插入一個(gè)正則表達式的反斜杠，所以跟在它后面的那個(gè)字符的意思就變了。"舉例來(lái)說(shuō)，如果你想表示一個(gè)或更多的"單詞字符"，那么這個(gè)正則表達式就應該是"\\w+"。如果你要插入一個(gè)反斜杠，那就得用"\\\\"。不過(guò)像換行，跳格之類(lèi)的還是只用一根反斜杠："\n\t"。

這里只給你講一個(gè)例子；你應該JDK文檔的java.util.regex.Pattern加到收藏夾里，這樣就能很容易地找到各種正則表達式的模式了。

舉一個(gè)具體一些的例子。下面這些正則表達式都是合法的，而且都能匹配"Rudolph"：

Rudolph[rR]udolph[rR][aeiou][a-z]ol.*R.*

數量表示符

"數量表示符(quantifier)"的作用是定義模式應該匹配多少個(gè)字符。

• Greedy(貪婪的)： 除非另有表示，否則數量表示符都是greedy的。Greedy的表達式會(huì )一直匹配下去，直到匹配不下去為止。(如果你發(fā)現表達式匹配的結果與預期的不符)，很有可能是因為，你以為表達式會(huì )只匹配前面幾個(gè)字符，而實(shí)際上它是greedy的，因此會(huì )一直匹配下去。
• Reluctant(勉強的)： 用問(wèn)號表示，它會(huì )匹配最少的字符。也稱(chēng)為lazy, minimal matching, non-greedy, 或ungreedy。
• Possessive(占有的)： 目前只有Java支持(其它語(yǔ)言都不支持)。它更加先進(jìn)，所以你可能還不太會(huì )用。用正則表達式匹配字符串的時(shí)候會(huì )產(chǎn)生很多中間狀態(tài)，(一般的匹配引擎會(huì )保存這種中間狀態(tài)，)這樣匹配失敗的時(shí)候就能原路返回了。占有型的表達式不保存這種中間狀態(tài)，因此也就不會(huì )回頭重來(lái)了。它能防止正則表達式的失控，同時(shí)也能提高運行的效率。

再提醒一下，要想讓表達式照你的意思去運行，你應該用括號把‘X‘括起來(lái)。比方說(shuō)：

abc+

似乎這個(gè)表達式能匹配一個(gè)或若干個(gè)‘a(chǎn)bc‘，但是如果你真的用它去匹配‘a(chǎn)bcabcabc‘的話(huà)，實(shí)際上只會(huì )找到三個(gè)字符。因為這個(gè)表達式的意思是‘a(chǎn)b‘后邊跟著(zhù)一個(gè)或多個(gè)‘c‘。要想匹配一個(gè)或多個(gè)完整的‘a(chǎn)bc‘，你應該這樣：

(abc)+

正則表達式能輕而易舉地把你給耍了；這是一種建立在Java之上的新語(yǔ)言。

CharSequence

JDK 1.4定義了一個(gè)新的接口，叫CharSequence。它提供了String和StringBuffer這兩個(gè)類(lèi)的字符序列的抽象：

interface CharSequence {  charAt(int i);  length();  subSequence(int start, int end);  toString();}

為了實(shí)現這個(gè)新的CharSequence接口，String，StringBuffer以及CharBuffer都作了修改。很多正則表達式的操作都要拿CharSequence作參數。

Pattern和Matcher

先給一個(gè)例子。下面這段程序可以測試正則表達式是否匹配字符串。第一個(gè)參數是要匹配的字符串，后面是正則表達式。正則表達式可以有多個(gè)。在Unix/Linux環(huán)境下，命令行下的正則表達式還必須用引號。

當你創(chuàng )建正則表達式時(shí)，可以用這個(gè)程序來(lái)判斷它是不是會(huì )按照你的要求工作。

//: c12:TestRegularExpression.java// Allows you to easly try out regular expressions.// {Args: abcabcabcdefabc "abc+" "(abc)+" "(abc){2,}" }import java.util.regex.*;public class TestRegularExpression {  public static void main(String[] args) {    if(args.length < 2) {      System.out.println("Usage:\n" +        "java TestRegularExpression " +        "characterSequence regularExpression+");      System.exit(0);    }    System.out.println("Input: \"" + args[0] + "\"");    for(int i = 1; i < args.length; i++) {      System.out.println(        "Regular expression: \"" + args[i] + "\"");      Pattern p = Pattern.compile(args[i]);      Matcher m = p.matcher(args[0]);      while(m.find()) {        System.out.println("Match \"" + m.group() +          "\" at positions " +          m.start() + "-" + (m.end() - 1));      }    }  }} ///:~

Java的正則表達式是由java.util.regex的Pattern和Matcher類(lèi)實(shí)現的。Pattern對象表示經(jīng)編譯的正則表達式。靜態(tài)的compile( )方法負責將表示正則表達式的字符串編譯成Pattern對象。正如上述例程所示的，只要給Pattern的matcher( )方法送一個(gè)字符串就能獲取一個(gè)Matcher對象。此外，Pattern還有一個(gè)能快速判斷能否在input里面找到regex的(注意，原文有誤，漏了方法名)

static boolean matches( regex,  input)

以及能返回String數組的split( )方法，它能用regex把字符串分割開(kāi)來(lái)。

只要給Pattern.matcher( )方法傳一個(gè)字符串就能獲得Matcher對象了。接下來(lái)就能用Matcher的方法來(lái)查詢(xún)匹配的結果了。

boolean matches()boolean lookingAt()boolean find()boolean find(int start)

matches( )的前提是Pattern匹配整個(gè)字符串，而lookingAt( )的意思是Pattern匹配字符串的開(kāi)頭。

find( )

Matcher.find( )的功能是發(fā)現CharSequence里的，與pattern相匹配的多個(gè)字符序列。例如：

//: c12:FindDemo.javaimport java.util.regex.*;import com.bruceeckel.simpletest.*;import java.util.*;public class FindDemo {  private static Test monitor = new Test();  public static void main(String[] args) {    Matcher m = Pattern.compile("\\w+")      .matcher("Evening is full of the linnet‘s wings");    while(m.find())      System.out.println(m.group());    int i = 0;    while(m.find(i)) {      System.out.print(m.group() + " ");      i++;    }    monitor.expect(new String[] {      "Evening",      "is",      "full",      "of",      "the",      "linnet",      "s",      "wings",      "Evening vening ening ning ing ng g is is s full " +      "full ull ll l of of f the the he e linnet linnet " +      "innet nnet net et t s s wings wings ings ngs gs s "    });  }} ///:~

"\\w+"的意思是"一個(gè)或多個(gè)單詞字符"，因此它會(huì )將字符串直接分解成單詞。find( )像一個(gè)迭代器，從頭到尾掃描一遍字符串。第二個(gè)find( )是帶int參數的，正如你所看到的，它會(huì )告訴方法從哪里開(kāi)始找——即從參數位置開(kāi)始查找。

Groups

Group是指里用括號括起來(lái)的，能被后面的表達式調用的正則表達式。Group 0 表示整個(gè)表達式，group 1表示第一個(gè)被括起來(lái)的group，以此類(lèi)推。所以；

A(B(C))D

里面有三個(gè)group：group 0是ABCD， group 1是BC，group 2是C。

你可以用下述Matcher方法來(lái)使用group：

public int groupCount( )返回matcher對象中的group的數目。不包括group0。

public String group( ) 返回上次匹配操作(比方說(shuō)find( ))的group 0(整個(gè)匹配)

public String group(int i)返回上次匹配操作的某個(gè)group。如果匹配成功，但是沒(méi)能找到group，則返回null。

public int start(int group)返回上次匹配所找到的，group的開(kāi)始位置。

public int end(int group)返回上次匹配所找到的，group的結束位置，最后一個(gè)字符的下標加一。

下面我們舉一些group的例子：

//: c12:Groups.javaimport java.util.regex.*;import com.bruceeckel.simpletest.*;public class Groups {  private static Test monitor = new Test();  static public final String poem =    "Twas brillig, and the slithy toves\n" +    "Did gyre and gimble in the wabe.\n" +    "All mimsy were the borogoves,\n" +    "And the mome raths outgrabe.\n\n" +    "Beware the Jabberwock, my son,\n" +    "The jaws that bite, the claws that catch.\n" +    "Beware the Jubjub bird, and shun\n" +    "The frumious Bandersnatch.";  public static void main(String[] args) {    Matcher m =      Pattern.compile("(?m)(\\S+)\\s+((\\S+)\\s+(\\S+))$")        .matcher(poem);    while(m.find()) {      for(int j = 0; j <= m.groupCount(); j++)        System.out.print("[" + m.group(j) + "]");      System.out.println();    }    monitor.expect(new String[]{      "[the slithy toves]" +      "[the][slithy toves][slithy][toves]",      "[in the wabe.][in][the wabe.][the][wabe.]",      "[were the borogoves,]" +      "[were][the borogoves,][the][borogoves,]",      "[mome raths outgrabe.]" +      "[mome][raths outgrabe.][raths][outgrabe.]",      "[Jabberwock, my son,]" +      "[Jabberwock,][my son,][my][son,]",      "[claws that catch.]" +      "[claws][that catch.][that][catch.]",      "[bird, and shun][bird,][and shun][and][shun]",      "[The frumious Bandersnatch.][The]" +      "[frumious Bandersnatch.][frumious][Bandersnatch.]"    });  }} ///:~

這首詩(shī)是Through the Looking Glass的，Lewis Carroll的"Jabberwocky"的第一部分?？梢钥吹竭@個(gè)正則表達式里有很多用括號括起來(lái)的group，它是由任意多個(gè)連續的非空字符(‘\S+‘)和任意多個(gè)連續的空格字符(‘\s+‘)所組成的，其最終目的是要捕獲每行的最后三個(gè)單詞；‘$‘表示一行的結尾。但是‘$‘通常表示整個(gè)字符串的結尾，所以這里要明確地告訴正則表達式注意換行符。這一點(diǎn)是由‘(?m)‘標志完成的(模式標志會(huì )過(guò)一會(huì )講解)。

start( )和end( )

如果匹配成功，start( )會(huì )返回此次匹配的開(kāi)始位置，end( )會(huì )返回此次匹配的結束位置，即最后一個(gè)字符的下標加一。如果之前的匹配不成功(或者沒(méi)匹配)，那么無(wú)論是調用start( )還是end( )，都會(huì )引發(fā)一個(gè)IllegalStateException。下面這段程序還演示了matches( )和lookingAt( )：

//: c12:StartEnd.javaimport java.util.regex.*;import com.bruceeckel.simpletest.*;public class StartEnd {  private static Test monitor = new Test();  public static void main(String[] args) {    String[] input = new String[] {      "Java has regular expressions in 1.4",      "regular expressions now expressing in Java",      "Java represses oracular expressions"    };    Pattern      p1 = Pattern.compile("re\\w*"),      p2 = Pattern.compile("Java.*");    for(int i = 0; i < input.length; i++) {      System.out.println("input " + i + ": " + input[i]);      Matcher        m1 = p1.matcher(input[i]),        m2 = p2.matcher(input[i]);      while(m1.find())        System.out.println("m1.find() ‘" + m1.group() +          "‘ start = "+ m1.start() + " end = " + m1.end());      while(m2.find())        System.out.println("m2.find() ‘" + m2.group() +          "‘ start = "+ m2.start() + " end = " + m2.end());      if(m1.lookingAt()) // No reset() necessary        System.out.println("m1.lookingAt() start = "          + m1.start() + " end = " + m1.end());      if(m2.lookingAt())        System.out.println("m2.lookingAt() start = "          + m2.start() + " end = " + m2.end());      if(m1.matches()) // No reset() necessary        System.out.println("m1.matches() start = "          + m1.start() + " end = " + m1.end());      if(m2.matches())        System.out.println("m2.matches() start = "          + m2.start() + " end = " + m2.end());    }    monitor.expect(new String[] {      "input 0: Java has regular expressions in 1.4",      "m1.find() ‘regular‘ start = 9 end = 16",      "m1.find() ‘ressions‘ start = 20 end = 28",      "m2.find() ‘Java has regular expressions in 1.4‘" +      " start = 0 end = 35",      "m2.lookingAt() start = 0 end = 35",      "m2.matches() start = 0 end = 35",      "input 1: regular expressions now " +      "expressing in Java",      "m1.find() ‘regular‘ start = 0 end = 7",      "m1.find() ‘ressions‘ start = 11 end = 19",      "m1.find() ‘ressing‘ start = 27 end = 34",      "m2.find() ‘Java‘ start = 38 end = 42",      "m1.lookingAt() start = 0 end = 7",      "input 2: Java represses oracular expressions",      "m1.find() ‘represses‘ start = 5 end = 14",      "m1.find() ‘ressions‘ start = 27 end = 35",      "m2.find() ‘Java represses oracular expressions‘ " +      "start = 0 end = 35",      "m2.lookingAt() start = 0 end = 35",      "m2.matches() start = 0 end = 35"    });  }} ///:~

注意，只要字符串里有這個(gè)模式，find( )就能把它給找出來(lái)，但是lookingAt( )和matches( )，只有在字符串與正則表達式一開(kāi)始就相匹配的情況下才能返回true。matches( )成功的前提是正則表達式與字符串完全匹配，而lookingAt( )^[67]成功的前提是，字符串的開(kāi)始部分與正則表達式相匹配。

匹配的模式(Pattern flags)

compile( )方法還有一個(gè)版本，它需要一個(gè)控制正則表達式的匹配行為的參數：

Pattern Pattern.compile(String regex, int flag)

在這些標志里面，Pattern.CASE_INSENSITIVE，Pattern.MULTILINE，以及Pattern.COMMENTS是最有用的(其中Pattern.COMMENTS還能幫我們把思路理清楚，并且/或者做文檔)。注意，你可以用在表達式里插記號的方式來(lái)啟用絕大多數的模式。這些記號就在上面那張表的各個(gè)標志的下面。你希望模式從哪里開(kāi)始啟動(dòng)，就在哪里插記號。

可以用"OR" (‘|‘)運算符把這些標志合使用：

//: c12:ReFlags.javaimport java.util.regex.*;import com.bruceeckel.simpletest.*;public class ReFlags {  private static Test monitor = new Test();  public static void main(String[] args) {    Pattern p =  Pattern.compile("^java",      Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);    Matcher m = p.matcher(      "java has regex\nJava has regex\n" +      "JAVA has pretty good regular expressions\n" +      "Regular expressions are in Java");    while(m.find())      System.out.println(m.group());    monitor.expect(new String[] {      "java",      "Java",      "JAVA"    });  }} ///:~

這樣創(chuàng )建出來(lái)的正則表達式就能匹配以"java"，"Java"，"JAVA"...開(kāi)頭的字符串了。此外，如果字符串分好幾行，那它還會(huì )對每一行做匹配(匹配始于字符序列的開(kāi)始，終于字符序列當中的行結束符)。注意，group( )方法僅返回匹配的部分。

split( )

所謂分割是指將以正則表達式為界，將字符串分割成String數組。

String[] split(CharSequence charseq)String[] split(CharSequence charseq, int limit)

這是一種既快又方便地將文本根據一些常見(jiàn)的邊界標志分割開(kāi)來(lái)的方法。

//: c12:SplitDemo.javaimport java.util.regex.*;import com.bruceeckel.simpletest.*;import java.util.*;public class SplitDemo {  private static Test monitor = new Test();  public static void main(String[] args) {    String input =      "This!!unusual use!!of exclamation!!points";    System.out.println(Arrays.asList(      Pattern.compile("!!").split(input)));    // Only do the first three:    System.out.println(Arrays.asList(      Pattern.compile("!!").split(input, 3)));    System.out.println(Arrays.asList(      "Aha! String has a split() built in!".split(" ")));    monitor.expect(new String[] {      "[This, unusual use, of exclamation, points]",      "[This, unusual use, of exclamation!!points]",      "[Aha!, String, has, a, split(), built, in!]"    });  }} ///:~

第二個(gè)split( )會(huì )限定分割的次數。

正則表達式是如此重要，以至于有些功能被加進(jìn)了String類(lèi)，其中包括split( )(已經(jīng)看到了)，matches( )，replaceFirst( )以及replaceAll( )。這些方法的功能同Pattern和Matcher的相同。

替換操作

正則表達式在替換文本方面特別在行。下面就是一些方法：

replaceFirst(String replacement)將字符串里，第一個(gè)與模式相匹配的子串替換成replacement。

replaceAll(String replacement)，將輸入字符串里所有與模式相匹配的子串全部替換成replacement。

appendReplacement(StringBuffer sbuf, String replacement)對sbuf進(jìn)行逐次替換，而不是像replaceFirst( )或replaceAll( )那樣，只替換第一個(gè)或全部子串。這是個(gè)非常重要的方法，因為它可以調用方法來(lái)生成replacement(replaceFirst( )和replaceAll( )只允許用固定的字符串來(lái)充當replacement)。有了這個(gè)方法，你就可以編程區分group，從而實(shí)現更強大的替換功能。

調用完appendReplacement( )之后，為了把剩余的字符串拷貝回去，必須調用appendTail(StringBuffer sbuf, String replacement)。

下面我們來(lái)演示一下怎樣使用這些替換方法。說(shuō)明一下，這段程序所處理的字符串是它自己開(kāi)頭部分的注釋?zhuān)怯谜齽t表達式提取出來(lái)并加以處理之后再傳給替換方法的。

//: c12:TheReplacements.javaimport java.util.regex.*;import java.io.*;import com.bruceeckel.util.*;import com.bruceeckel.simpletest.*;/*! 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. !*/public class TheReplacements {  private static Test monitor = new Test();  public static void main(String[] args) throws Exception {    String s = TextFile.read("TheReplacements.java");    // Match the specially-commented block of text above:    Matcher mInput =      Pattern.compile("/\\*!(.*)!\\*/", Pattern.DOTALL)        .matcher(s);    if(mInput.find())      s = mInput.group(1); // Captured by parentheses    // Replace two or more spaces with a single space:    s = s.replaceAll(" {2,}", " ");    // Replace one or more spaces at the beginning of each    // line with no spaces. Must enable MULTILINE mode:    s = s.replaceAll("(?m)^ +", "");    System.out.println(s);    s = s.replaceFirst("[aeiou]", "(VOWEL1)");    StringBuffer sbuf = new StringBuffer();    Pattern p = Pattern.compile("[aeiou]");    Matcher m = p.matcher(s);    // Process the find information as you    // perform the replacements:    while(m.find())      m.appendReplacement(sbuf, m.group().toUpperCase());    // Put in the remainder of the text:    m.appendTail(sbuf);    System.out.println(sbuf);    monitor.expect(new String[]{      "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. ",      "H(VOWEL1)rE‘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. "    });  }} ///:~

我們用前面介紹的TextFile.read( )方法來(lái)打開(kāi)和讀取文件。mInput的功能是匹配‘/*!‘ 和 ‘!*/‘ 之間的文本(注意一下分組用的括號)。接下來(lái)，我們將所有兩個(gè)以上的連續空格全都替換成一個(gè)，并且將各行開(kāi)頭的空格全都去掉(為了讓這個(gè)正則表達式能對所有的行，而不僅僅是第一行起作用，必須啟用多行模式)。這兩個(gè)操作都用了String的replaceAll( )(這里用它更方便)。注意，由于每個(gè)替換只做一次，因此除了預編譯Pattern之外，程序沒(méi)有額外的開(kāi)銷(xiāo)。

replaceFirst( )只替換第一個(gè)子串。此外，replaceFirst( )和replaceAll( )只能用常量(literal)來(lái)替換，所以如果你每次替換的時(shí)候還要進(jìn)行一些操作的話(huà)，它們是無(wú)能為力的。碰到這種情況，你得用appendReplacement( )，它能讓你在進(jìn)行替換的時(shí)候想寫(xiě)多少代碼就寫(xiě)多少。在上面那段程序里，創(chuàng )建sbuf的過(guò)程就是選group做處理，也就是用正則表達式把元音字母找出來(lái)，然后換成大寫(xiě)的過(guò)程。通常你得在完成全部的替換之后才調用appendTail( )，但是如果要模仿replaceFirst( )(或"replace n")的效果，你也可以只替換一次就調用appendTail( )。它會(huì )把剩下的東西全都放進(jìn)sbuf。

你還可以在appendReplacement( )的replacement參數里用"$g"引用已捕獲的group，其中‘g‘ 表示group的號碼。不過(guò)這是為一些比較簡(jiǎn)單的操作準備的，因而其效果無(wú)法與上述程序相比。

reset( )

此外，還可以用reset( )方法給現有的Matcher對象配上個(gè)新的CharSequence。

//: c12:Resetting.javaimport java.util.regex.*;import java.io.*;import com.bruceeckel.simpletest.*;public class Resetting {  private static Test monitor = new Test();  public static void main(String[] args) throws Exception {    Matcher m = Pattern.compile("[frb][aiu][gx]")      .matcher("fix the rug with bags");    while(m.find())      System.out.println(m.group());    m.reset("fix the rig with rags");    while(m.find())      System.out.println(m.group());    monitor.expect(new String[]{      "fix",      "rug",      "bag",      "fix",      "rig",      "rag"    });  }} ///:~

如果不給參數，reset( )會(huì )把Matcher設到當前字符串的開(kāi)始處。

正則表達式與Java I/O

到目前為止，你看到的都是用正則表達式處理靜態(tài)字符串的例子。下面我們來(lái)演示一下怎樣用正則表達式掃描文件并且找出匹配的字符串。受Unix的grep啟發(fā)，我寫(xiě)了個(gè)JGrep.java，它需要兩個(gè)參數：文件名，以及匹配字符串用的正則表達式。它會(huì )把匹配這個(gè)正則表達式那部分內容及其所屬行的行號打印出來(lái)。

//: c12:JGrep.java// A very simple version of the "grep" program.// {Args: JGrep.java "\\b[Ssct]\\w+"}import java.io.*;import java.util.regex.*;import java.util.*;import com.bruceeckel.util.*;public class JGrep {  public static void main(String[] args) throws Exception {    if(args.length < 2) {      System.out.println("Usage: java JGrep file regex");      System.exit(0);    }    Pattern p = Pattern.compile(args[1]);    // Iterate through the lines of the input file:    ListIterator it = new TextFile(args[0]).listIterator();    while(it.hasNext()) {      Matcher m = p.matcher((String)it.next());      while(m.find())        System.out.println(it.nextIndex() + ": " +          m.group() + ": " + m.start());    }  }} ///:~

文件是用TextFile打開(kāi)的(本章的前半部分講的)。由于TextFile會(huì )把文件的各行放在ArrayList里面，而我們又提取了一個(gè)ListIterator，因此我們可以在文件的各行當中自由移動(dòng)(既能向前也可以向后)。

每行都會(huì )有一個(gè)Matcher，然后用find( )掃描。注意，我們用ListIterator.nextIndex( )跟蹤行號。

測試參數是JGrep.java和以[Ssct]開(kāi)頭的單詞。

還需要StringTokenizer嗎?

看到正則表達式能提供這么強大的功能，你可能會(huì )懷疑，是不是還需要原先的StringTokenizer。JDK 1.4以前，要想分割字符串，只有用StringTokenizer。但現在，有了正則表達式之后，它就能做得更干凈利索了。

//: c12:ReplacingStringTokenizer.javaimport java.util.regex.*;import com.bruceeckel.simpletest.*;import java.util.*;public class ReplacingStringTokenizer {  private static Test monitor = new Test();  public static void main(String[] args) {    String input = "But I‘m not dead yet! I feel happy!";    StringTokenizer stoke = new StringTokenizer(input);    while(stoke.hasMoreElements())      System.out.println(stoke.nextToken());    System.out.println(Arrays.asList(input.split(" ")));    monitor.expect(new String[] {      "But",      "I‘m",      "not",      "dead",      "yet!",      "I",      "feel",      "happy!",      "[But, I‘m, not, dead, yet!, I, feel, happy!]"    });  }} ///:~

有了正則表達式，你就能用更復雜的模式將字符串分割開(kāi)來(lái)——要是交給StringTokenizer的話(huà)，事情會(huì )麻煩得多。我可以很有把握地說(shuō)，正則表達式可以取代StringTokenizer。

要想進(jìn)一步學(xué)習正則表達式，建議你看Mastering Regular Expression, 2nd Edition，作者Jeffrey E. F. Friedl (O’Reilly, 2002)。

總結

Java的I/O流類(lèi)庫應該能滿(mǎn)足你的基本需求：你可以用它來(lái)讀寫(xiě)控制臺，文件，內存，甚至是Internet。你還可以利用繼承來(lái)創(chuàng )建新的輸入和輸出類(lèi)型。你甚至可以利用Java會(huì )自動(dòng)調用對象的toString( )方法的特點(diǎn)(Java僅有的"自動(dòng)類(lèi)型轉換")，通過(guò)重新定義這個(gè)方法，來(lái)對要傳給流的對象做一個(gè)簡(jiǎn)單的擴展。

但是Java的I/O流類(lèi)庫及其文檔還是留下了一些缺憾。比方說(shuō)你打開(kāi)一個(gè)文件往里面寫(xiě)東西，但是這個(gè)文件已經(jīng)有了，這么做會(huì )把原先的內容給覆蓋了 。這時(shí)要是能有一個(gè)異常就好了——有些編程語(yǔ)言能讓你規定只能往新建的文件里輸出?？磥?lái)Java是要你用File對象來(lái)判斷文件是否存在，因為如果你用FileOutputStream或FileWriter的話(huà)，文件就會(huì )被覆蓋了。

我對I/O流類(lèi)庫的評價(jià)是比較矛盾的；它確實(shí)能干很多事情，而且做到了跨平臺。但是如果你不懂decorator模式，就會(huì )覺(jué)得這種設計太難理解了，所以無(wú)論是對老師還是學(xué)生，都得多花精力。此外這個(gè)類(lèi)庫也不完整，否則我也用不著(zhù)去寫(xiě)TextFile了。此外它沒(méi)有提供格式化輸出的功能，而其他語(yǔ)言都已經(jīng)提供了這種功能。

但是，一旦你真正理解了decorator模式，并且能開(kāi)始靈活運用這個(gè)類(lèi)庫的時(shí)候，你就能感受到這種設計的好處了。這時(shí)多寫(xiě)幾行代碼就算不了什么了。

如果你覺(jué)得不解渴(本章只是做個(gè)介紹，沒(méi)想要面面俱到)，可以去看Elliotte Rusty Harold 寫(xiě)的Java I/O (O’Reilly, 1999)。這本書(shū)講得更深。

^[61]Design Patterns，作者Erich Gamma等，Addison-Wesley 1995年出版。

^[62]目前還不清楚這種設計是不是好，特別是與其它語(yǔ)言在I/O類(lèi)庫方面的簡(jiǎn)單性相比。但這確實(shí)是個(gè)很充分的理由。

^[63]XML是另一個(gè)能在不同的平臺上轉移數據的辦法，而且它不要求所有平臺都用Java。JDK 1.4的javax.xml.* 里收錄了XML工具。這些內容會(huì )在www.MindView.net 上的Thinking in Enterprise Java中涉及。

^[64]第13章會(huì )介紹一個(gè)更簡(jiǎn)便的解決方案:一個(gè)GUI程序，里邊是帶滾動(dòng)軸的文本框。

^[65]由Chintan Thakker撰寫(xiě)這部分內容。

^[66]第四版里會(huì )有一章專(zhuān)門(mén)講字符串。由Mike Shea供稿。

^[67] 對于他們是怎么想到要起這個(gè)名字的，或者想用這個(gè)名字表達什么意思，我一無(wú)所知。但是我可以很有把握地說(shuō)，不管這是誰(shuí)的杰作，他現在肯定還在領(lǐng)Sun的工資。而且很明顯，他們還在頑固地堅持不復查代碼。請原諒我的冷嘲熱諷，但是經(jīng)過(guò)這么多年，我已經(jīng)對這種事情感到厭煩了。

- 作者： hqman 訪(fǎng)問(wèn)統計： 　2005年10月10日, 星期一 21:49 加入博采