改進JAVA字符串分解的方法


一、概述

　　大多數Java程序員都曾經使用過java.util.StringTokenizer類。它是一個很方便的字符串分解器，主要用來根據分隔符把字符串分割成標記（Token），然后按照請求返回各個標記。這個過程稱為Tokenization，實際上就是把字符序列轉換成應用程序能夠理解的多個標記。

　　雖然StringTokenizer用起來很方便，但它的功能卻很有限。這個類只是簡單地在輸入字符串中查找分隔符，一旦找到了分隔符就分割字符串。它不會檢查分隔符是否在子串之中這類條件，當輸入字符串中出現兩個連續的分隔符時，它也不會返回""（字符串長度為0）形式的標記。

　　為了突破這些局限，Java 2平臺提供了BreakIterator類，它是在StringTokenizer之上改進的字符串分解器。由于JDK 1.1.x沒有提供這個類，為了滿足自己的需要，開發者經常花費很多時間從頭開始編寫分解器。在涉及到數據格式化處理的大型工程中，這類定制的字符串分解器有時隨處可見，而且這種情況并不罕見。

　　本文的目標是幫助你利用現有的StringTokenizer類，編寫一個高級字符串分解器。

二、StringTokenizer的局限

　　你可以用以下三種構造函數中的任意一種創建StringTokenizer分解器：


StringTokenizer(String sInput)：以空白字符（“ ”，“\t”，“\n”）為分隔符分割字符串。
StringTokenizer(String sInput, String sDelimiter)：以sDelimiter為分隔符分割字符串。
StringTokenizer(String sInput, String sDelimiter, boolean bReturnTokens)：以sDelimiter為分隔符分割字符串，但如果bReturnTokens為true，則分隔符也作為標記返回。
　　第一個構造函數不檢查輸入字符串是否包含子串。例如，如果以空白字符為分隔符分割“hello. Today \"I am \" going to my home town”，則字符串分解結果是hello.、Today、"I、am、"、going等，而不是hello.、Today、"I am "、going等。

　　第二個構造函數不檢查兩個分隔符連續出現的情況。例如，如果以“,”為分隔符分割“book, author, publication,,,date published”這個字符串，則StringTokenizer返回book、author、publication和date published這四個標記，而不是book、author、publication、""、""和date published這6個標記（其中""表示0長度字符串）。要得到6個標記的答案，你必須把StringTokenizer的bReturnTokens參數設置為true。

　　允許設置值為true的bReturnTokens參數是一個重要的功能，因為它考慮到了分隔符連續出現的情況。例如，使用第二個構造函數時，如果數據是動態收集得到而且要用來更新數據庫中的表，輸入字符串中的標記對應著表里面列的值，那么當我們不能確定哪一個列應該設置為""時，我們就無法把輸入串中的標記映射到數據庫列。假設我們要把記錄插入到一個有6個列的表，而輸入數據中包含兩個連續的分隔符。此時，StringTokenizer的分解結果是5個標記（兩個連續的分隔符代表""標記，它將被StringTokenizer忽略），而我們卻有6個字段需要設置。同時，我們也不知道連續分隔符在哪里出現，所以也就不知道哪一個列應該設置成""。

　　當標記本身等同于分隔符（無論是長度還是值）且位于子串之內時，第三個構造函數無效。例如，如果我們要以“,”為分隔符分解字符串“book, author, publication,\",\",date published”（這個字符串包含一個“,”標記，它與分隔符一樣），結果是book、author、publication、"、"、date published這六個標記，而不是book、author、publication、,（逗號字符）、date published這五個標記。再提醒一下，即使我們把StringTokenizer的bReturnTokens參數設置設置成了true，在這種情況下也沒有什么幫助。

三、高級字符串分解器

　　在編寫代碼之前，你必須搞清楚一個好的分解器有哪些基本要求。因為Java開發者已經習慣于使用StringTokenizer類，所以一個好的分解器應該提供StringTokenizer類提供的所有實用方法，比如hasMoreTokens()、nextToken()、countTokens()。

　　本文提供的代碼很簡單，而且大部分代碼足以自我解釋。在這里，我主要利用了StringTokenizer類（創建類實例時bReturnTokens參數設置為true），并提供了上面提到的幾個方法。大多數時候標記與分隔符不同，有些時候分隔符卻要作為標記輸出（盡管非常罕見），此時如果出現了對標記的請求，分解器要把分隔符作為標記輸出。創建PowerfulTokenizer對象時，你只需要提供輸入字符串和分隔符這兩個參數，PowerfulTokenizer將在內部使用bReturnTokens設置成true的StringTokenizer。（這么做的原因在于，如果不是用bReturnTokens設置成true的方式創建StringTokenizer，那么它將在解決先前提出的問題時受到限制）。為了正確地控制分解器，代碼在幾個地方（計算標記的總數量以及nextToken()）檢查bReturnTokens是否設置成了true。

　　你可能已經發現，PowerfulTokenizer實現了Enumeration接口，從而也就實現了hasMoreElements()和nextElement()這兩個方法，而這兩個方法又分別把調用直接委托給hasMoreTokens()和nextToken()。（由于實現了Enumeration接口，PowerfulTokenizer實現了與StringTokenizer的向后兼容。）

　　我們來看一個例子，假設輸入字符串是“hello, Today,,, \"I, am \", going to,,, \"buy, a, book\"”，分隔符是“,”。用分解器分割這個字符串時返回結果如表1所示：

表1：字符串分解結果

　　輸入字符串包含11個逗號（,）字符，其中3個在子串里面、4個連續出現（“Today,,,”中包含兩個連續逗號，第一個逗號是Today的分隔符）。下面是PowerfulTokenizer計算標記總數的算法：


如果bReturnTokens=true，把子串中的分隔符數量乘以2，再從實際總數量減去該數字，就得到了標記的總數。理由是，對于子串“buy, a, book”，StringTokenizer將返回5個標記（即“buy:,:a:,:book”），而PowerfulTokenizer將返回一個標記（即“buy, a, book”），兩者的差值是4（即，2乘以子串中的分隔符數量）。這個公式對于所有包含分隔符的子串都有效。
類似地，對于bReturnTokens=false的情形，我們從實際總數（19）減去表達式[分隔符總數（11）- 連續分隔符數量（4） + 子串中的分隔符數量（3）]。由于這時我們不返回分隔符，它們（非連續出現或在子串內部）對我們來說沒有用，上面的公式為我們返回了標記的總數量（9）。
　　請記住這兩個公式，它們是PowerfulTokenizer的核心。這兩個公式適用于幾乎所有它們各自條件下的情形。但是，如果你有更復雜的要求，不能使用這兩個公式，那么你應該在編寫代碼之前分析各種可能出現的情況，并設計出自己的公式。


// 檢查分隔符是否位于子串之內
for (int i=1; i<aiIndex.length; i++)>/td>
{
iIndex = sInput.indexOf(sDelim, iIndex+1);
if (iIndex == -1)
break;
// 如果分隔符位于子串之內，則向前分析直至子串結束
while (sInput.substring(iIndex-iLen, iIndex).equals(sDelim))
{
iNextIndex = sInput.indexOf(sDelim, iIndex+1);
if (iNextIndex == -1)
break;
iIndex = iNextIndex;
}
aiIndex[i] = iIndex;
//System.out.println("aiIndex[" + i + "] = " + iIndex);
if (isWithinQuotes(iIndex))
{
if (bIncludeDelim)
iTokens -= 2;
else
iTokens -= 1;
}
}




　　countTokens()方法檢查子串是否包含雙引號。如果包含，那么它減少總數并把索引值修改為字符串中下一個雙引號出現的位置（如上面的代碼片斷所示）。如果bReturnTokens是false，那么它從總數減去輸入字符串中出現的非連續分隔符的數量。


// 如發現多個連續的分隔符，則返回""作為標記
if ( (sPrevToken.equals(sDelim)) && (sToken.equals(sDelim)) ) {
sPrevToken = sToken;
iTokenNo++;
return "";
}

// 檢查標記本身是否等于分隔符
if ( (sToken.trim().startsWith("\"")) && (sToken.length() == 1) ) {
// 標記本身等于分隔符的特殊情況
String sNextToken = oTokenizer.nextToken();
while (!sNextToken
sToken += sNextToken;
sPrevToken = sToken;
iTokenNo++;
return sToken.substring(1, sToken.length()-1);
}
// 檢查字符串中是否包含子串
else if ( (sToken.trim().startsWith("\""))
&& (!((sToken.trim().endsWith("\""))
&& (!sToken.trim().endsWith("\"\"")))) )
{
if (oTokenizer.hasMoreTokens())
{
String sNextToken = oTokenizer.nextToken();
// 檢查"\"\""
while (!((sNextToken.trim().endsWith("\""))
&& (!sNextToken.trim().endsWith("\"\""))) )
{
sToken += sNextToken;
if (!oTokenizer.hasMoreTokens())
{
sNextToken = "";
break;
}
sNextToken = oTokenizer.nextToken();
}
sToken += sNextToken;
}
}
　　nextToken()方法通過StringTokenizer.nextToken方法獲取標記，并檢查標記中的雙引號字符。如果發現了這些字符，它繼續獲取標記直至不能再找到帶有雙引號的標記。另外，它還把標記保存到一個變量（sPrevToken，參見本文后面完整的源代碼）以檢查連續出現的分隔符。如果nextToken()發現等同于分隔符的連續多個標記，那么它返回""（長度為0的字符串）作為標記。

　　按照類似的方法，hasMoreTokens()方法檢查已經返回的標記數量是否小于標記的總數量。

　　【結束語】本文為你介紹了如何輕松地編寫一個強大的字符串分解器。根據本文介紹的原理，你能夠迅速編寫出復雜的字符串分解器，節省大量的開發時間

_______________________________________________________________________

/**
?* 文本分割
?*/
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class spliter_file{
?public static void main(String[] args) throws IOException{
??String fileinname = "D:\\01.txt";
??String fileoutname = "D:\\02.txt";
??FileReader in = new FileReader(fileinname);
//??ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileinname));
??PrintWriter out = new PrintWriter(new FileWriter(fileoutname));
??boolean flag = true;
??boolean signflag = false;
??String word = "";
??char c;
??char ct[] = new char[1];
??long filesize = (new File(fileinname)).length();
//??System.out.println(filesize);
??long current = 0;
??long totalwords = 0;
??while(flag){
???if(current > filesize){
????out.println("The total words is : " + totalwords + ".");
????in.close();
????out.close();
????break;
???}
???try{
????current++;
????in.read(ct);
????c = ct[0];
//????System.out.println(current + "? " + c);
//????in.skip(0);
????if (c == '\'') {
?????if(word.equals("")){
??????continue;
?????}
?????if(word.toLowerCase().equals("o")){
??????word += c;
??????continue;
?????}
?????signflag = true;
?????word += c;
?????continue;
????}
????if (signflag) {
?????if (c == 's' || c == 'S') {
??????c = 's';
??????signflag = false;
?????} else {
??????word = word.substring(0, word.length() - 1);
??????out.println(word);
??????out.flush();
??????totalwords++;
??????word = "";
??????signflag = false;
??????continue;
?????}
????}
????if(c == '\n' || c == '\r' || c == ' ' || c == '.' || c == ','
?????|| c == ';' || c == ':'
?????|| c == '\"'|| c == '\t'|| c == '\f'?
?????|| c == '，'?|| c == '。'?|| c == '：'|| c == '‘'
?????|| c == '“'?|| c == '”'?|| c == '’'|| c == '；' ){
?????if(!word.equals("")){
??????out.println(word);
??????out.flush();
??????totalwords++;
??????word = "";
?????}
?????continue;
????}
????word += c;
???}catch(Exception e){
????flag = false;
????out.println("The total words is : " + totalwords + ".");
????in.close();
????out.close();
???}
??}
?}
}