BufferedReader, BufferedWriter

"Ini saya lagi."

"Hai, Ellie!"

"Hari ini saya ingin memberitahu anda semua tentang BufferedReader dan BufferedWriter ."

"Anda sudah memberitahu saya tentang mereka. Mereka sebenarnya tidak begitu rumit."

"OK. Kemudian beritahu saya cara BufferedReader berfungsi."

" BufferedReader adalah seperti penukar 110/220V."

"Anda perlu menghantar objek Reader kepada pembina BufferedReader yang mana data akan dibaca. Objek BufferedReader membaca sebahagian besar data daripada Reader dan menyimpannya secara dalaman dalam buffer. Itulah sebabnya menggunakan BufferedReader untuk membaca daripada Reader adalah lebih pantas daripada membaca terus daripada Pembaca ."

"Betul. Dan bagaimana pula dengan BufferedWriter ?"

"Ia adalah sekeping kek. Katakan kita menulis kepada FileWriter . Data ditulis ke cakera serta-merta. Jika kita menulis bit kecil data dengan kerap, maka kita akan memukul cakera dengan banyak, yang akan melambatkan program dengan banyak. Tetapi jika kita menggunakan BufferedWriter sebagai 'penukar', maka operasi tulis adalah lebih cepat. Apabila anda menulis kepada BufferedWriter , ia menyimpan data dalam penimbal dalaman. Apabila penimbal penuh, ia menulis data kepada Penulis sebagai satu ketul besar. Ini lebih cepat."

"Hmm. Spot on. Tapi apa yang awak dah lupa?"

"Selepas anda selesai menulis, anda perlu memanggil kaedah flush() pada objek BufferedWriter untuk memaksanya menghantar sebarang data yang masih dalam penimbal kepada Writer ."

"Dan apa lagi?"

"Apa lagi? Oh! Selagi penimbal belum ditulis kepada Penulis , data boleh dipadamkan dan/atau diganti."

"Amigo! Saya kagum! Anda seorang pakar! Baiklah, saya akan memberitahu anda tentang beberapa kelas baharu:  ByteArrayStream dan PrintStream ."

"Sebagai contoh, ByteArrayInputStream dan ByteArrayOutputStream ."

"Kelas ini sedikit seperti StringReader dan StringWriter . Kecuali StringReader membaca aksara ( char ) daripada rentetan ( String ), tetapi InputStream membaca bait daripada tatasusunan bait ( ByteArray ).

StringWriter menulis aksara ( char ) kepada rentetan, manakala ByteArrayOutputStream menulis bait kepada tatasusunan bait dalaman. Apabila anda menulis kepada StringWriter , rentetan dalamannya menjadi lebih panjang dan apabila anda menulis kepada ByteArrayOutputStream tatasusunan bait dalamannya juga berkembang secara dinamik.

"Ingat contoh yang diberikan kepada anda dalam pelajaran lepas:"

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

"Berikut ialah bagaimana ia akan kelihatan jika ia berfungsi menggunakan bait dan bukannya aksara:"

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

"Semuanya adalah sama seperti dalam contoh di atas. Kecuali, kami menggantikan String dengan ByteArray, Reader dengan InputStream dan Writer dengan OutputStream."

"Hanya dua langkah lain ialah menukar String menjadi ByteArray dan kembali semula. Seperti yang anda lihat, ini dilakukan dengan agak mudah:"

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

"Untuk mendapatkan bait yang telah ditambahkan pada ByteArrayOutputStream, panggil kaedah toByteArray ()."

"Ah. Persamaan dengan StringReader/StringWriter agak kuat, terutamanya selepas anda menunjukkannya kepada saya. Terima kasih, Ellie, untuk pelajaran yang sangat menarik."

"Awak nak pergi mana tergesa-gesa? Saya masih ada hadiah kecil untuk awak. Saya nak beritahu awak tentang kelas PrintStream."

"PrintStream? Itulah kali pertama saya mendengar tentang kelas itu."

"Ya. Terutama, jika anda tidak mengira fakta bahawa anda telah menggunakannya sejak hari pertama pengajian Java anda. Adakah anda masih ingat System.out ? Nah, System.out ialah pembolehubah statik (kelas) Sistem kelas, dan jenisnya ialah... PrintStream ! Di sinilah semua kaedah cetakan, println, dsb. ini berasal."

"Wah. Menariknya. Saya entah bagaimana tidak pernah menganggapnya. Beritahu saya lebih lanjut."

"Baik. Okey, dengar. Kelas PrintStream dicipta untuk output yang boleh dibaca. Ia terdiri hampir keseluruhan kaedah cetakan dan println. Lihat jadual ini:"

"Terdapat juga beberapa kaedah format supaya anda boleh mengeluarkan data menggunakan rentetan format. Contohnya:"

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.

"Ya, saya ingat. Kami sudah mempelajari kaedah format kelas String."

"Itu sahaja buat masa ini."

"Terima kasih, Ellie."