1. Classe BufferredReader
. Biblioteca de classe:
java.lang.Object
java.io.Reader
Java.io.BufferedReader
. Conceitos básicos:
A classe pública BufferredReader estende o leitor
Leia o texto a partir do fluxo de entrada do caractere e buffer caracteres individuais, permitindo a leitura eficiente de caracteres, matrizes e linhas. Você pode especificar o tamanho do buffer ou o tamanho padrão pode ser usado. Na maioria dos casos, o valor padrão é grande o suficiente.
Normalmente, cada solicitação de leitura feita por um leitor resulta em uma solicitação de leitura correspondente para o caractere subjacente ou fluxo de bytes. Portanto, é recomendável envolver todos os leitores cujas operações de leitura () podem ser caras (como FileReader e InputStreamReader) com o BufferredReader.
O BufferEredReader Stream é capaz de ler linhas de texto e cria um objeto BufferredReader, passando um objeto de leitor para o BufferredReader. Isso ocorre porque o FileReader não fornece a função de ler linhas de texto.
. Demonstração:
Capture a declaração inserida através do BufferredReader:
importar java.io. System.out.print ("Por favor, insira uma série de texto, que pode incluir espaços:"); Text string = bufferredreader.readline (); System.out.println ("Por favor, digite o texto:"+texto); }}anotação:
lança ioexception lança exceção
InputStreamReader é a ponte entre o fluxo de bytes e o fluxo de caracteres
2. Classe InputStreamReader
InputStreamReader converte um fluxo de bytes em um fluxo de caracteres. É a ponte entre o fluxo de bytes e o fluxo de caracteres. Se a codificação do conjunto de caracteres não for especificada, o processo de decodificação usará a codificação de caracteres padrão da plataforma, como: GBK.
Método de construção:
InputStreamReader isr = new InputStreamReader (inputStream in); // Construa uma classe InputStreamReader com o conjunto de codificação padrão
InputStreamReader isr = new InputStreamReader (inputStream in, string charsetName); // Construa um conjunto de codificação especificado
Classe InputStreamReader.
O parâmetro no objeto é obtido pelo InputStream in = System.in;. // Leia dados no teclado.
Ou inputStream in = new FileInputStream (String filename); // Leia os dados no arquivo. Pode -se observar que o FileInputStream é uma subclasse do InputStream.
Método principal: int read (); // Leia um único caractere.
int read (char [] cbuf); // salve os caracteres de leitura na matriz. Retorna o número de caracteres lidos.
. Demonstração:
importar java.io. */// Leia o fluxo de bytes // inputStream in = System.in; // Leia a entrada do teclado. InputStream in = new FileInputStream ("d: //demo.txt"); // Leia os dados do arquivo. // Conversão de bytes fluidos em fluxo de caracteres. Para permitir a conversão eficaz de bytes em caracteres, // você pode ler mais bytes do fluxo subjacente com antecedência. InputStreamReader isr = new InputStreamReader (in); // leia // abrangente em uma frase. // inputStreamReader isr = new InputStreamReader (// new FileInputStream ("d: //demo.txt")); char [] cha = novo char [1024]; int len = isr.read (cha); System.out.println (new String (Cha, 0, Len)); isr.close (); } public static void transRreadByBuf () lança IoException { /*** Use buffers para usar os métodos read () e readLine () do objeto buffer. */// Leia o fluxo de bytes // inputStream in = System.in; // Leia os dados no teclado inputStream em = new FileInputStream ("d: //demo.txt"); // Leia dados no arquivo. // Conversão de bytes fluidos em fluxo de caracteres. InputStreamReader isr = new InputStreamReader (in); // leia // Crie o BufferReader buffer de buffer de fluxo de caracteres BUFR = new BufferredReader (ISR); // buffer // buffaredreader bufr = new buffarredreader (// new inputStreamReader (new FileInputStream ("D: //demo.txt)")) pode ser combinado em uma frase. /*int ch = 0; ch = bufr.read (); System.out.println ((char) ch); */ Linha de sequência; while ((line = bufr.readline ())! = null) {System.out.println (line); } isr.close (); }}3. Casos reais de InputStreamReader e BufferredReader (conjunto não codificado)
importar java.io. String leia; bufread = new BufferredReader (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 é colocado no diretório raiz do projeto
importar java.io.BufferEnDitStream; importar java.io.fileInputStream; importar java.io.fileNotfoundException; classe ResourceHelper { / ** * @param ResourceInMetream * @return * @return * / static -bufferInpTream GetResourceEnName (StringTream (StringCename) FileInputStream (nome do nome)); } catch (fileNotfoundException e) {// TODO BLOCO DE CATAGEM AUTOMENTADO E.PRINTSTACKTRACE (); } retornar nulo; }}Resumir:
Classe InputStreamReader
É a ponte entre o fluxo de bytes e o fluxo de caracteres, envolvendo o InsputStream dentro. Ele lê os caracteres um por um de cada vez em um nível superior, entradas/saídas no formato de texto e pode especificar o formato de codificação;
Classe BufferredReader
O BufferErader é estendido pela classe do leitor, fornecendo uma leitura geral de texto em buffer e fornece uma linha de leitura muito prática, que lê uma linha de texto, lê texto a partir de um fluxo de entrada de caracteres e buffer cada caractere, fornecendo leitura eficiente de caracteres, matrizes e linhas.
PS: A relação entre InputStream, InputStreamReader e leitor
InputStream: o resultado é o fluxo de entrada de bytes. Após o InputStream.read ("nome do arquivo"), o resultado é o fluxo de bytes.
Leitor: Lendo um fluxo de personagens
InputStreamReader: uma ponte de bytes para caracteres. InputStreamReader (inputStream.read ("nome do arquivo"));
leitor.read (inputStreamReader (inputStream in)); pode ser alterado de byte para personagem e impresso e exibido.
java.io.reader e java.io.inputStream formam a classe de entrada java.
O leitor é usado para ler caracteres de 16 bits, ou seja, caracteres codificados por unicode; Enquanto o InputStream é usado para ler caracteres ASCII e dados binários.
O leitor suporta a saída de caractere Unicode de 16 bits e o InputStream suporta saída de caracteres de 8 bits.
O leitor e o InputStream são dois conjuntos de mecanismos de nível paralelo e independente fornecidos pela biblioteca de E/S, respectivamente. 1byte = 8bits inputStream e outputStream são usados para processar fluxos de 8 bits, e o leitor e escritor são usados para processar fluxos de 16 bits.
No idioma Java, o tipo de byte é de 8 bits e o tipo de char é de 16 bits, então você precisa usar o leitor e o escritor ao processar chinês.
Vale a pena notar que, nesses dois níveis de mecanismos, também há um Bridge InputStreamReader e o OutputStreamWriter, responsável pela adaptação do InputStream ao leitor e pela adaptação do OutputStream ao Writer.
Em Java, existem diferentes tipos de fluxos de entrada do leitor que correspondem a diferentes fontes de dados:
O FileReader é usado para inserção de um arquivo; CharArrayReader é usado para inserir uma matriz de caracteres no programa; StringReader é usado para inserção de uma string no programa; O PipedReader é usado para leitura de dados gravados no pipeline de um escritor de tubulação em outro thread.
Existem também diferentes tipos de fluxos de entrada de entrada de entrada correspondentes a diferentes fontes de dados: FILEInputStream, byteArrayInputStream, StringBufferInputStream, PipedInputStream.
Além disso, existem dois fluxos de entrada de entrada de entrada que não possuem um tipo de leitor correspondente: o soquete é usado para soquetes; O URLConnection é usado para conexões de URL. Essas duas classes usam getInputStream () para ler os dados.
Da mesma forma, existem diferenças semelhantes entre Java.io.writer e java.io.outputStream.
Em relação ao InputStream.read (byte [] b) e inputstream.read (byte [] b, int off, int len) Ambos os métodos são usados para ler vários bytes de um fluxo. Programadores experientes descobrirão que esses dois métodos geralmente não podem ler o número de bytes que desejam ler. Por exemplo, no primeiro método, os programadores geralmente esperam que o programa possa ler B.Length Bytes, mas a situação real é que o sistema geralmente não pode ler tantos. Depois de ler cuidadosamente as instruções da API Java, você descobrirá que esse método não garante que ele possa ler tantos bytes, só pode garantir que ele possa ler até tantos bytes (pelo menos 1). Portanto, se você deseja que o programa leia a Count Bytes, é melhor usar o seguinte código:
byte [] b = novo byte [contagem]; int readCount = 0; // o número de bytes que foram lidos com sucesso (readcount <count) {readCount += in.read (bytes, readCount, count - readCount); } Este código pode garantir que a contagem de bytes seja lida, a menos que uma exceção de IO seja encontrada no meio ou no final do fluxo de dados (eofexception)