StreamTokenizer

尽量StreamTokenizer并不是从InputStream或OutputStream衍生的，但它只伴同InputStream事情，所以十分恰内地包罗在库的IO部门中。
StreamTokenizer类用于将任何InputStream支解为一系列“暗号”（Token）。这些暗号实际是一些断续的文本块，中间用我们选择的任何对象脱离。譬喻，我们的暗号可以是单词，中间用空缺（空格）以及标点标记脱离。
下面是一个简朴的措施，用于计较各个单词在文本文件中反复呈现的次数：
 

//: SortedWordCount.java
// Counts words in a file, outputs
// results in sorted form.
import java.io.*;
import java.util.*;
import c08.*; // Contains StrSortVector

class Counter {
  private int i = 1;
  int read() { return i; }
  void increment() { i++; }
}

public class SortedWordCount {
  private FileInputStream file;
  private StreamTokenizer st;
  private Hashtable counts = new Hashtable();
  SortedWordCount(String filename)
    throws FileNotFoundException {
    try {
      file = new FileInputStream(filename);
      st = new StreamTokenizer(file);
      st.ordinaryChar('.');
      st.ordinaryChar('-');
    } catch(FileNotFoundException e) {
      System.out.println(
        "Could not open " + filename);
      throw e;
    }
  }
  void cleanup() {
    try {
      file.close();
    } catch(IOException e) {
      System.out.println(
        "file.close() unsuccessful");
    }
  }
  void countWords() {
    try {
      while(st.nextToken() !=
        StreamTokenizer.TT_EOF) {
        String s;
        switch(st.ttype) {
          case StreamTokenizer.TT_EOL:
            s = new String("EOL");
            break;
          case StreamTokenizer.TT_NUMBER:
            s = Double.toString(st.nval);
            break;
          case StreamTokenizer.TT_WORD:
            s = st.sval; // Already a String
            break;
          default: // single character in ttype
            s = String.valueOf((char)st.ttype);
        }
        if(counts.containsKey(s))
          ((Counter)counts.get(s)).increment();
        else
          counts.put(s, new Counter());
      }
    } catch(IOException e) {
      System.out.println(
        "st.nextToken() unsuccessful");
    }
  }
  Enumeration values() {
    return counts.elements();
  }
  Enumeration keys() { return counts.keys(); }
  Counter getCounter(String s) {
    return (Counter)counts.get(s);
  }
  Enumeration sortedKeys() {
    Enumeration e = counts.keys();
    StrSortVector sv = new StrSortVector();
    while(e.hasMoreElements())
      sv.addElement((String)e.nextElement());
    // This call forces a sort:
    return sv.elements();
  }
  public static void main(String[] args) {
    try {
      SortedWordCount wc =
        new SortedWordCount(args[0]);
      wc.countWords();
      Enumeration keys = wc.sortedKeys();
      while(keys.hasMoreElements()) {
        String key = (String)keys.nextElement();
        System.out.println(key + ": "
                 + wc.getCounter(key).read());
      }
      wc.cleanup();
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
} ///:~

最好将功效按排序名目输出，但由于Java 1.0和Java 1.1都没有提供任何排序要领，所以必需由本身动手。这个方针可用一个StrSortVector利便地告竣（建设于第8章，属于那一章建设的软件包的一部门。记着本书所有子目次的起始目次都必需位于类路径中，不然措施将不能正确地编译）。
为打开文件，利用了一个FileInputStream。并且为了将文件转换成单词，从FileInputStream中建设了一个StreamTokenizer。在StreamTokenizer中，存在一个默认的脱离符列表，我们可用一系列要领插手更多的脱离符。在这里，我们用ordinaryChar()指出“该字符没有出格重要的意义”，所以理会器不会把它看成本身建设的任何单词的一部门。譬喻，st.ordinaryChar(‘.’)暗示小数点不会成为理会出来的单词的一部门。在与Java配套提供的联机文档中，可以找到更多的相关信息。
在countWords()中，每次从数据流中取出一个暗号，而ttype信息的浸染是判定对每个暗号采纳什么操纵——因为暗号大概代表一个行尾、一个数字、一个字串可能一个字符。
找到一个暗号后，会查询Hashtable counts，核实个中是否已经以“键”（Key）的形式包括了一个暗号。若谜底是必定的，对应的Counter（计数器）工具就会增值，指出已找到该单词的另一个实例。若谜底为否，则新建一个Counter——因为Counter构建器会将它的值初始化为1，正是我们计较单词数量时的要求。
SortedWordCount并不属于Hashtable（散列表）的一种范例，所以它不会担任。它执行的一种特定范例的操纵，所以尽量keys()和values()要领都必需从头展现出来，但仍不暗示应利用谁人担任，因为大量Hashtable要领在这里都是不适当的。除此以外，对付另一些要领来说（好比getCounter()——用于得到一个特定字串的计数器；又如sortedKeys()——用于发生一个列举），它们最终都改变了SortedWordCount接口的形式。
在main()内，我们用SortedWordCount打开和计较文件中的单词数量——总共只用了两行代码。随后，我们为一个排好序的键（单词）列表提取出一个列举。并用它得到每个键以及相关的Count（计数）。留意必需挪用cleanup()，不然文件不能正常封锁。
回收了StreamTokenizer的第二个例子将在第17章提供。