Clase Java.io.StreamTokenizer en Java | Serie 1

La clase Java.io.StreamTokenizer analiza el flujo de entrada en «tokens». Permite leer un token a la vez. Stream Tokenizer puede reconocer números, strings entrecomilladas y varios estilos de comentarios.
Declaración :

public class StreamTokenizer
  extends Object

Constructor:
StreamTokenizer(Reader arg): crea un tokenizador que analiza el flujo de caracteres dado.

Métodos :

comentarioChar:

java.io.StreamTokenizer.commentChar(int arg) ignora todos los caracteres desde el carácter de comentario de una sola línea hasta el final de la línea por este StreamTokenizer.
Sintaxis:

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

Implementación:

// 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;
  
            }
        }
    }
}

Nota:
este programa no se ejecutará aquí ya que no existe un archivo ‘ABC’. Puede verificar este código en el compilador de Java en su sistema.
Para verificar este código, cree un archivo ‘ABC’ en su sistema.
El archivo ‘ABC’ contiene:

Programadores
1
2
3
Frikis
Hola
aqui se explica un programa mis amigos.

Producción:

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

lineno() : java.io.StreamTokenizer.lineno() devuelve el número de línea actual de este StreamTokenizer.
Sintaxis:

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.

Implementación:

// 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;
  
            }
        }
    }
}

Producción:

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.io.StreamTokenizer.toString() representa el token Stream actual como una string junto con su línea no.
Sintaxis:

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

Implementación:

// 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;
             }
        }
    }
}

Producción:

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

eolIsSignificant() : java.io.StreamTokenizer.eolIsSignificant(boolean arg) indica si tratar el final de la línea como un token o no. Si ‘arg’ es verdadero, entonces End Of Line se trata como un token. Si es verdadero, el método devuelve TT_EOL y establece el campo ttype cuando se alcanza el final de la línea.
Si ‘arg’ es falso, el final de línea se trata simplemente como un espacio en blanco.
Sintaxis:

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.

Implementación:

// 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
frikis
2
para
3
frikis

Producción :

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.io.StreamTokenizer.nextToken() analiza el siguiente token del Input Stream y devuelve su valor al campo ttype junto con los campos adicionales como ‘sval’, ‘nval’.
Sintaxis:

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

Implementación:

// 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
Este programa informa
2
sobre el uso del método
3
next token()

Producción :

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

lowerCaseMode() : java.io.StreamTokenizer.lowerCaseMode(boolean arg) indica si se deben escribir en minúsculas los tokens de palabras automáticamente o no. Si el indicador – ‘arg’ se establece como verdadero, entonces se reduce el valor del campo ‘sval’.
Sintaxis:

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

Implementación:

// 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;
  
            }
        }
    }
}

Hola geeks ,
se trata de
LowerCaseMode()

Producción :

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

ordinaryChar() : java.io.StreamTokenizer.ordinaryChar(int arg) establece el carácter ‘arg’ como un carácter ordinario. Eliminará el carácter arg, si tiene algún significado como palabra, número, espacio en blanco o carácter de comentario.
Sintaxis:

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

Implementación:

// 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;
  
            }
        }
    }
}

Hola Geeks
Estosss Issszz Acerca deordinaryChar
()

Este método ha eliminado ‘s’ de todo el Stream

Producción :

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

ordinaryChars() : java.io.StreamTokenizer.ordinaryChars(int low, int high) establece el carácter en el rango – ‘a a b’ al carácter Ordinario en StreamTokenizer
Sintaxis:

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

Implementación:

// 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;
  
            }
        }
    }
}

Hola Geeks
Esto
es
sobre
los caracteres ordinarios()

Producción :

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

Artículo siguiente – Clase Java.io.StreamTokenizer en Java | Conjunto 2

Este artículo es una contribución de Mohit Gupta 🙂 . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta