Java IO笔记（StreamTokenizer）

本篇讲述的是java io包中的StreamTokenizer类。

StreamTokenize类可以将任意的输入流分割为一系列标记（token），然后可以每次读取一个标记，先附上源码，进行简单地分析。

StreamTokenizer.java:

package java.io;import java.util.Arrays;public class StreamTokenizer {    //内部声明了一个Reader对象句柄和一个InputStream对象句柄，用于接收读取流。    private Reader reader = null;    private InputStream input = null;    //声明了一个char类型的数组，初始容量为20，用于存储读取时标记的内容，读取时，可以根据实际需要自动扩容。    private char buf[] = new char[20];        //声明了一个int型变量peekc，当调用nextToken方法的时候，peekc作为一个状态，用于判断是否需要继续读取下一个字符放入到标记中，初始化时赋值为NEED_CHAR。    private int peekc = NEED_CHAR;    //定义了两个常量，NEED_CHAR和SKIP_LF都表示要读取下一个字符，但后者如果遇到一个'\n'，则会将它丢弃然后读取下一个字符。    private static final int NEED_CHAR = Integer.MAX_VALUE;    private static final int SKIP_LF = Integer.MAX_VALUE - 1;    //声明了一个boolean型变量pushedBack，该变量用于控制执行nextToken方法时，是否需要进行回退。    private boolean pushedBack;    //声明了一个boolean型变量forceLower，该变量用于控制sval是否需要进行小写处理。    private boolean forceLower;       //声明了一个int型变量，用于记录最后一次读取标记时的行数。    private int LINENO = 1;    private boolean eolIsSignificantP = false;    private boolean slashSlashCommentsP = false;    private boolean slashStarCommentsP = false;    //声明了一个一个数组作为一个语法表，存放几种类型，依次为空格，数字，字母，引号，注解等类型。    private byte ctype[] = new byte[256];    private static final byte CT_WHITESPACE = 1;    private static final byte CT_DIGIT = 2;    private static final byte CT_ALPHA = 4;    private static final byte CT_QUOTE = 8;    private static final byte CT_COMMENT = 16;    //声明了一个int型变量，表明当前标记的标记类型，初始化时为TT_NOTHING类型。    public int ttype = TT_NOTHING;    //定义了一个常量，表示此时已经读取到了流的末尾。    public static final int TT_EOF = -1;    //定义了一个常量，表示此时已经读到了一行的末尾。    public static final int TT_EOL = '\n';    //定义了一个常量，表示此时读到的标记是一个数字标记。    public static final int TT_NUMBER = -2;    //定义了一个常量，表示此时读到的标记是一个文本标记。    public static final int TT_WORD = -3;    //定义了一个常量，表示此时并没有进行标记的读取，用于初始化ttype。    private static final int TT_NOTHING = -4;    //声明了一个字符串型变量sval，如果当前的标记为字符串，那么此时将当前标记的值赋值给sval。    public String sval;    //声明了一个double型变量nval，如果当前的标记为数值，那么此时将当前标记的值赋值给nval。    public double nval;    /**     * 一个私有的构造函数，用于初始化内置的语法表，即ctype数组。     */    private StreamTokenizer() {        wordChars('a', 'z');        wordChars('A', 'Z');        wordChars(128 + 32, 255);        whitespaceChars(0, ' ');        commentChar('/');        quoteChar('"');        quoteChar('\'');        parseNumbers();    }    /**     * 一个带一个参数的构造函数，传入的参数为一个InputStream对象，先对其进行安全检测，如果不为null，则赋值给最初声明的InputStream对象句柄，input。值得注     * 意的是该方法如今已经被弃用了。     */ @Deprecated    public StreamTokenizer(InputStream is) {        this();        if (is == null) {            throw new NullPointerException();        }        input = is;    }    /**     *一个带一个参数的构造函数，传入的参数为一个Reader对象，先对其进行安全检测，如果不为null，则赋值给最初声明的Reader对象句柄，reader。     */    public StreamTokenizer(Reader r) {        this();        if (r == null) {            throw new NullPointerException();        }        reader = r;    }    /**     * 该方法用于重置标记的语法表，通过一个循环，将语法表中的每一个元素都置为0，即当做普通字符进行处理。     */    public void resetSyntax() {        for (int i = ctype.length; --i >= 0;)            ctype[i] = 0;    }    /**     * 用于初始化语法表，传入的两个参数，为语法表的前后区间，将传入区间内的数据     */    public void wordChars(int low, int hi) {        if (low < 0)            low = 0;        if (hi >= ctype.length)            hi = ctype.length - 1;        while (low <= hi)            ctype[low++] |= CT_ALPHA;    }    /**     * 用于初始化语法表，传入的两个参数，为语法表的前后区间，将传入区间内的数据都做为空白空格处理。     */    public void whitespaceChars(int low, int hi) {        if (low < 0)            low = 0;        if (hi >= ctype.length)            hi = ctype.length - 1;        while (low <= hi)            ctype[low++] = CT_WHITESPACE;    }    /**     * 用于初始化语法表，传入的两个参数，为语法表的前后区间，将传入区间内的数据都做为普通字符处理。     */    public void ordinaryChars(int low, int hi) {        if (low < 0)            low = 0;        if (hi >= ctype.length)            hi = ctype.length - 1;        while (low <= hi)            ctype[low++] = 0;    }    /**     * 用于初始化语法表，通过传入的参数作为语法表的索引，将对应的类型该为0，这样便会当做普通字符处理。     */    public void ordinaryChar(int ch) {        if (ch >= 0 && ch < ctype.length)            ctype[ch] = 0;    }    /**     * 用于初始化语法表，以传入的int型值为索引，将其对应的数组划分到CT_COMMENT注解类型。     */    public void commentChar(int ch) {        if (ch >= 0 && ch < ctype.length)            ctype[ch] = CT_COMMENT;    }    /**     * 用于初始化语法表，以传入的int型值为索引，将其对应的数组划分到CT_QUOTE引用类型。     */    public void quoteChar(int ch) {        if (ch >= 0 && ch < ctype.length)            ctype[ch] = CT_QUOTE;    }    /**     * 用于初始化语法表，将数字0-9，'.'，'-'划分到CT_DIGIT数字类型。     */    public void parseNumbers() {        for (int i = '0'; i <= '9'; i++)            ctype[i] |= CT_DIGIT;        ctype['.'] |= CT_DIGIT;        ctype['-'] |= CT_DIGIT;    }    /**     * 该方法用于设置eolIsSignificant变量的值，该值用来恒定是否将行的结尾当做一个标记来处理。     */    public void eolIsSignificant(boolean flag) {        eolIsSignificantP = flag;    }    /**     * 该方法用于设置slashStarCommnetsP的值，该值用于恒定是否将c语言形式的注释当做特殊字符处理，如果为true，则所有包含在注释内的内容会被丢弃。为false，则     * 当做普通字符处理。     */    public void slashStarComments(boolean flag) {        slashStarCommentsP = flag;    }    /**     * 该方法与上一个方法类似，不过是用来恒定是否认可c++形式的注释。     */    public void slashSlashComments(boolean flag) {        slashSlashCommentsP = flag;    }    /**     * 该方法用于修改forceLower变量的值。     */    public void lowerCaseMode(boolean fl) {        forceLower = fl;    }    /**     * 定义了一个read方法，实际上是通过调用内置的reader/input 的read方法，从中看出，优先是使用reader来进去读取的。     */    private int read() throws IOException {        if (reader != null)            return reader.read();        else if (input != null)            return input.read();        else            throw new IllegalStateException();    }    /**     * 该方法用于获取下一个标记。     */    public int nextToken() throws IOException { //判断是否需要进行回退，如果pushedBack值为true，则直接返回上一个标记的类型，同时将pushedBack的值重置为false。        if (pushedBack) {            pushedBack = false;            return ttype;        }        byte ct[] = ctype;        sval = null;        int c = peekc;        if (c < 0)            c = NEED_CHAR;        if (c == SKIP_LF) {            c = read();            if (c < 0)                return ttype = TT_EOF;            if (c == '\n')                c = NEED_CHAR;        }        if (c == NEED_CHAR) {            c = read();            if (c < 0)                return ttype = TT_EOF;        }        ttype = c;             //将peekc重置，方便下一次进入方法时使用          peekc = NEED_CHAR;//如果当前类型是空格，进行的操作        int ctype = c < 256 ? ct[c] : CT_ALPHA;        while ((ctype & CT_WHITESPACE) != 0) {            if (c == '\r') {                LINENO++;                if (eolIsSignificantP) {                    peekc = SKIP_LF;                    return ttype = TT_EOL;                }                c = read();                if (c == '\n')                    c = read();            } else {                if (c == '\n') {                    LINENO++;                    if (eolIsSignificantP) {                        return ttype = TT_EOL;                    }                }                c = read();            }            if (c < 0)                return ttype = TT_EOF;            ctype = c < 256 ? ct[c] : CT_ALPHA;        }//如果当前类型为数字的操作        if ((ctype & CT_DIGIT) != 0) {            boolean neg = false;            if (c == '-') {                c = read();                if (c != '.' && (c < '0' || c > '9')) {                    peekc = c;                    return ttype = '-';                }                neg = true;            }            double v = 0;            int decexp = 0;            int seendot = 0;            while (true) {                if (c == '.' && seendot == 0)                    seendot = 1;                else if ('0' <= c && c <= '9') {                    v = v * 10 + (c - '0');                    decexp += seendot;                } else                    break;                c = read();            }            peekc = c;            if (decexp != 0) {                double denom = 10;                decexp--;                while (decexp > 0) {                    denom *= 10;                    decexp--;                }                v = v / denom;            }            nval = neg ? -v : v;            return ttype = TT_NUMBER;        }//如果当前类型为字母符号的操作        if ((ctype & CT_ALPHA) != 0) {            int i = 0;            do {                if (i >= buf.length) {    //自动扩容                    buf = Arrays.copyOf(buf, buf.length * 2);                }                buf[i++] = (char) c;                c = read();                ctype = c < 0 ? CT_WHITESPACE : c < 256 ? ct[c] : CT_ALPHA;            } while ((ctype & (CT_ALPHA | CT_DIGIT)) != 0);            peekc = c;            sval = String.copyValueOf(buf, 0, i);            if (forceLower)                sval = sval.toLowerCase();            return ttype = TT_WORD;        }//如果当前类型为引用符号的操作        if ((ctype & CT_QUOTE) != 0) {            ttype = c;            int i = 0;                     int d = read();            while (d >= 0 && d != ttype && d != '\n' && d != '\r') {                if (d == '\\') {                    c = read();                    int first = c;   /* To allow \377, but not \477 */                    if (c >= '0' && c <= '7') {                        c = c - '0';                        int c2 = read();                        if ('0' <= c2 && c2 <= '7') {                            c = (c << 3) + (c2 - '0');                            c2 = read();                            if ('0' <= c2 && c2 <= '7' && first <= '3') {                                c = (c << 3) + (c2 - '0');                                d = read();                            } else                                d = c2;                        } else                          d = c2;                    } else {                        switch (c) {                        case 'a':                            c = 0x7;                            break;                        case 'b':                            c = '\b';                            break;                        case 'f':                            c = 0xC;                            break;                        case 'n':                            c = '\n';                            break;                        case 'r':                            c = '\r';                            break;                        case 't':                            c = '\t';                            break;                        case 'v':                            c = 0xB;                            break;                        }                        d = read();                    }                } else {                    c = d;                    d = read();                }                if (i >= buf.length) {                    buf = Arrays.copyOf(buf, buf.length * 2);                }                buf[i++] = (char)c;            }            peekc = (d == ttype) ? NEED_CHAR : d;            sval = String.copyValueOf(buf, 0, i);            return ttype;        }//关于对待注解形式的处理。        if (c == '/' && (slashSlashCommentsP || slashStarCommentsP)) {            c = read();            if (c == '*' && slashStarCommentsP) {                int prevc = 0;                while ((c = read()) != '/' || prevc != '*') {                    if (c == '\r') {                        LINENO++;                        c = read();                        if (c == '\n') {                            c = read();                        }                    } else {                        if (c == '\n') {                            LINENO++;                            c = read();                        }                    }                    if (c < 0)                        return ttype = TT_EOF;                    prevc = c;                }                return nextToken();            } else if (c == '/' && slashSlashCommentsP) {                while ((c = read()) != '\n' && c != '\r' && c >= 0);                peekc = c;                return nextToken();            } else {                if ((ct['/'] & CT_COMMENT) != 0) {                    while ((c = read()) != '\n' && c != '\r' && c >= 0);                    peekc = c;                    return nextToken();                } else {                    peekc = c;                    return ttype = '/';                }            }        }    //对于当前类型是注解时的操作。        if ((ctype & CT_COMMENT) != 0) {            while ((c = read()) != '\n' && c != '\r' && c >= 0);            peekc = c;            return nextToken();        }        return ttype = c;    }    /**     * 调用该方法时，首先进行安全检测，如果ttype不为TT_NOTHING,即已经调用过nextToken方法，那么将pushedBack的值设为true，下一次执行nextToeken方法时，     * 便不会修改当前标记的类型，同时也不会去修改当前nval或者sval的值。     */    public void pushBack() {        if (ttype != TT_NOTHING)               pushedBack = true;    }    /**     * 该方法返回LINENO的值，即分割标记后最后的行数，值得注意的是如果将换行符设置为普通字符的话，会影响该方法的准确性。     */    public int lineno() {        return LINENO;    }    /**     * 该方法可以得到一个字符串，字符串内容为当前标记的类型，以及标记所在的行数。     */    public String toString() {        String ret;        switch (ttype) {          case TT_EOF:            ret = "EOF";            break;          case TT_EOL:            ret = "EOL";            break;          case TT_WORD:            ret = sval;            break;          case TT_NUMBER:            ret = "n=" + nval;            break;          case TT_NOTHING:            ret = "NOTHING";            break;          default: {                if (ttype < 256 &&                    ((ctype[ttype] & CT_QUOTE) != 0)) {                    ret = sval;                    break;                }                char s[] = new char[3];                s[0] = s[2] = '\'';                s[1] = (char) ttype;                ret = new String(s);                break;            }        }        return "Token[" + ret + "], line " + LINENO;    }}

源码可能乍一眼看起来没有一些直观的认识，下面将通过一些具体的例子来加深理解：

package dataInOut;import java.io.File;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.IOException;import java.io.StreamTokenizer;import java.io.UnsupportedEncodingException;public class DataTest {public static void main(String[] args) throws UnsupportedEncodingException,FileNotFoundException {//通过传入一个FileReader来构建一个StreamTokenizer。这里读取的是本地的一个txt文件。StreamTokenizer stk = new StreamTokenizer(new FileReader(new File("E:\\workspaceforlibgdx\\IOStudy\\src\\file\\test.txt")));//1stk.resetSyntax();//2stk.ordinaryChar('\"');//3stk.ordinaryChar('/');try {//当没有读取到文件结尾时，不停调用nextToken方法，然后将每一个token及其行号打印出来。while (stk.nextToken() != StreamTokenizer.TT_EOF) {String s = null;switch (stk.ttype) {case StreamTokenizer.TT_WORD:s = stk.sval;break;case StreamTokenizer.TT_NUMBER:s = String.valueOf(stk.nval);break;default:s = stk.sval;}System.out.println(stk.toString());}} catch (IOException e) {e.printStackTrace();}}}

执行上述代码可以看到以下打印：
这是读取的test.txt文本的内容：

这是控制台打印的内容：

这里我们注意到的是通过nextToken中方法读取的数字型数据都是double类型的，如果不符合要求，需自行进行转换。
下面我们通过修改test.txt文本中的内容，再次运行时，会得到不一样的输出打印：

从打印中可以看出，被引号所包裹的内容无论长短，都被当做一个token处理，被注释掉的内容在读取时会被舍弃。如果想让这写符号被当做普通符号来进行处理，只需调用StreamTokenizer类中的ondinaryChar或者ondinaryChars方法便可以将特殊的字符也当做普通字符处理，比如我们本次的例子中，放开注释2,3，便可以将引号和注释符号当做普通符号处理，执行代码后可以得到如下打印：

如果放开注释1的话，则会把所有的字符都当做普通字符处理。这里要注意的是有时有人会把token数和字符数混淆在一起，从上面的例子中也可以看出，token数是不等于字符数的。StreamTokenizer类可以用于分析一个流中文本，数字等不同类型数据的次数。最后它还有一个使用方法，用于我们基本的输入操作：

package dataInOut;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import java.io.PrintWriter;import java.io.StreamTokenizer;public class DataTest{    public static void main(String[] args) throws IOException    {//将标准输入流传入StreamTokenizer中。        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));        int a, b;        while(in.nextToken() != StreamTokenizer.TT_EOF)        {            a = (int)in.nval;            in.nextToken();            b = (int)in.nval;            //out.println(a + b);            System.out.println("a + b = "+(a+b));        }//将缓存区中的数据真实写出。        out.flush();    }}

这样的实现是不是让你想到了Scanner类呢。java已经帮我们封装好了类似的类，但是Scanner类的效率低于StreamTokenizer类。
以上为本篇内容。