BufferedReader, BufferedWriter

"Ik ben het weer."

"Hallo, Ellie!"

"Vandaag wil ik je alles vertellen over BufferedReader en BufferedWriter ."

'Je hebt me er al over verteld. Ze zijn echt niet zo ingewikkeld.'

"OK. Vertel me dan hoe BufferedReader werkt."

" BufferedReader is als een 110/220V-converter."

"U moet aan de BufferedReader- constructor het Reader- object doorgeven waarvan gegevens zullen worden gelezen. Een BufferedReader- object leest grote hoeveelheden gegevens uit de Reader en slaat deze intern op in een buffer. Daarom is het sneller om een ​​BufferedReader te gebruiken om van een Reader te lezen dan rechtstreeks lezen van een Reader ."

"Dat klopt. En hoe zit het met BufferedWriter ?"

"Het is een fluitje van een cent. Stel dat we naar een FileWriter schrijven. De gegevens worden onmiddellijk naar de schijf geschreven. Als we vaak kleine stukjes gegevens schrijven, raken we de schijf veel, wat het programma veel zal vertragen. Maar als we een BufferedWriter als 'converter' gebruiken, dan is de schrijfbewerking veel sneller. Wanneer u naar een BufferedWriter schrijft , slaat deze de gegevens op in een interne buffer. Wanneer de buffer vol is, schrijft deze de gegevens naar de Writer als een enkele grote brok. Dit is veel sneller."

"Hmm. Spot on. Maar wat ben je vergeten?"

"Nadat je klaar bent met schrijven, moet je de methode flush() op het BufferedWriter- object aanroepen om het te dwingen alle gegevens die zich nog in de buffer bevinden naar de Writer te sturen ."

"En wat nog meer?"

"Wat nog meer? Oh! Zolang de buffer niet naar de Writer is geschreven , kunnen de gegevens worden verwijderd en/of vervangen."

"Amigo! Ik ben onder de indruk! Je bent een expert! Nou, dan zal ik je wat nieuwe klassen vertellen:  ByteArrayStream en PrintStream ."

"Bijvoorbeeld ByteArrayInputStream en ByteArrayOutputStream ."

"Deze klassen lijken een beetje op StringReader en StringWriter . Behalve dat StringReader karakters ( char ) uit een string ( String ) leest, maar InputStream leest bytes uit een byte-array ( ByteArray )."

StringWriter schrijft karakters ( char ) naar een string, terwijl ByteArrayOutputStream bytes naar een interne byte-array schrijft. Wanneer u naar een StringWriter schrijft , wordt de interne tekenreeks langer, en wanneer u naar een ByteArrayOutputStream schrijft , wordt de interne byte-array ook dynamisch uitgebreid.

"Denk aan het voorbeeld dat je in de vorige les hebt gekregen:"

public static void main (String[] args) throws Exception
{
 String test = "Hi!\n My name is Richard\n I'm a photographer\n";
 StringReader reader = new StringReader(test);

 StringWriter writer = new StringWriter();

 executor(reader, writer);

 String result = writer.toString();

 System.out.println("Result: "+ result);
}

public static void executor(Reader reader, Writer writer) throws Exception
{
 BufferedReader br = new BufferedReader(reader);
 String line;
 while ((line = br.readLine()) != null) {
 StringBuilder sb = new StringBuilder(line);
 String newLine = sb.reverse().toString();

 writer.write(newLine);
 }
}

"Dit is hoe het eruit zou zien als het zou werken met bytes in plaats van tekens:"

public static void main (String[] args) throws Exception
{
 String test = "Hi!\n My name is Richard\n I'm a photographer\n";
 InputStream inputStream = new ByteArrayInputStream(test.getBytes());

 ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

 executor(inputStream, outputStream);

 String result = new String(outputStream.toByteArray());
 System.out.println("Result: "+ result);
}

public static void executor(InputStream inputStream, OutputStream outputStream) throws Exception
{
 BufferedInputStream bis = new BufferedInputStream(inputStream);
 while (bis.available() > 0)
 {
  int data = bis.read();
  outputStream.write(data);
 }
}

"Alles is hetzelfde als in het bovenstaande voorbeeld. Behalve dat we String hebben vervangen door ByteArray, Reader door InputStream en Writer door OutputStream."

"De enige twee andere stappen zijn het converteren van de String naar een ByteArray en weer terug. Zoals je kunt zien, gaat dit vrij eenvoudig:"

public static void main (String[] args) throws Exception
{
 String test = "Hi!\n My name is Richard\n I'm a photographer\n";
 byte[] array = test.getBytes();

 String result = new String(array);
 System.out.println("Result: "+ result);
}

"Om de bytes te krijgen die al aan een ByteArrayOutputStream zijn toegevoegd, roept u de methode toByteArray () aan."

"Ah. De overeenkomsten met StringReader/StringWriter zijn behoorlijk sterk, vooral nadat je me erop gewezen hebt. Bedankt, Ellie, voor een heel interessante les."

'Waar ga je zo snel heen? Ik heb nog een klein cadeautje voor je. Ik wil je vertellen over de PrintStream-klas.'

'PrintStream? Dat is de eerste keer dat ik van die klas hoor.'

"Ja. Vooral als je het feit niet meetelt dat je het al sinds de eerste dag van je Java-studies gebruikt. Herinner je je System.out nog ? Nou, System.out is een statische (klasse) variabele van de System class, en het type is... PrintStream ! Hier komen al deze print-, println-, enz. methoden vandaan."

"Wow. Wat interessant. Op de een of andere manier heb ik daar nooit aan gedacht. Vertel me meer."

"Goed. Oké, luister. De klasse PrintStream is uitgevonden voor leesbare uitvoer. Hij bestaat bijna volledig uit methoden print en println. Kijk naar deze tabel:"

"Er zijn ook verschillende indelingsmethoden, zodat u gegevens kunt uitvoeren met behulp van een indelingsreeks. Bijvoorbeeld:"

String name = "Kolan";
int age = 25;
System.out.format("My name is %s. My age is %d.", name, age);

My name is Kolan. My age is 25.

'Ja, dat weet ik nog. We hebben de opmaakmethode van de klasse String al bestudeerd.'

"Dat is het voor nu."

"Bedankt, Elly."