JAVA伊奥。Java |集合1中的StreamTokenizer类-yiteyi-C++库

null

JAVA伊奥。StreamTokenizer类将输入流解析为“令牌”。它允许一次读取一个令牌。流标记器可以识别数字、带引号的字符串和各种注释样式。 宣言：

public class StreamTokenizer
  extends Object

建造师： StreamTokenizer（读卡器参数）： 创建解析给定字符流的标记器。

方法：

commentChar：

JAVA伊奥。StreamTokenizer。commentChar（int arg） 忽略此StreamTokenizer从单行注释字符到行尾的所有字符。 语法：

public void commentChar(int arg) 
Parameters : 
arg : the character after which all characters are ignored in the line.
Return :
No value is returned.

实施：

                     // Java Program illustrating use of commentChar() method                   
                             
                     import                               java.io.*;                   
                     public                               class                               NewClass                   
                     {                   
                                         public                               static                               void                               main(String[] args)                               throws                               InterruptedException,                   
                                         FileNotFoundException, IOException                   
                                         {                   
                                         FileReader reader =                               new                               FileReader(                               "ABC.txt"                               );                   
                                         BufferedReader bufferread =                               new                               BufferedReader(reader);                   
                                         StreamTokenizer token =                               new                               StreamTokenizer(bufferread);                   
                                         // Use of commentChar() method                   
                                         token.commentChar(                               'a'                               );                   
                                         int                               t;                   
                                         while                               ((t = token.nextToken()) != StreamTokenizer.TT_EOF)                   
                                         {                   
                                         switch                               (t)                   
                                         {                   
                                         case                               StreamTokenizer.TT_NUMBER:                   
                                         System.out.println(                               "Number : "                               + token.nval);                   
                                         break                               ;                   
                                         case                               StreamTokenizer.TT_WORD:                   
                                         System.out.println(                               "Word : "                               + token.sval);                   
                                         break                               ;                   
                             
                                         }                   
                                         }                   
                                         }                   
                     }                   

注：由于不存在“ABC”文件，此程序不会在此处运行。您可以在系统的Java编译器上检查这些代码。要检查此代码，请在系统上创建一个文件“ABC”。 “ABC”文件包含：

程序员 1. 2. 3. 极客你好我的朋友们，这里解释了一个程序。

输出：

Word : Progr
Number : 1.0
Number : 2.0
Number : 3.0
Word : Geeks
Word : Hello

lineno（）： JAVA伊奥。StreamTokenizer。lineno（） 返回此StreamTokenizer的当前行号。 语法：

public int lineno()
Parameters : 
arg : the character after which all characters are ignored in the line.
Return :
returns the current line number of this StreamTokenizer.

实施：

                       // Java Program  illustrating use of lineno() method                     
                                
                       import                                  java.io.*;                     
                       public                                  class                                  NewClass                     
                       {                     
                                
                                             public                                  static                                  void                                  main(String[] args)                                  throws                                  InterruptedException,                     
                                             FileNotFoundException, IOException                     
                                             {                     
                                             FileReader reader =                                  new                                  FileReader(                                  "ABC.txt"                                  );                     
                                             BufferedReader bufferread =                                  new                                  BufferedReader(reader);                     
                                             StreamTokenizer token =                                  new                                  StreamTokenizer(bufferread);                     
                                
                                             token.eolIsSignificant(                                  true                                  );                     
                                             // Use of lineno() method                     
                                             // to get current line no.                     
                                             System.out.println(                                  "Line Number:"                                  + token.lineno());                     
                                
                                             token.commentChar(                                  'a'                                  );                     
                                             int                                  t;                     
                                             while                                  ((t = token.nextToken()) != StreamTokenizer.TT_EOF)                     
                                             {                     
                                             switch                                  (t)                     
                                             {                     
                                             case                                  StreamTokenizer.TT_EOL:                     
                                             System.out.println(                                  ""                                  );                     
                                             System.out.println(                                  "Line No. : "                                  + token.lineno());                     
                                             break                                  ;                     
                                             case                                  StreamTokenizer.TT_NUMBER:                     
                                             System.out.println(                                  "Number : "                                  + token.nval);                     
                                             break                                  ;                     
                                             case                                  StreamTokenizer.TT_WORD:                     
                                             System.out.println(                                  "Word : "                                  + token.sval);                     
                                             break                                  ;                     
                                
                                             }                     
                                             }                     
                                             }                     
                       }                     

输出：

Line Number:1
Word : Progr

Line No. : 2
Number : 1.0

Line No. : 3
Number : 2.0

Line No. : 4
Number : 3.0

Line No. : 5
Word : Geeks

Line No. : 6
Word : Hello

Line No. : 7
Word : This
Word : is

toString（）： JAVA伊奥。StreamTokenizer。toString（） 将当前流标记表示为字符串及其行号。 语法：

public String toString()
Return :
represents current Stream token as a string along with it's line no.

实施：

                       // Java Program  illustrating use of toString() method                     
                                
                       import                                  java.io.*;                     
                       public                                  class                                  NewClass                     
                       {                     
                                             public                                  static                                  void                                  main(String[] args)                                  throws                                  InterruptedException,                     
                                             FileNotFoundException, IOException                     
                                             {                     
                                             FileReader reader =                                  new                                  FileReader(                                  "ABC.txt"                                  );                     
                                             BufferedReader bufferread =                                  new                                  BufferedReader(reader);                     
                                             StreamTokenizer token =                                  new                                  StreamTokenizer(bufferread);                     
                                
                                             int                                  t;                     
                                             while                                  ((t = token.nextToken()) != StreamTokenizer.TT_EOF)                     
                                             {                     
                                             switch                                  (t)                     
                                             {                     
                                             case                                  StreamTokenizer.TT_NUMBER:                     
                                             // Value of ttype field returned by nextToken()                     
                                             System.out.println(                                  "Number : "                                  + token.nval);                     
                                             break                                  ;                     
                                             // Value of ttype field returned by nextToken()                     
                                             case                                  StreamTokenizer.TT_WORD:                     
                                
                                             // Use of toStringn() method                     
                                             System.out.println(                                  "Word : "                                  + token.toString());                     
                                             break                                  ;                     
                                             }                     
                                             }                     
                                             }                     
                       }                     

输出：

Word : Token[Programmers], line 1
Number : 1.0
Number : 2.0
Number : 3.0
Word : Token[Geeks], line 5
Word : Token[Hello], line 6
Word : Token[a], line 7
Word : Token[Program], line 7
Word : Token[is], line 7
Word : Token[explained], line 7
Word : Token[here], line 7
Word : Token[my], line 7
Word : Token[friends.], line 7

e重要性（） JAVA伊奥。StreamTokenizer。EOL重要性（布尔参数） 说明是否将行尾视为标记。如果“arg”为真，那么它的行尾将被视为一个标记。如果为true，则该方法返回TT_EOL，并在到达行尾时设置ttype字段。如果“arg”为false，那么行尾将被简单地视为空白。 语法：

public void eolIsSignificant(boolean arg)
Parameters :
arg : boolean which tells whether to take EOL as a token or white space
Return :
No value is returned.

实施：

                       // Java Program  illustrating use of eolIsSignificant() method                     
                                
                       import                                  java.io.*;                     
                       public                                  class                                  NewClass                     
                       {                     
                                             public                                  static                                  void                                  main(String[] args)                                  throws                                  InterruptedException,                     
                                             FileNotFoundException, IOException                     
                                             {                     
                                             FileReader reader =                                  new                                  FileReader(                                  "ABC.txt"                                  );                     
                                             BufferedReader bufferread =                                  new                                  BufferedReader(reader);                     
                                             StreamTokenizer token =                                  new                                  StreamTokenizer(bufferread);                     
                                
                                             boolean                                  arg =                                  true                                  ;                     
                                             // Use of eolIsSignificant() method                     
                                             token.eolIsSignificant(arg);                     
                                             // Here the 'arg' is set true, so EOL is treated as a token                     
                                
                                             int                                  t;                     
                                             while                                  ((t = token.nextToken()) != StreamTokenizer.TT_EOF)                     
                                             {                     
                                             switch                                  (t)                     
                                             {                     
                                             case                                  StreamTokenizer.TT_EOL:                     
                                             System.out.println(                                  "End of Line encountered."                                  );                     
                                             break                                  ;                     
                                             case                                  StreamTokenizer.TT_NUMBER:                     
                                             System.out.println(                                  "Number : "                                  + token.nval);                     
                                             break                                  ;                     
                                             case                                  StreamTokenizer.TT_WORD:                     
                                             System.out.println(                                  "Word : "                                  + token.sval);                     
                                             break                                  ;                     
                                
                                             }                     
                                             }                     
                                             }                     
                       }                     

1. 极客 2. 对于 3. 极客

输出：

Number : 1.0
End of Line encountered.
Word : Geeks
End of Line encountered.
Number : 2.0
End of Line encountered.
Word : For
End of Line encountered.
Number : 3.0
End of Line encountered.
Word : Geeks

nextToken（）： JAVA伊奥。StreamTokenizer。nextToken（） 解析输入流中的下一个令牌，并将其值与其他字段（如“sval”、“nval”）一起返回到ttype字段。 语法：

public int nextToken()
Parameters :
------
Return :
value to the ttype field

实施：

                       // Java Program  illustrating use of nextToken() method                     
                                
                       import                                  java.io.*;                     
                       public                                  class                                  NewClass                     
                       {                     
                                             public                                  static                                  void                                  main(String[] args)                                  throws                                  InterruptedException,                     
                                             FileNotFoundException, IOException                     
                                             {                     
                                             FileReader reader =                                  new                                  FileReader(                                  "ABC.txt"                                  );                     
                                             BufferedReader bufferread =                                  new                                  BufferedReader(reader);                     
                                             StreamTokenizer token =                                  new                                  StreamTokenizer(bufferread);                     
                                
                                             // Use of nextToken() method to parse Next Token from the Input Stream                     
                                             int                                  t = token.nextToken();                     
                                             while                                  ((t = token.nextToken()) != StreamTokenizer.TT_EOF)                     
                                             {                     
                                             switch                                  (t)                     
                                             {                     
                                             case                                  StreamTokenizer.TT_NUMBER:                     
                                             System.out.println(                                  "Number : "                                  + token.nval);                     
                                             break                                  ;                     
                                             case                                  StreamTokenizer.TT_WORD:                     
                                             System.out.println(                                  "Word : "                                  + token.sval);                     
                                             break                                  ;                     
                                
                                             }                     
                                             }                     
                                             }                     
                       }                     

1. 这个节目告诉我们 2. 关于使用 3. next token（）方法

输出：

Word : This
Word : program
Word : tells
Number : 2.0
Word : about
Word : use
Word : of
Number : 3.0
Word : next
Word : token
Word : method

小写符号（）： JAVA伊奥。StreamTokenizer。小写符号（布尔参数） 指示是否自动将单词标记小写。如果标志–“arg”设置为真，则“sval”字段的值将降低。 语法：

public void lowerCaseMode(boolean arg)
Parameters :
arg : indicates whether to lowercase the word tokens automatically or not
Return :
void

实施：

                       // Java Program  illustrating use of lowerCaseMode() method                     
                                
                       import                                  java.io.*;                     
                       public                                  class                                  NewClass                     
                       {                     
                                             public                                  static                                  void                                  main(String[] args)                                  throws                                  InterruptedException,                     
                                             FileNotFoundException, IOException                     
                                             {                     
                                             FileReader reader =                                  new                                  FileReader(                                  "ABC.txt"                                  );                     
                                             BufferedReader bufferread =                                  new                                  BufferedReader(reader);                     
                                             StreamTokenizer token =                                  new                                  StreamTokenizer(bufferread);                     
                                
                                             /* Use of lowerCaseMode() method to                     
                                             Here, the we have set the Lower Case Mode ON                     
                                             */                     
                                             boolean                                  arg =                                  true                                  ;                     
                                             token.lowerCaseMode(arg);                     
                                
                                             int                                  t;                     
                                             while                                  ((t = token.nextToken()) != StreamTokenizer.TT_EOF)                     
                                             {                     
                                             switch                                  (t)                     
                                             {                     
                                             case                                  StreamTokenizer.TT_NUMBER:                     
                                             System.out.println(                                  "Number : "                                  + token.nval);                     
                                             break                                  ;                     
                                             case                                  StreamTokenizer.TT_WORD:                     
                                             System.out.println(                                  "Word : "                                  + token.sval);                     
                                             break                                  ;                     
                                
                                             }                     
                                             }                     
                                             }                     
                       }                     

你好，极客们这是关于小写符号（）

输出：

Word : hello
Word : geeks
Word : this
Word : is
Word : about
Word : lowercasemode

ordinaryChar（）： JAVA伊奥。StreamTokenizer。普通字符（int arg） 将“arg”字符设置为普通字符。如果arg字符作为单词、数字、空格或注释字符有任何意义，它将删除arg字符。 语法：

public void ordinaryChar(int arg)
Parameters :
arg : the character which is to be set as an Ordinary Character
Return :
void

实施：

                       // Java Program  illustrating use of ordinaryChar() method                     
                                
                       import                                  java.io.*;                     
                       public                                  class                                  NewClass                     
                       {                     
                                             public                                  static                                  void                                  main(String[] args)                                  throws                                  InterruptedException,                     
                                             FileNotFoundException, IOException                     
                                             {                     
                                             FileReader reader =                                  new                                  FileReader(                                  "ABC.txt"                                  );                     
                                             BufferedReader bufferread =                                  new                                  BufferedReader(reader);                     
                                             StreamTokenizer token =                                  new                                  StreamTokenizer(bufferread);                     
                                
                                             // Use of ordinaryChar() method                     
                                             // Here we have taken 's' as an ordinary character                     
                                             token.ordinaryChar(                                  's'                                  );                     
                                
                                             int                                  t;                     
                                             while                                  ((t = token.nextToken()) != StreamTokenizer.TT_EOF)                     
                                             {                     
                                             switch                                  (t)                     
                                             {                     
                                             case                                  StreamTokenizer.TT_NUMBER:                     
                                             System.out.println(                                  "Number : "                                  + token.nval);                     
                                             break                                  ;                     
                                             case                                  StreamTokenizer.TT_WORD:                     
                                             System.out.println(                                  "Word : "                                  + token.sval);                     
                                             break                                  ;                     
                                
                                             }                     
                                             }                     
                                             }                     
                       }                     

你好，极客们这是关于普通字符（）

此方法已从整个流中删除’s’

输出：

Word : Hello
Word : Geek
Word : Thi
Word : I
Word : zz
Word : About
Word : ordinaryChar

普通字符（）： JAVA伊奥。StreamTokenizer。普通字符（整数低，整数高） 在StreamTokenizer中将“a到b”范围内的字符设置为普通字符 语法：

public void ordinaryChars(int low, int high)
Parameters :
low : lower limit of range
high : higher limit of range
Return :
void

实施：

                       // Java Program  illustrating use of ordinaryChars() method                     
                                
                       import                                  java.io.*;                     
                       public                                  class                                  NewClass                     
                       {                     
                                             public                                  static                                  void                                  main(String[] args)                                  throws                                  InterruptedException,                     
                                             FileNotFoundException, IOException                     
                                             {                     
                                             FileReader reader =                                  new                                  FileReader(                                  "ABC.txt"                                  );                     
                                             BufferedReader bufferread =                                  new                                  BufferedReader(reader);                     
                                             StreamTokenizer token =                                  new                                  StreamTokenizer(bufferread);                     
                                
                                             // Use of ordinaryChars() method                     
                                             // Here we have taken low = 'a' and high = 'c'                     
                                             token.ordinaryChars(                                  'a'                                  ,                                  'c'                                  );                     
                                
                                             int                                  t;                     
                                             while                                  ((t = token.nextToken()) != StreamTokenizer.TT_EOF)                     
                                             {                     
                                             switch                                  (t)                     
                                             {                     
                                             case                                  StreamTokenizer.TT_NUMBER:                     
                                             System.out.println(                                  "Number : "                                  + token.nval);                     
                                             break                                  ;                     
                                             case                                  StreamTokenizer.TT_WORD:                     
                                             System.out.println(                                  "Word : "                                  + token.sval);                     
                                             break                                  ;                     
                                
                                             }                     
                                             }                     
                                             }                     
                       }                     

你好，极客们这是关于普通字符（）

输出：

Word : Hello
Word : Geeks
Word : This
Word : is
Word : out
Word : ordin
Word : ryCh
Word : rs

下一篇文章 – JAVA伊奥。Java |集合2中的StreamTokenizer类本文由 莫希特·古普塔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java