BufferedReader, BufferedWriter

"Ini aku lagi."

"Hai, Elli!"

"Hari ini saya ingin memberi tahu Anda semua tentang BufferedReader dan BufferedWriter ."

"Kamu sudah memberitahuku tentang mereka. Mereka sebenarnya tidak serumit itu."

"Oke. Lalu beri tahu saya cara kerja BufferedReader ."

" BufferedReader seperti konverter 110/220V."

"Anda harus meneruskan ke konstruktor BufferedReader objek Pembaca tempat data akan dibaca. Objek BufferedReader membaca sebagian besar data dari Pembaca dan menyimpannya secara internal dalam buffer. Itu sebabnya menggunakan BufferedReader untuk membaca dari Pembaca lebih cepat daripada membaca langsung dari Pembaca ."

"Benar. Dan bagaimana dengan BufferedWriter ?"

"Ini sangat mudah. ​​Misalkan kita menulis ke FileWriter . Data segera ditulis ke disk. Jika kita sering menulis sedikit data, maka kita akan sering menekan disk, yang akan sangat memperlambat program. Tapi jika kita menggunakan BufferedWriter sebagai 'konverter', maka operasi tulis jauh lebih cepat. Saat Anda menulis ke BufferedWriter , ini menyimpan data dalam buffer internal. Saat buffer penuh, ia menulis data ke Writer sebagai satu bongkahan besar. Ini jauh lebih cepat."

"Hmm. Tepat. Tapi apa yang kamu lupakan?"

"Setelah Anda selesai menulis, Anda perlu memanggil metode flush() pada objek BufferedWriter untuk memaksanya mengirim data apa pun yang masih dalam buffer ke Writer ."

"Lalu apa lagi?"

"Apa lagi? Oh! Selama buffer belum ditulis ke Writer , data dapat dihapus dan/atau diganti."

"Amigo! Saya terkesan! Anda seorang ahli! Baiklah, saya akan memberi tahu Anda tentang beberapa kelas baru:  ByteArrayStream dan PrintStream ."

"Misalnya, ByteArrayInputStream dan ByteArrayOutputStream ."

"Kelas-kelas ini sedikit mirip dengan StringReader dan StringWriter . Kecuali StringReader membaca karakter ( char ) dari string ( String ), tetapi InputStream membaca byte dari array byte ( ByteArray )."

StringWriter menulis karakter ( char ) ke string, sementara ByteArrayOutputStream menulis byte ke array byte internal. Saat Anda menulis ke StringWriter , string internalnya bertambah panjang, dan saat Anda menulis ke ByteArrayOutputStream , larik byte internalnya juga mengembang secara dinamis.

"Ingat contoh yang Anda berikan di pelajaran terakhir:"

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

"Inilah tampilannya jika bekerja menggunakan byte alih-alih karakter:"

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 sama dengan contoh di atas. Kecuali, kami mengganti String dengan ByteArray, Reader dengan InputStream, dan Writer dengan OutputStream."

"Hanya dua langkah lain yang mengubah String menjadi ByteArray dan kembali lagi. Seperti yang Anda lihat, ini dilakukan dengan cukup 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 byte yang telah ditambahkan ke ByteArrayOutputStream, panggil metode toByteArray ()."

"Ah. Kemiripan dengan StringReader/StringWriter cukup kuat, terutama setelah kamu menunjukkannya kepadaku. Terima kasih, Ellie, untuk pelajaran yang sangat menarik."

"Ke mana kamu terburu-buru? Aku masih punya hadiah kecil untukmu. Aku ingin memberitahumu tentang kelas PrintStream."

"PrintStream? Itu pertama kalinya aku mendengar tentang kelas itu."

"Ya. Terutama, jika Anda tidak menghitung fakta bahwa Anda telah menggunakannya sejak hari pertama studi Java Anda. Apakah Anda ingat System.out ? Nah, System.out adalah variabel (kelas) statis dari Sistem kelas, dan tipenya adalah... PrintStream ! Dari sinilah semua metode print, println, dll. ini berasal."

"Wow. Sangat menarik. Entah bagaimana aku bahkan tidak pernah mempertimbangkannya. Ceritakan lebih banyak."

"Bagus. Oke, dengarkan. Kelas PrintStream diciptakan untuk keluaran yang dapat dibaca. Kelas ini hampir seluruhnya terdiri dari metode print dan println. Lihat tabel ini:"

"Ada juga beberapa metode format sehingga Anda dapat menampilkan data menggunakan string format. Misalnya:"

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, aku ingat. Kita sudah mempelajari metode format kelas String."

"Itu saja untuk saat ini."

"Terima kasih, Elli."