As funções de entrada e saída da linguagem Java são muito poderosas e flexíveis, e as operações de entrada e saída dos dados são realizadas de maneira "fluxo". O J2SDK fornece uma variedade de classes de "fluxo" para obter diferentes tipos de dados, definidos no pacote java.io. Os dados são de entrada ou saída no programa através de métodos padrão.
Os fluxos em Java podem ser classificados de diferentes perspectivas:
De acordo com a direção do fluxo: ele é dividido no fluxo de entrada e fluxo de saída.
De acordo com as diferentes unidades de dados: é dividido em fluxo de bytes (8 bits) e fluxo de caracteres (16 bits).
De acordo com diferentes funções: dividido no fluxo de nó e no fluxo de processamento.
Fluxo do nó: é um fluxo (como arquivo, memória) que pode ler e gravar dados de uma fonte de dados específica (nó). É como um único tubo conectado à torneira e começando a liberar água.
Fluxo de processamento: está "conectado" em um fluxo existente (fluxo de nó ou fluxo de processamento), fornecendo ao programa funções de leitura e gravação mais poderosas através de dados de processamento. Assim como com base em um tubo (fluxo de nó) conectado, alguns tubos mais espessos e especiais (fluxo de processamento) são colocados no tratamento adicional da água da saída.
Todos os tipos de fluxo fornecidos pelo J2SDK localizados no pacote java.io herdam os quatro tipos de fluxo abstrato a seguir.
Os quatro fluxos básicos InputStream, OutputStream, Leitor e Writer têm subclasses mais específicas, divididas em fluxos de arquivo, fluxos de buffer, fluxos de dados, fluxos de conversão, fluxos de impressão, fluxos de objetos, etc., todos os quais têm funções específicas ou são usados para operar dados específicos. Entre eles, as cores escuras representam o fluxo de nós e as cores claras representam o fluxo de processamento.
Aqui resumimos o uso específico do fluxo através do fluxo de nós e do fluxo de processamento.
Classificação dos fluxos de nó:
Fluxos de nó Arquivo de processo (arquivo), Array (Array na memória), String (String) e Pipe (Pipe), respectivamente.
Classificação dos fluxos de processamento:
Os fluxos de processamento comumente usados incluem: fluxo de buffer, fluxo de conversão, fluxo de dados, fluxo de objetos e fluxo de impressão.
Fluxo em buffer: ele precisa ser encaixado no fluxo de bytes correspondente e fornece função de buffer para dados de leitura e escrita, que melhora a eficiência de leitura e gravação e também adiciona alguns métodos mais convenientes.
A função de um fluxo de buffer é como um balde. O fluxo de byte original é um tubo de água. O tubo de água está diretamente conectado ao destino. Depois de adicionar o fluxo de tampão, um balde é conectado sob o tubo de água e depois derramado no destino depois que o balde é preenchido com água. Desempenha um papel em buffer. Dessa forma, você pode ler mais dados de uma só vez, evitando leitura e gravação frequentes no disco rígido. Como possui uma função de buffer, você precisa usar o método de descarga ao escrever dados.
importar java.io.*; classe pública TestBufferStream {public static void main (string [] args) {try {bufferwriter bw = new bufferWriter (new FileWriter ("f: //java//io/dat.txt"); FileReader ("f: //java//io/dat.txt"); // fluxo buffer no fluxo de bytes na sequência de arquivos de leitura s = null; for (int i = 1; i <= 100; i ++) {s = string.valueof (math.random ()); // atribui s a bw.write (s); // Escreva s no arquivo dat.txt bw.newline (); // Escreva um caractere de quebra de linha. Uma maneira melhor de usar fluxos em buffer é escrever ou ler uma linha de dados. } bw.flush (); // Faça com que todos os dados na memória sejam gravados imediatamente e não tamponados mais. while ((s = Br.readline ())! = null) {// Leia o conteúdo do arquivo por line System.out.println (s); } bw.close (); // Feche o fluxo de processamento e feche o fluxo do nó dentro. br.close (); } catch (ioexception e) {e.printStackTrace (); }}} Converter Flow: Use conversão com dados de bytes em dados de caracteres. O InputStreamReader requer um soquete InputStream, e o outputStreamWriter requer um soquete de saída.
Fluxo de dados: DatainputStream e DataOutputStream fornecem escrita ou leitura do tipo de dados básico em um arquivo. Este fluxo é de grande utilidade. Se não houver tal fluxo, há muito tempo que ocupa apenas 8 bytes. Se eu quiser escrever no arquivo, preciso convertê -lo em uma string e depois convertê -lo em uma matriz de caracteres, o espaço ocupará muito. No entanto, com esse fluxo, é muito conveniente. Basta escrever esses 8 bytes no arquivo, que não apenas salva o espaço de memória, mas também torna o programa mais conveniente e simples. No entanto, você precisa prestar atenção ao ler. De acordo com o tipo de dados que você lê, o ponteiro se moverá para baixo; portanto, o pedido que você leu deve ser consistente com a ordem de escrita para atender às suas necessidades corretas. Caso contrário, é equivalente a dividir os dados.
importar java.io.*; classe pública TestDataTream {public static void main (string [] args) {byteArrayoutputStream baos = new ByteArrayOutputStream (); // Crie um fluxo de nó. DataOutputStream DOS = new DataOutputStream (BAOS); // Conecte um fluxo de dados "Pipe" no fluxo de nós tente {dos.Writedouble (Math.random ()); // tipo duplo, 8 bytes dos.WriteBoolean (true); // tipo booleano, ocupa um byteByteArrayInputStream Bais = new ByteArrayInputStream (baos.tobytearray ()); System.out.println (Bais.Available ()); // Número total de bytes disponíveis no fluxo de saída-9 DatainputStream dis = new DatainputStream (Bais); // também conecta o fluxo de dados "Pipe" fora do sistema de fluxo de saída.out.println (dis.readDouble ()); // Turny leia o número do número de tipos duplos.out.println (Dis.ReadBoolean ()); // Turny leia o tipo booleano dos.close (); divulgar(); } catch (ioexception e) {e.printStackTrace (); }}}
Print Stream: Java.io fornece fluxos para impressão. Esse tipo de fluxo tem a função de lavar automaticamente ao escrever, portanto, não há necessidade de lavar toda vez que você imprimir alguma coisa.
importar java.io.*; classe pública testPrintStream1 {public static void main (string [] args) {printStream ps = null; tente {FileOutputStream fos = new FileOutputStream ("f: //java//io/log.dat"); // Crie o fluxo de saída e especifique o local de saída ps = new PrintStream (Fos); // Pacote o fluxo de impressão fora do fluxo} catch (ioexception e) {e.printStackTrace (); } if (ps! = null) {System.setout (ps); // Defina a impressão do sistema para imprimir fluxo ps} int ln = 0; for (char c = 0; c <= 60000; c ++) {System.out.print (c+""); // Não imprimindo na janela DOS, o fluxo de saída é impresso diretamente no arquivo especificado se (ln ++> = 100) {System.out.println (); ln = 0; }}}}