1. Fluxos básicos de entrada e fluxos de saída <Br /> é um dos conceitos básicos mais importantes do Java. Leitura e escrita de arquivos, transmissão e recepção de rede, comunicação de processos e streaming são usados em quase todos os lugares onde são necessárias entradas e saída.
Para que é usado o streaming? É para entrada e saída. Por que a entrada e a saída usam "Stream"? Como a unidade básica de entrada e saída do programa é bytes, a entrada é obter uma sequência de bytes, e a saída é enviar uma sequência de bytes. No entanto, em muitos casos, é impossível para um programa receber todos os bytes antes do processamento, mas receber um pouco de processamento. Por exemplo, quando você baixar o World of Warcraft, é impossível baixar tudo na memória e salvá -lo no disco rígido, mas basta fazer o download e salvá -lo um pouco. Neste momento, esse método é muito adequado.
Em Java, cada fluxo é um objeto. Existem dois tipos de fluxos: fluxo de entrada (InputStream) e fluxo de saída (saída de saída). Para o fluxo de entrada, você só precisa continuar retirando os bytes do fluxo;
Como os objetos de fluxo são obtidos? Diferentes sistemas externos também têm maneiras diferentes de obter fluxos. Por exemplo, ao ler e escrever arquivos, você precisa criar um objeto FileInputStream/FileOutputStream, enquanto a comunicação de rede usa objetos de soquete para obter fluxos de entrada e saída. De um modo geral, se uma classe possui métodos como getInputStream () ou getOutputStream (), significa que é entrada e saída através de um objeto de fluxo.
InputStream é um fluxo de entrada.
Importar java.io.File; */ public class Readfiledemo {// Entrada do programa Public Static void Main (String [] args) {String Path = "C: /boot.ini"; ; BYTE [0]; Se o valor de retorno for -1, significa que não há conteúdo para ler. while (cada vez! = -1) {// O conteúdo de leitura é colocado no buffer e agora o mescla no conteúdo. Content = ConcatbyTearRays (conteúdo, buffer, cada vez); PrintStackTrace (); em. Retorne o resultado da mesclagem dos primeiros sizeofbytes2 bytes1 e bytes2*/ byte estático privado [] concatbytearrays (byte [] bytes1, byte [] bytes2, int sizeofbytes2) {byte [] resu lt = arrays.copyof (byTes1, (byTes1) {byte [] lt = arrays.CopyOf (byTes1, (byTes1) .Length + sizeofbytes2));Embora seja muito detalhado, esse é realmente o uso básico do InputStream. Observe que este é apenas um exemplo de como ler uma string de byte a partir do fluxo de entrada. De fato, o Java fornece uma maneira mais fácil de ler arquivos de texto. Será introduzido mais tarde.
O uso de saída de saída é uma coisa muito simples do que ler a partir de um fluxo. Aqui está um exemplo:
Importar Java.io.OutputStream; Savefiledemo {public static void main (string [] args) lança IoException {String Path = "C: /now.txt"; ()) {System.err.println ("arquivo não pode ser criado."); ) .ToString () .GetBytes ()); System.out.println ("A gravação de arquivos está concluída.");
O Java também fornece outras operações de streaming, mas todas elas estendem ou wrapper InputStream e OutputStream. Portanto, essas duas classes são a base e devem ser entendidas.
2. Leitor e escritor
InputStream e OutputStream são introduzidos e, em seguida, o leitor e o escritor são introduzidos. Essas duas classes realmente envolvem o InputStream e o OutputStream. No entanto, eles processam não bytes, mas personagens. Se o conteúdo de um fluxo for um texto, será mais fácil processar com o leitor/escritor. Aqui está um exemplo de leitura de um arquivo de texto usando o leitor:
Importar java.io.fileReader; String Path = "C: /boot.ini"; Leia (buffer))! = -1) {Content += new String (Buffer, 0, contagem); );Quanto a como usar o Writer para escrever conteúdo de texto em um arquivo, não darei um exemplo aqui.
O exemplo acima ainda não é a maneira mais comum de ler arquivos de texto. O Java fornece um leitor de buffers, que geralmente usamos para ler arquivos de texto. Aqui está um exemplo:
Importar java.io.BufferReader; Path = "C: /boot.ini"; {content + = linha + "/n"; }3. A serialização do objeto <br /> serialização do objeto também é um aspecto importante dos aplicativos de streaming. A serialização é converter um objeto em uma sequência de bytes, que pode ser salva ou passada para outro programa Java para uso. ObjectOutputStream e ObjectInputStream são usados especialmente para serialização e deserialização. Aqui está um exemplo simples:
Importar java.io.ObjectUtTream; importar java.io.eofexception; * Essas duas classes são usadas para serialização e desserialização, respectivamente. */ public class SerializationDemo {public static void main (string [] args) lança Exceção {String Path = "C: /Persons.data"; f.createnewfile (); caminho); O objeto é salvo no arquivo especificado privado estático void writePersons (caminho da sequência) lança ioexception {Person [] pessoas = nova pessoa [] {new Person ("Zhang San", 23), New Pessoa ("Li Si", 24)} ObjectUtTream OOS = NOVO OBJETIVO DE OOS (NOVA FILHOUSTUMENTE (PATH); /////////// //////////////////////////////////////////////uvido /////////////////////////////////////////////////////////Tipos //////////////////////////////////////201S de implementos serializable {Nome da String Private; Pessoa pública () {} Pessoa pública (Nome da String, Int Age) {this.name = Name; Nome = Nome; Nome + '/' ' + ", Age =" Age +'} ';Este exemplo não pode ler e escrever bytes e caracteres, porque as duas classes são embaladas. O exposto acima é apenas um exemplo simples, e ainda há muitas coisas para prestar atenção se você quiser escrever bem a serialização. Se você quiser ter um entendimento mais profundo da serialização, pode conferir aqui. Este artigo se concentra apenas nas peças relacionadas ao streaming. De fato, a serialização raramente é usada porque a serialização reduz a flexibilidade, por isso geralmente não é usada se você não a usar.