BufferedReader, BufferedWriter

"Ako ulit."

"Hi, Ellie!"

"Ngayon gusto kong sabihin sa iyo ang lahat tungkol sa BufferedReader at BufferedWriter ."

"Nakwento mo na sa akin ang tungkol sa kanila. Hindi naman talaga sila ganoon kakomplikado."

"OK. Pagkatapos ay sabihin sa akin kung paano gumagana ang BufferedReader ."

" Ang BufferedReader ay parang 110/220V converter."

"Kailangan mong ipasa sa BufferedReader constructor ang Reader object kung saan babasahin ang data. Binabasa ng object ng BufferedReader ang malalaking chunks ng data mula sa Reader at iniimbak ang mga ito sa loob ng buffer. Kaya naman ang paggamit ng BufferedReader para magbasa mula sa Reader ay mas mabilis kaysa magbasa nang direkta mula sa isang Reader ."

"Tama. At paano naman ang BufferedWriter ?"

"Ito ay isang piraso ng cake. Ipagpalagay na sumulat tayo sa isang FileWriter . Ang data ay isinulat kaagad sa disk. Kung magsusulat tayo ng maliliit na data ng madalas, pagkatapos ay matumbok natin ang disk nang husto, na magpapabagal nang husto sa programa. Ngunit kung gagamit tayo ng BufferedWriter bilang 'converter', mas mabilis ang write operation. Kapag sumulat ka sa BufferedWriter , sine-save nito ang data sa internal buffer. Kapag puno na ang buffer, isinusulat nito ang data sa Writer bilang isang malaking tipak. Ito ay mas mabilis."

"Hmm. Spot on. Pero anong nakalimutan mo?"

"Pagkatapos mong magsulat, kailangan mong tawagan ang flush() method sa BufferedWriter object upang pilitin itong magpadala ng anumang data na nasa buffer pa rin sa Writer ."

"At ano pa?"

"Ano pa? Naku! Hangga't hindi pa naisusulat ang buffer sa Writer , maaaring tanggalin at/o palitan ang data."

"Amigo! Humanga ako! Isa kang eksperto! Well, pagkatapos ay sasabihin ko sa iyo ang tungkol sa ilang mga bagong klase:  ByteArrayStream at PrintStream ."

"Halimbawa, ByteArrayInputStream at ByteArrayOutputStream ."

"Ang mga klase na ito ay medyo katulad ng StringReader at StringWriter . Maliban ang StringReader ay nagbabasa ng mga character ( char ) mula sa isang string ( String ), ngunit ang InputStream ay nagbabasa ng mga byte mula sa isang byte array ( ByteArray ).

Ang StringWriter ay nagsusulat ng mga character ( char ) sa isang string, habang ang ByteArrayOutputStream ay nagsusulat ng mga byte sa isang panloob na byte array. Kapag sumulat ka sa isang StringWriter , lumalaki ang panloob na string nito, at kapag sumulat ka sa isang ByteArrayOutputStream , dynamic na lumalawak din ang panloob na byte array nito.

"Tandaan ang halimbawang ibinigay sa iyo sa huling aralin:"

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

"Narito ang magiging hitsura kung ito ay gumagana gamit ang mga byte sa halip na mga character:"

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

"Ang lahat ay pareho sa halimbawa sa itaas. Maliban, pinalitan namin ang String ng ByteArray, Reader na may InputStream, at Writer ng OutputStream."

"Ang dalawa lang na hakbang ay ang pagko-convert ng String sa isang ByteArray at bumalik muli. Gaya ng nakikita mo, ito ay medyo madali:"

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

"Upang makuha ang mga byte na naidagdag na sa isang ByteArrayOutputStream, tawagan ang toByteArray () na paraan."

"Ah. Medyo malakas ang pagkakatulad sa StringReader/StringWriter, lalo na pagkatapos mong ituro sa akin. Salamat, Ellie, para sa isang talagang kawili-wiling aralin."

"Saan ka ba nagmamadali? May maliit pa akong regalo para sa iyo. Gusto kong sabihin sa iyo ang tungkol sa klase ng PrintStream."

"PrintStream? Iyon ang unang beses na narinig ko ang klaseng iyon."

"Oo. Lalo na, kung hindi mo binibilang ang katotohanan na ginagamit mo ito mula pa noong unang araw ng iyong pag-aaral sa Java. Naaalala mo ba ang System.out ? Well, ang System.out ay isang static (class) na variable ng System class, at ang uri nito ay... PrintStream ! Dito nagmula ang lahat ng mga pamamaraan ng print, println, atbp.."

"Wow. How interesting. I somehow never even considered that. Tell me more."

"Mabuti. Okay, makinig. Ang klase ng PrintStream ay naimbento para sa nababasang output. Ito ay halos lahat ay binubuo ng mga pamamaraan ng pag-print at println. Tingnan ang talahanayang ito:"

"Mayroon ding ilang paraan ng pag-format upang makapag-output ka ng data gamit ang isang format na string. Halimbawa:"

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.

"Yeah, I remember. Napag-aralan na namin ang format method ng String class."

"Yun lang muna."

"Salamat, Ellie."