Antarmuka standar: InputStream, OutputStream

"Halo, Amigo! Sekarang saya akan memberi tahu Anda tentang dua antarmuka: InputStream dan OutputStream . Mereka dideklarasikan sebagai kelas abstrak, tetapi jika Anda menggali lebih dalam, Anda dapat melihat bahwa mereka pada dasarnya adalah antarmuka . Hampir semua metode mereka abstrak, kecuali untuk beberapa metode yang tidak penting. Mereka sangat mirip dengan " pengawal " yang kita bahas sebelumnya."

Ini adalah antarmuka yang sangat menarik. Untuk saat ini, saya sengaja menyebutnya interfaces , jadi Anda mengerti mengapa kami membutuhkannya. Dan kemudian kita akan berbicara tentang mengapa mereka sebenarnya adalah kelas abstrak.

"Oke. Jadi antarmuka apa ini?"

"Aku akan memberitahumu tanpa basa-basi lagi."

Java memiliki hal menarik yang disebut « aliran ». Aliran adalah entitas yang sangat sederhana. Dan kesederhanaannya adalah kunci untuk cara yang sangat ampuh untuk bertukar data. Ada dua jenis aliran: aliran untuk membaca dan aliran untuk menulis .

Seperti yang mungkin sudah Anda duga, Anda dapat menulis data ke aliran untuk menulis . Ini memiliki metode tulis untuk ini. Anda dapat membaca data dari aliran untuk membaca . Ini memiliki metode baca () untuk ini.

InputStream  adalah antarmuka untuk aliran yang mendukung pembacaan. Ini mendefinisikan kemampuan berikut: «byte dapat dibaca dari saya».

Demikian pula, OutputStream , OutputStream adalah antarmuka untuk aliran yang mendukung penulisan. Ini mendefinisikan kemampuan berikut: «byte dapat ditulis untuk saya».

"Itu dia?"

"Cukup banyak. Tapi intinya adalah Java memiliki banyak kelas yang dapat bekerja dengan InputStream dan OutputStream . Misalnya, Anda ingin membaca file dari disk dan menampilkan kontennya di layar. Tidak ada yang lebih mudah."

Untuk membaca data dari file di disk, kami memiliki kelas khusus FileInputStream , yang mengimplementasikan antarmuka InputStream . Apakah Anda ingin menulis data ini ke file lain? Untuk ini, kami memiliki kelas FileOutputStream , yang mengimplementasikan antarmuka OutputStream . Kode berikut menunjukkan apa yang perlu Anda lakukan untuk menyalin data dari satu file ke file lainnya.

public static void main(String[] args) throws IOException
{
 InputStream inStream = new FileInputStream("c:/source.txt");
 OutputStream outStream = new FileOutputStream("c:/result.txt");

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one byte from the input stream
  outStream.write(data); //write that byte to the other stream.
 }

 inStream.close(); //close the streams
 outStream.close();
}

Bayangkan kita telah menulis sebuah kelas dan menambahkan  kemampuan InputStream  dan  OutputStream ke dalamnya.

Jika kita mengimplementasikan antarmuka ini dengan benar, maka instance kelas kita sekarang dapat disimpan atau dibaca dari file. Cukup dengan membaca isinya menggunakan metode baca . Atau mereka dapat dimuat dari file dengan membuat objek dan menggunakan metode tulis untuk menulis konten file.

"Mungkin contohnya?"

"Tentu."

class MyClass
{
private ArrayList<Integer> list;
}

Sekarang kita akan menambahkan metode baca dan tulis ke dalamnya

class MyClass
{
private ArrayList<Integer> list;
public void write(int data)
{
list.add(data);
}
public int read()
{
int first = list.get(0);
list.remove(0);
return first;
}

public int available()
{
return list.size();
}
}

Tentu saja, ini bukan implementasi dari antarmuka InputStream dan OutputStream, tetapi sangat mirip.

"Ya, saya mengerti. Jadi, bagaimana Anda menyimpan konten objek semacam itu ke dalam file?"

"Izinkan saya memberi Anda sebuah contoh:"

public static void main(String[] args)
{
 MyClass myObject = new MyClass();
 OutputStream outStream = new FileOutputStream ("c:/my-object-data.txt");

 while (myObject.available() > 0)
 {
  int data = myObject.read(); //read one int from the input stream
  outStream.write(data); //write that int to the other stream.
 }

 outStream.close();
}

public static void main(String[] args)
{
 InputStream inStream = new FileInputStream("c:/my-object-data.txt");
 MyClass myObject = new MyClass();

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one int from the input stream
  myObject.write(data); //write that int to the other stream.
 }

 inStream.close(); //close the streams
}

"Holy moly! Ini benar-benar sangat mirip dengan bekerja dengan InputStream/OutputStream. Alirannya manis!"

"Dan kemudian beberapa!"