BufferedReader, BufferedWriter

"Det är jag igen."

"Hej Ellie!"

"Idag skulle jag vilja berätta allt om BufferedReader och BufferedWriter ."

"Du har redan berättat om dem. De är verkligen inte så komplicerade."

"OK. Berätta sedan hur BufferedReader fungerar."

" BufferedReader är som en 110/220V-omvandlare."

"Du måste skicka Reader -objektet som data kommer att läsas från till BufferedReader- konstruktorn . Ett BufferedReader -objekt läser stora bitar av data från Reader och lagrar dem internt i en buffert. Det är därför det går snabbare att använda en BufferedReader för att läsa från en Reader än att läsa direkt från en läsare ."

"Det stämmer. Och hur är det med BufferedWriter ?"

"Det är en piece of cake. Anta att vi skriver till en FileWriter . Data skrivs till disken omedelbart. Om vi ​​skriver små bitar av data ofta, då kommer vi att träffa disken mycket, vilket kommer att sakta ner programmet mycket. Men om vi använder en BufferedWriter som en 'omvandlare' så är skrivoperationen mycket snabbare. När du skriver till en BufferedWriter sparar den data i en intern buffert. När bufferten är full skriver den data till Writer som en enda stor bit. Det här är mycket snabbare."

"Hmm. Spot on. Men vad har du glömt?"

"När du har skrivit klart måste du anropa metoden flush() på BufferedWriter -objektet för att tvinga det att skicka all data som finns kvar i bufferten till Writer ."

"Och vad mer?"

"Vad annars? Åh! Så länge bufferten inte har skrivits till Writer kan data raderas och/eller ersättas."

"Amigo! Jag är imponerad! Du är en expert! Ja, då ska jag berätta om några nya klasser:  ByteArrayStream och PrintStream ."

"Till exempel ByteArrayInputStream och ByteArrayOutputStream ."

"Dessa klasser är lite som StringReader och StringWriter . Förutom att StringReader läser tecken ( char ) från en sträng ( String ), men InputStream läser bytes från en byte-array ( ByteArray )."

StringWriter skriver tecken ( char ) till en sträng, medan ByteArrayOutputStream skriver byte till en intern byte-array. När du skriver till en StringWriter växer dess interna sträng längre, och när du skriver till en ByteArrayOutputStream expanderar dess interna byte-array också dynamiskt.

"Kom ihåg exemplet du fick i förra lektionen:"

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);
 }
}

"Så här skulle det se ut om det fungerade med byte istället för tecken:"

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);
 }
}

"Allt är detsamma som i exemplet ovan. Förutom att vi ersatte String med ByteArray, Reader med InputStream och Writer med OutputStream."

"De enda två andra stegen är att konvertera strängen till en ByteArray och tillbaka igen. Som du kan se görs detta ganska enkelt:"

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);
}

"För att få byte som redan har lagts till i en ByteArrayOutputStream, anropa metoden toByteArray ()."

"Ah. Likheterna med StringReader/StringWriter är ganska starka, särskilt efter att du påpekade dem för mig. Tack, Ellie, för en riktigt intressant lektion."

"Vart ska du ha så bråttom? Jag har fortfarande en liten present till dig. Jag vill berätta om PrintStream-klassen."

"PrintStream? Det är första gången jag har hört talas om den klassen."

"Japp. Speciellt om du inte räknar med det faktum att du har använt det sedan dag ett av dina Java-studier. Kommer du ihåg System.out ? Tja, System.out är en statisk (klass)variabel i systemet klass, och dess typ är... PrintStream ! Det är härifrån alla dessa metoder för utskrift, println, etc. kommer ifrån."

"Wow. Vad intressant. Jag har på något sätt aldrig ens tänkt på det. Berätta mer."

"Bra. Okej, lyssna. PrintStream-klassen uppfanns för läsbar utdata. Den består nästan uteslutande av print- och println-metoder. Titta på den här tabellen:"

"Det finns också flera formatmetoder så att du kan mata ut data med en formatsträng. Till exempel:"

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, jag kommer ihåg. Vi har redan studerat String-klassens formatmetod."

"Det var allt tills vidare."

"Tack, Ellie."