"Hallo, Amigo! Vandaag gaan we opnieuw in op hoe InputStream en OutputStream werken. De eerste uitleg was eigenlijk een beetje simplistisch. Dit zijn geen interfaces. Het zijn abstracte klassen en ze hebben zelfs een aantal geïmplementeerde methoden. Laten we eens kijken naar de methoden die ze hebben:"

InputStream-methoden Wat de methode doet 
int read(byte[] buff);
 Deze methode leest onmiddellijk een blok bytes in de buffer ( byte array ), totdat de buffer vol is of totdat de bron geen bytes meer heeft om te lezen.
De methode retourneert het aantal werkelijk gelezen bytes (dit kan kleiner zijn dan de lengte van de array)		 
int read();
 Deze methode leest één byte en retourneert deze. Het resultaat wordt verbreed tot een int voor uiterlijk. Als er geen bytes meer zijn om te lezen, retourneert de methode -1. 
int available();
 Deze methode retourneert het aantal ongelezen (beschikbare) bytes. 
void close();
 Deze methode «sluit» de stream. Je roept dit aan als je klaar bent met werken met de stream.
Het object voert vervolgens de huishoudelijke bewerkingen uit die nodig zijn om het bestand te sluiten, enz
. Op dit moment kunt u geen gegevens meer uit de stream lezen.
Java webinar

"Dus we kunnen niet alleen enkele bytes lezen, maar ook hele blokken?"

"Precies."

"Kunnen we ook hele blokken schrijven?"

"Ja, kijk eens:"

OutputStream-methoden Wat de methode doet 
void write(int c);
 Deze methode schrijft één byte. Het int-type is versmald tot een byte. Het extra deel wordt gewoon weggegooid. 
void write(byte[] buff);
 Deze methode schrijft een blok bytes. 
void write(byte[] buff, int from, int count);
 Deze methode schrijft een deel van een bytesblok weg. Het wordt gebruikt in gevallen waarin de byte-array mogelijk niet volledig is gevuld. 
void flush();
 Als de stream intern gegevens opslaat die nog niet zijn geschreven, dwingt deze methode het schrijven af. 
void close();
 Deze methode «sluit» de stream. Je roept dit aan als je klaar bent met werken met de stream.
Het object voert vervolgens de huishoudelijke bewerkingen uit die nodig zijn om het bestand te sluiten, enz. U kunt geen gegevens meer naar de stream schrijven en flush wordt automatisch aangeroepen.

"Hoe zou de code voor het kopiëren van bestanden eruit zien als we hele blokken tegelijk lezen in plaats van enkele bytes?"

"Hmm. Iets als dit:"

Kopieer een bestand op schijf 
public static void main(String[] args) throws Exception
{
 //Create a stream to read bytes from a file
 FileInputStream inputStream = new FileInputStream("c:/data.txt");
 //Create a stream to write bytes to a file
 FileOutputStream outputStream = new FileOutputStream("c:/result.txt");

  byte[] buffer = new byte[1000];
 while (inputStream.available() > 0) //as long as there are unread bytes
 {
  //Read the next block of bytes into buffer, and store the actual number of bytes read in count.
  int count = inputStream.read(buffer);
  outputStream.write(buffer, 0, count); //Write a block (part of a block) to the second stream
 }

 inputStream.close(); //Close both streams. We don't need them any more.
 outputStream.close();
}

"Ik begrijp alles van de buffer, maar wat is deze telvariabele?"

"Als we het laatste datablok uit een bestand lezen, krijgen we bijvoorbeeld 328 bytes in plaats van 1000. Dus als we de data schrijven, moeten we aangeven dat we niet het hele blok schrijven - alleen de eerste 328 bytes." bytes."

Wanneer we het laatste blok lezen, retourneert de leesmethode het aantal werkelijk gelezen bytes. 1000 elke keer dat we een blok lezen, behalve het laatste blok, wanneer we 328 krijgen.

Dus als we een blok schrijven, geven we aan dat niet alle bytes in de buffer moeten worden geschreven, alleen 328 (dwz de waarde die is opgeslagen in de variabele count).

'Nu is het allemaal duidelijk. Bedankt, Ellie.'