1. Clase BufferedReader
. Biblioteca de clases:
java.lang.object
java.io.reader
java.io.bufferedreader
. Conceptos básicos:
BufferedReader de clase pública extiende el lector
Lea el texto del flujo de entrada de caracteres y buffer caracteres individuales, lo que permite una lectura eficiente de caracteres, matrices y líneas. Puede especificar el tamaño del búfer, o se puede usar el tamaño predeterminado. En la mayoría de los casos, el valor predeterminado es lo suficientemente grande.
Por lo general, cada solicitud de lectura realizada por un lector da como resultado una solicitud de lectura correspondiente para el carácter subyacente o la secuencia de bytes. Por lo tanto, se recomienda envolver a todos los lectores cuyas operaciones Read () pueden ser costosas (como FileReader e InputStreamReader) con BufferedReader.
La transmisión de BufferedReader puede leer líneas de texto y crea un objeto BufferedReader al pasar un objeto lector al BufferedReader. Esto se debe a que FileReader no proporciona la función de leer líneas de texto.
. Manifestación:
Capture la declaración ingresada a través del BufferedReader:
import java.io.*; class BufferedReaderDemo {public static void main (string [] args) lanza ioexception {bufferedReader bufferedReader = new BufferedReader (new InputStreamReader (System.in)); System.out.print ("Ingrese una serie de texto, que puede incluir espacios:"); String text = bufferedReader.readline (); System.out.println ("Ingrese el texto:"+texto); }}anotación:
lanza ioexception lanza excepción
InputStreamReader es el puente entre el flujo de bytes y el flujo de caracteres
2. Clase de InputStreamReader
InputStreamReader convierte una secuencia de byte en una secuencia de caracteres. Es el puente entre el flujo de bytes y el flujo de caracteres. Si no se especifica la codificación del conjunto de caracteres, el proceso de decodificación utilizará la codificación de caracteres predeterminada de la plataforma, como: GBK.
Método de construcción:
InputStreamReader isr = new InputStreamReader (InputStream in); // Construye una clase InputStreamReader con el conjunto de codificación predeterminado
InputStreamReader isr = new InputStreamReader (inputStream in, string charsetName); // construir un conjunto de codificación especificado
Clase InputStreamReader.
El parámetro en el objeto se obtiene por InputStream in = System.in;. // Leer datos en el teclado.
O InputStream in = new FileInputStream (String FileName); // Lea los datos en el archivo. Se puede ver que FileInputStream es una subclase de InputStream.
Método principal: int read (); // leer un solo carácter.
int read (char [] cbuf); // Guardar los caracteres de lectura en la matriz. Devuelve el número de caracteres leídos.
. Manifestación:
import java.io.*; class inputStreamReaderDemo {public static void transadNobuf () lanza ioexception { /*** No hay búfer, solo puede usar el método Read (). */// Leer Byte Stream // InputStream in = System.in; // Leer entrada del teclado. InputStream in = new FileInputStream ("d: //demo.txt"); // Lea los datos del archivo. // Conversión de bytes que fluyen a la corriente de personajes. Para habilitar una conversión efectiva de bytes a personajes, // puede leer más bytes de la transmisión subyacente con anticipación. InputStreamReader isr = new InputStreamReader (in); // lea // Completo en una oración. // InputStreamReader isr = new InputStreamReader (// new FileInputStream ("d: //demo.txt")); char [] cha = nuevo char [1024]; int len = isr.Read (cha); System.out.println (nueva cadena (cha, 0, len)); isr.close (); } public static void transreadByBuf () lanza IOException { /*** Use buffers para usar los métodos Read () y Readline () del objeto de búfer. */// Leer Byte Stream // InputStream in = System.in; // Leer datos en el teclado InputStream in = new FileInputStream ("d: //demo.txt"); // Leer datos en el archivo. // Conversión de bytes que fluyen a la corriente de personajes. InputStreamReader isr = new InputStreamReader (in); // Read // Crear transmisión de caracteres BufferedReader bufr = new BufferedReader (ISR); // buffered // bufferedReader bufr = new BufferedReader (// new InputStreamReader (nuevo FileInputStream ("D: //demo.txt")); se puede combinar en una oración. /*int ch = 0; ch = bufr.read (); System.out.println ((char) ch); */ Línea de cadena; while ((línea = bufr.readline ())! = null) {system.out.println (línea); } isr.close (); }}3. Casos reales de InputStreamReader y BufferedReader (conjunto no codificado)
import java.io.*; class UtilResource {private void inicializeSource () {try {// lea el archivo y escríbelo en el formulario UTF-8 BufferedReader Bufread; Cadena leer; bufread = new BufferedReader (new InputStreamReader (ResourceHelper .GetResourceInputStream ("Pinyin.txt"))); while ((read = bufread.readline ())! = null) {system.out.println (read); } bufread.close (); } catch (FileNotFoundException ex) {Ex.PrintStackTrace (); } catch (ioException ex) {ex.printstackTrace (); }}}Nota: Pinyin.txt se coloca en el directorio raíz del proyecto
import java.io.bufferedInputStream; import java.io.fileInputStream; import java.io.filenotFoundException; class ResourceHelper { / ** * @param resuran ResourCeName * @Return * @Return * / Static BuffeDinputPutPutReMeurceInputStream (String Resource) FileInputStream (ResourceName)); } Catch (FileNotFoundException e) {// TODO Auto Generado Bloque E.PrintStackTrace (); } return null; }}Resumir:
Clase de InputStreamReader
Es el puente entre el flujo de bytes y el flujo de caracteres, encerrando el InputStream en el interior. Lee caracteres uno por uno a la vez en un nivel superior, entradas/salidas en formato de texto, y puede especificar el formato de codificación;
Clase de litigante buffered
BufferedReader se extiende por la clase de lector, proporciona una lectura de texto en buffado general, y proporciona una línea de lectura muy práctica, que lee una línea de texto, lee texto de un flujo de entrada de caracteres y amortigua cada carácter, proporcionando así una lectura eficiente de caracteres, matrices y líneas.
PS: La relación entre InputStream, InputStreamReader y Reader
InputStream: El resultado es la secuencia de entrada de bytes. Después de inputStream.read ("nombre de archivo"), el resultado es la secuencia de bytes.
Lector: leer una transmisión de personajes
InputStreamReader: un puente de bytes a caracteres. InputStreamReader (inputStream.Read ("FileName"));
lector.read (inputStreamReader (inputStream in)); se puede cambiar de byte a carácter, e impreso y mostrado.
java.io.reader y java.io.inputstream forman la clase de entrada Java.
El lector se usa para leer caracteres de 16 bits, es decir, caracteres codificados por Unicode; mientras que InputStream se usa para leer caracteres ASCII y datos binarios.
El lector admite la salida de caracteres Unicode de 16 bits, y InputStream admite la salida de caracteres de 8 bits.
El lector y la entrada de entrada son dos conjuntos de mecanismos de nivel paralelo e independiente proporcionados por la biblioteca de E/S, respectivamente. 1byte = 8bits InputStream y OutputStream se utilizan para procesar las secuencias de 8 bits, y el lector y el escritor se utilizan para procesar las transmisiones de 16 bits.
En el idioma Java, el tipo de byte es de 8 bits y el tipo de char es de 16 bits, por lo que debe usar el lector y el escritor cuando procese chino.
Vale la pena señalar que, bajo estos dos niveles de mecanismos, también hay un puente InputStreamReader y OutputStreamWriter, que es responsable de la adaptación de InputStream al lector y la adaptación de OutputStream to Writer.
En Java, hay diferentes tipos de secuencias de entrada de lector que corresponden a diferentes fuentes de datos:
FileReader se usa para ingresar desde un archivo; CharArrayReader se usa para ingresar desde una matriz de caracteres en el programa; StringReader se usa para ingresar desde una cadena en el programa; PipeDreader se usa para leer datos escritos en la tubería de un PipeedWriter en otro hilo.
También hay diferentes tipos de flujos de entrada de InputStream correspondientes a diferentes fuentes de datos: FileInputStream, BytearrayInputStream, StringBufferInputStream, PipeDInputStream.
Además, hay dos secuencias de entrada de InputStream que no tienen un tipo de lector correspondiente: Socket se usa para enchufes; UrlConnection se usa para conexiones de URL. Estas dos clases usan getInputStream () para leer los datos.
En consecuencia, existen diferencias similares entre java.io.writer y java.io.outputstream.
Con respecto a InputStream.Read (Byte [] b) y InputStream.Read (Byte [] B, int Off, int Len) ambos métodos se utilizan para leer múltiples bytes de una secuencia. Los programadores experimentados encontrarán que estos dos métodos a menudo no pueden leer el número de bytes que desean leer. Por ejemplo, en el primer método, los programadores a menudo esperan que el programa pueda leer B. Longitud Bytes, pero la situación real es que el sistema a menudo no puede leer tantos. Después de leer cuidadosamente las instrucciones de la API de Java, encontrará que este método no garantiza que pueda leer tantos bytes, solo puede garantizar que pueda leer hasta tantos bytes (al menos 1). Por lo tanto, si desea que el programa lea bytes de conteo, es mejor usar el siguiente código:
byte [] b = nuevo byte [cuenta]; int readCount = 0; // El número de bytes que se han leído con éxito mientras (ReadCount <Count) {ReadCount += in.read (bytes, ReadCount, Count - ReadCount); } Este código puede garantizar que se lean los bytes de conteo a menos que se encuentre una excepción de IO en el medio o en el final del flujo de datos (EOFException)