# 10.6 `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章提供。
## 10.6.1 `StringTokenizer`
盡管并不必要IO庫的一部分,但`StringTokenizer`提供了與`StreamTokenizer`極相似的功能,所以在這里一并講述。
`StringTokenizer`的作用是每次返回字符串內的一個記號。這些記號是一些由制表站、空格以及新行分隔的連續字符。因此,字符串`"Where is my cat?"`的記號分別是`"Where"`、`"is"`、`"my"`和`"cat?"`。與`StreamTokenizer`類似,我們可以指示`StringTokenizer`按照我們的愿望分割輸入。但對于`StringTokenizer`,卻需要向構造器傳遞另一個參數,即我們想使用的分隔字符串。通常,如果想進行更復雜的操作,應使用`StreamTokenizer`。
可用`nextToken()`向`StringTokenizer`對象請求字符串內的下一個記號。該方法要么返回一個記號,要么返回一個空字符串(表示沒有記號剩下)。
作為一個例子,下述程序將執行一個有限的句法分析,查詢鍵短語序列,了解句子暗示的是快樂亦或悲傷的含義。
```
//: AnalyzeSentence.java
// Look for particular sequences
// within sentences.
import java.util.*;
public class AnalyzeSentence {
public static void main(String[] args) {
analyze("I am happy about this");
analyze("I am not happy about this");
analyze("I am not! I am happy");
analyze("I am sad about this");
analyze("I am not sad about this");
analyze("I am not! I am sad");
analyze("Are you happy about this?");
analyze("Are you sad about this?");
analyze("It's you! I am happy");
analyze("It's you! I am sad");
}
static StringTokenizer st;
static void analyze(String s) {
prt("\nnew sentence >> " + s);
boolean sad = false;
st = new StringTokenizer(s);
while (st.hasMoreTokens()) {
String token = next();
// Look until you find one of the
// two starting tokens:
if(!token.equals("I") &&
!token.equals("Are"))
continue; // Top of while loop
if(token.equals("I")) {
String tk2 = next();
if(!tk2.equals("am")) // Must be after I
break; // Out of while loop
else {
String tk3 = next();
if(tk3.equals("sad")) {
sad = true;
break; // Out of while loop
}
if (tk3.equals("not")) {
String tk4 = next();
if(tk4.equals("sad"))
break; // Leave sad false
if(tk4.equals("happy")) {
sad = true;
break;
}
}
}
}
if(token.equals("Are")) {
String tk2 = next();
if(!tk2.equals("you"))
break; // Must be after Are
String tk3 = next();
if(tk3.equals("sad"))
sad = true;
break; // Out of while loop
}
}
if(sad) prt("Sad detected");
}
static String next() {
if(st.hasMoreTokens()) {
String s = st.nextToken();
prt(s);
return s;
}
else
return "";
}
static void prt(String s) {
System.out.println(s);
}
} ///:~
```
對于準備分析的每個字符串,我們進入一個`while`循環,并將記號從那個字符串中取出。請注意第一個if語句,假如記號既不是`"I"`,也不是`"Are"`,就會執行`continue`(返回循環起點,再一次開始)。這意味著除非發現一個`"I"`或者`"Are"`,才會真正得到記號。大家可能想用`==`代替`equals()`方法,但那樣做會出現不正常的表現,因為`==`比較的是引用值,而`equals()`比較的是內容。
`analyze()`方法剩余部分的邏輯是搜索`"I am sad"`(我很憂傷、`"I am nothappy"`(我不快樂)或者`"Are you sad?"`(你悲傷嗎?)這樣的句法格式。若沒有`break`語句,這方面的代碼甚至可能更加散亂。大家應注意對一個典型的解析器來說,通常都有這些記號的一個表格,并能在讀取新記號的時候用一小段代碼在表格內移動。
無論如何,只應將`StringTokenizer`看作`StreamTokenizer`一種簡單而且特殊的簡化形式。然而,如果有一個字符串需要進行記號處理,而且`StringTokenizer`的功能實在有限,那么應該做的全部事情就是用`StringBufferInputStream`將其轉換到一個數據流里,再用它創建一個功能更強大的`StreamTokenizer`。
- Java 編程思想
- 寫在前面的話
- 引言
- 第1章 對象入門
- 1.1 抽象的進步
- 1.2 對象的接口
- 1.3 實現方案的隱藏
- 1.4 方案的重復使用
- 1.5 繼承:重新使用接口
- 1.6 多態對象的互換使用
- 1.7 對象的創建和存在時間
- 1.8 異常控制:解決錯誤
- 1.9 多線程
- 1.10 永久性
- 1.11 Java和因特網
- 1.12 分析和設計
- 1.13 Java還是C++
- 第2章 一切都是對象
- 2.1 用引用操縱對象
- 2.2 所有對象都必須創建
- 2.3 絕對不要清除對象
- 2.4 新建數據類型:類
- 2.5 方法、參數和返回值
- 2.6 構建Java程序
- 2.7 我們的第一個Java程序
- 2.8 注釋和嵌入文檔
- 2.9 編碼樣式
- 2.10 總結
- 2.11 練習
- 第3章 控制程序流程
- 3.1 使用Java運算符
- 3.2 執行控制
- 3.3 總結
- 3.4 練習
- 第4章 初始化和清除
- 4.1 用構造器自動初始化
- 4.2 方法重載
- 4.3 清除:收尾和垃圾收集
- 4.4 成員初始化
- 4.5 數組初始化
- 4.6 總結
- 4.7 練習
- 第5章 隱藏實現過程
- 5.1 包:庫單元
- 5.2 Java訪問指示符
- 5.3 接口與實現
- 5.4 類訪問
- 5.5 總結
- 5.6 練習
- 第6章 類復用
- 6.1 組合的語法
- 6.2 繼承的語法
- 6.3 組合與繼承的結合
- 6.4 到底選擇組合還是繼承
- 6.5 protected
- 6.6 累積開發
- 6.7 向上轉換
- 6.8 final關鍵字
- 6.9 初始化和類裝載
- 6.10 總結
- 6.11 練習
- 第7章 多態性
- 7.1 向上轉換
- 7.2 深入理解
- 7.3 覆蓋與重載
- 7.4 抽象類和方法
- 7.5 接口
- 7.6 內部類
- 7.7 構造器和多態性
- 7.8 通過繼承進行設計
- 7.9 總結
- 7.10 練習
- 第8章 對象的容納
- 8.1 數組
- 8.2 集合
- 8.3 枚舉器(迭代器)
- 8.4 集合的類型
- 8.5 排序
- 8.6 通用集合庫
- 8.7 新集合
- 8.8 總結
- 8.9 練習
- 第9章 異常差錯控制
- 9.1 基本異常
- 9.2 異常的捕獲
- 9.3 標準Java異常
- 9.4 創建自己的異常
- 9.5 異常的限制
- 9.6 用finally清除
- 9.7 構造器
- 9.8 異常匹配
- 9.9 總結
- 9.10 練習
- 第10章 Java IO系統
- 10.1 輸入和輸出
- 10.2 增添屬性和有用的接口
- 10.3 本身的缺陷:RandomAccessFile
- 10.4 File類
- 10.5 IO流的典型應用
- 10.6 StreamTokenizer
- 10.7 Java 1.1的IO流
- 10.8 壓縮
- 10.9 對象序列化
- 10.10 總結
- 10.11 練習
- 第11章 運行期類型識別
- 11.1 對RTTI的需要
- 11.2 RTTI語法
- 11.3 反射:運行期類信息
- 11.4 總結
- 11.5 練習
- 第12章 傳遞和返回對象
- 12.1 傳遞引用
- 12.2 制作本地副本
- 12.3 克隆的控制
- 12.4 只讀類
- 12.5 總結
- 12.6 練習
- 第13章 創建窗口和程序片
- 13.1 為何要用AWT?
- 13.2 基本程序片
- 13.3 制作按鈕
- 13.4 捕獲事件
- 13.5 文本字段
- 13.6 文本區域
- 13.7 標簽
- 13.8 復選框
- 13.9 單選鈕
- 13.10 下拉列表
- 13.11 列表框
- 13.12 布局的控制
- 13.13 action的替代品
- 13.14 程序片的局限
- 13.15 視窗化應用
- 13.16 新型AWT
- 13.17 Java 1.1用戶接口API
- 13.18 可視編程和Beans
- 13.19 Swing入門
- 13.20 總結
- 13.21 練習
- 第14章 多線程
- 14.1 反應靈敏的用戶界面
- 14.2 共享有限的資源
- 14.3 堵塞
- 14.4 優先級
- 14.5 回顧runnable
- 14.6 總結
- 14.7 練習
- 第15章 網絡編程
- 15.1 機器的標識
- 15.2 套接字
- 15.3 服務多個客戶
- 15.4 數據報
- 15.5 一個Web應用
- 15.6 Java與CGI的溝通
- 15.7 用JDBC連接數據庫
- 15.8 遠程方法
- 15.9 總結
- 15.10 練習
- 第16章 設計模式
- 16.1 模式的概念
- 16.2 觀察器模式
- 16.3 模擬垃圾回收站
- 16.4 改進設計
- 16.5 抽象的應用
- 16.6 多重分發
- 16.7 訪問器模式
- 16.8 RTTI真的有害嗎
- 16.9 總結
- 16.10 練習
- 第17章 項目
- 17.1 文字處理
- 17.2 方法查找工具
- 17.3 復雜性理論
- 17.4 總結
- 17.5 練習
- 附錄A 使用非JAVA代碼
- 附錄B 對比C++和Java
- 附錄C Java編程規則
- 附錄D 性能
- 附錄E 關于垃圾收集的一些話
- 附錄F 推薦讀物