¿Cómo leo la entrada carácter por carácter en Java?

Question

Estoy acostumbrado al getchar () estilo c, pero parece que no hay nada comparable para Java. Estoy creando un analizador léxico y necesito leer el carácter de entrada por carácter.

Sé que puedo usar el escáner para escanear un token o línea y analizar el token char-by-char, pero eso parece difícil de manejar para cadenas que abarcan varias líneas. ¿Hay alguna forma de obtener el siguiente carácter del búfer de entrada en Java, o debería simplemente conectarme con la clase Scanner?

La entrada es un archivo, no el teclado.

Answer 1

Utilice Reader.read () . Un valor de retorno de -1 significa final de flujo; de lo contrario, lance a char .

Este código lee datos de caracteres de una lista de argumentos de archivo:

public class CharacterHandler {
    //Java 7 source level
    public static void main(String[] args) throws IOException {
        // replace this with a known encoding if possible
        Charset encoding = Charset.defaultCharset();
        for (String filename : args) {
            File file = new File(filename);
            handleFile(file, encoding);
        }
    }

    private static void handleFile(File file, Charset encoding)
            throws IOException {
        try (InputStream in = new FileInputStream(file);
             Reader reader = new InputStreamReader(in, encoding);
             // buffer for efficiency
             Reader buffer = new BufferedReader(reader)) {
            handleCharacters(buffer);
        }
    }

    private static void handleCharacters(Reader reader)
            throws IOException {
        int r;
        while ((r = reader.read()) != -1) {
            char ch = (char) r;
            System.out.println("Do something with " + ch);
        }
    }
}

Lo malo del código anterior es que utiliza el conjunto de caracteres predeterminado del sistema. Siempre que sea posible, prefiera una codificación conocida (idealmente, una codificación Unicode si tiene una opción). Consulte la clase Charset para obtener más información. (Si te parece masoquista, puedes leer esta guía para la codificación de caracteres .)

(Una cosa que quizás desee tener en cuenta son los caracteres Unicode suplementarios, aquellos que requieren dos valores de caracteres para almacenarlos. Consulte Clase de personaje para obtener más detalles; este es un caso extremo que probablemente no se aplicará a la tarea.)

Answer 2

Combinando las recomendaciones de otros para especificar una codificación de caracteres y almacenar en búfer la entrada, esto es lo que creo que es una respuesta bastante completa.

Suponiendo que tiene un objeto File que representa el archivo que desea leer:

BufferedReader reader = new BufferedReader(
    new InputStreamReader(
        new FileInputStream(file),
        Charset.forName("UTF-8")));
int c;
while((c = reader.read()) != -1) {
  char character = (char) c;
  // Do something with your character
}

Answer 3

Otra opción es no leer las cosas carácter por carácter: lea todo el archivo en la memoria. Esto es útil si necesitas mirar a los personajes más de una vez. Una forma trivial de hacerlo es:

  /** Read the contents of a file into a string buffer      */
    public static void readFile(File file, StringBuffer buf)
        throws IOException
    {
    FileReader fr = null;
    try {
      fr = new FileReader(file);
      BufferedReader br = new BufferedReader(fr);
      char[] cbuf = new char[(int) file.length()];
      br.read(cbuf);  
      buf.append(cbuf);
      br.close();
    }
    finally {
      if (fr != null) {
        fr.close();
      }
    }
}

Answer 4

Envuelva su flujo de entrada en un lector con búfer y luego use el método de lectura para leer un byte a la vez hasta el final del flujo.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Reader {

    public static void main(String[] args) throws IOException {

        BufferedReader buffer = new BufferedReader(
                 new InputStreamReader(System.in));
        int c = 0;
        while((c = buffer.read()) != -1) {
            char character = (char) c;          
            System.out.println(character);          
        }       
    }   
}

Answer 5

Si fuera usted, simplemente usaría un escáner y usaría " .nextByte () " ;. Puedes lanzar eso a un char y eres bueno.

Answer 6

Tiene varias opciones si usa BufferedReader . Este lector almacenado en búfer es más rápido que Reader, por lo que puede envolverlo.

BufferedReader reader = new BufferedReader(new FileReader(path));
reader.read(char[] buffer);

esto lee la línea en la matriz de caracteres. Tienes opciones similares. Mira la documentación.

Answer 7

Envuelva su lector en un BufferedReader , que mantiene un búfer que permite lecturas en general mucho más rápidas. Luego puede usar read () para leer un solo carácter (que deberá emitir). También puede usar readLine () para obtener una línea completa y luego dividirla en caracteres individuales. El BufferedReader también admite el marcado y la devolución, por lo que si lo necesita, puede leer una línea varias veces.

En términos generales, desea utilizar un BufferedReader o BufferedInputStream  en la parte superior de cualquier flujo que esté utilizando, ya que el búfer que mantienen hará que las lecturas sean mucho más rápidas.

Answer 8

En java 5 se agregó una nueva función que es el método de escáner que brinda la oportunidad de leer el carácter de entrada por carácter en java.

por ejemplo; para uso Método de escáner import java.util.Scanner; después en el método principal: definir

Escáner myScanner = nuevo escáner (System.in); // para leer caracteres

char anything = myScanner.findInLine (". "). charAt (0);

cualquier cosa almacena un solo carácter, si desea más, lea más el carácter declare más objetos como cualquier cosa1, cualquier cosa2 ... más ejemplos para su respuesta, por favor verifique en su mano (copiar / pegar)

     import java.util.Scanner;
     class ReverseWord  {

    public static void main(String args[]){
    Scanner myScanner=new Scanner(System.in);
    char c1,c2,c3,c4;

    c1 = myScanner.findInLine(".").charAt(0);
        c2 = myScanner.findInLine(".").charAt(0);
    c3 = myScanner.findInLine(".").charAt(0);
    c4 = myScanner.findInLine(".").charAt(0);

    System.out.print(c4);
    System.out.print(c3);
    System.out.print(c2);
    System.out.print(c1);
    System.out.println();

   }
  }

Answer 9

Esto imprimirá 1 carácter por línea desde el archivo.

    try {

        FileInputStream inputStream = new FileInputStream(theFile);
        while (inputStream.available() > 0) {
            inputData = inputStream.read();
            System.out.println((char) inputData);

        }
        inputStream.close();
    } catch (IOException ioe) {
        System.out.println("Trouble reading from the file: " + ioe.getMessage());
    }