BufferedReader, BufferedWriter

"Megint én vagyok."

– Szia, Ellie!

"Ma mindent szeretnék elmondani a BufferedReaderről és a BufferedWriterről ."

– Már meséltél róluk. Tényleg nem olyan bonyolultak.

"OK. Akkor mondja el, hogyan működik a BufferedReader ."

" A BufferedReader olyan, mint egy 110/220 V-os átalakító."

"Át kell adnia a BufferedReader konstruktornak azt a Reader objektumot, amelyből az adatokat beolvassa. A BufferedReader objektum nagy mennyiségű adatot olvas be a Readerből , és belsőleg egy pufferben tárolja. Ezért gyorsabb a BufferedReader használata az olvasóból való olvasáshoz. mint közvetlenül olvasóból olvasni . "

– Így van. És mi a helyzet a BufferedWriterrel ?

"Ez egy szelet. Tegyük fel, hogy egy FileWriter- be írunk . Az adatok azonnal a lemezre kerülnek. Ha gyakran írunk egy kis adatot, akkor nagyon megütjük a lemezt, ami nagyon lelassítja a programot. De ha egy BufferedWriter-t használunk 'átalakítónak', akkor sokkal gyorsabb az írási művelet. Ha egy BufferedWriter- be írunk , az egy belső pufferbe menti az adatokat. Amikor a puffer megtelik, az adatokat a Writerbe írja egyetlen nagy darab. Ez sokkal gyorsabb."

"Hmm. Pontosan. De mit felejtettél el?"

"Miután végzett az írással, meg kell hívnia a flush() metódust a BufferedWriter objektumon, hogy kényszerítse azt, hogy a pufferben lévő adatokat elküldje a Writernek . "

"És mi más?"

"Mi más? Ó! Amíg a puffert nem írták be a Writerbe , az adatok törölhetők és/vagy cserélhetők."

"Amigo! Lenyűgözött! Szakértő vagy! Nos, akkor mesélek néhány új osztályról:  ByteArrayStream és PrintStream ."

"Például ByteArrayInputStream és ByteArrayOutputStream ."

"Ezek az osztályok kicsit olyanok, mint a StringReader és a StringWriter . A StringReader kivételével a karaktereket ( char ) egy stringből ( String ) olvassa be, az InputStream viszont egy bájttömbből ( ByteArray ) olvassa be a bájtokat."

A StringWriter karaktereket ( char ) ír egy karakterláncba, míg a ByteArrayOutputStream bájtokat ír egy belső bájttömbbe. Amikor egy StringWriter- be ír , a belső karakterlánca meghosszabbodik, és amikor egy ByteArrayOutputStream- be ír , annak belső bájttömbje is dinamikusan bővül.

"Emlékezzen a példára, amelyet az előző leckében adtak neked:"

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

"Íme, hogyan nézne ki, ha karakterek helyett bájtokkal működne:"

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

"Minden ugyanaz, mint a fenti példában. Kivéve, hogy a String-et a ByteArray-re, a Readert az InputStreamre, a Writer-t pedig az OutputStreamre cseréltük."

"A másik két lépés a String ByteArray-vé való átalakítása, majd visszaállítása. Mint láthatja, ez meglehetősen egyszerűen megtehető:

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

"A ByteArrayOutputStreamhez már hozzáadott bájtok lekéréséhez hívja meg a toByteArray () metódust."

"Ah. A StringReader/StringWriter hasonlóságok elég erősek, különösen miután rámutatott. Köszönöm, Ellie, az igazán érdekes leckét."

"Hová sietsz ennyire? Még mindig van egy kis ajándékom a számodra. Szeretnék mesélni a PrintStream óráról."

"PrintStream? Most hallok először erről az osztályról."

"Igen. Főleg, ha nem számítja azt a tényt, hogy Java-tanulmányainak első napja óta használja. Emlékszel a System.out-ra ? Nos, a System.out a System statikus (osztály) változója osztály, típusa pedig... PrintStream ! Innen erednek ezek a print, println stb. metódusok."

"Hú. Milyen érdekes. Valahogy ez eszembe sem jutott. Mesélj még."

"Jó. Oké, figyelj. A PrintStream osztályt olvasható kimenetre találták ki. Szinte teljes egészében print és println metódusokból áll. Nézd meg ezt a táblázatot:"

"Több formázási módszer is létezik, így formátumkarakterlánc segítségével is kiadhatja az adatokat. Például:"

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.

"Igen, emlékszem. Már tanulmányoztuk a String osztály formázási módszerét."

"Ez minden most."

– Köszönöm, Ellie.