Antara muka standard: InputStream, OutputStream

"Helo, Amigo! Sekarang saya akan memberitahu anda tentang dua antara muka: InputStream dan OutputStream . Mereka diisytiharkan sebagai kelas abstrak, tetapi jika anda menggali lebih dalam, anda boleh melihat bahawa ia pada asasnya adalah antara muka . Hampir semua kaedah mereka adalah abstrak, kecuali untuk beberapa kaedah yang tidak penting. Mereka sangat mirip dengan " pengawal peribadi " yang kami pertimbangkan sebelum ini."

Ini adalah antara muka yang sangat menarik. Buat masa ini, saya sengaja akan memanggilnya antara muka , jadi anda faham mengapa kami memerlukannya. Dan kemudian kita akan bercakap tentang mengapa mereka sebenarnya kelas abstrak.

"Baiklah. Jadi apakah antara muka ini?"

"Saya akan memberitahu anda tanpa berlengah lagi."

Java mempunyai perkara yang menarik ini dipanggil « strim ». Strim ialah entiti yang sangat mudah. Dan kesederhanaannya adalah kunci untuk cara yang sangat berkuasa untuk bertukar-tukar data. Terdapat dua jenis aliran: aliran untuk membaca dan aliran untuk menulis .

Seperti yang anda mungkin sudah meneka, anda boleh menulis data ke strim untuk menulis . Ia mempunyai kaedah tulis untuk ini. Anda boleh membaca data daripada strim untuk bacaan . Ia mempunyai kaedah baca () untuk ini.

InputStream  ialah antara muka untuk aliran yang menyokong bacaan. Ia mentakrifkan keupayaan berikut: «bait boleh dibaca daripada saya».

Begitu juga, OutputStream , OutputStream ialah antara muka untuk aliran yang menyokong penulisan. Ia mentakrifkan keupayaan berikut: «bait boleh ditulis kepada saya».

"Itu sahaja?"

"Cukup banyak. Tetapi intinya ialah Java mempunyai banyak kelas yang boleh berfungsi dengan InputStream dan OutputStream . Contohnya, anda ingin membaca fail daripada cakera dan memaparkan kandungannya pada skrin. Tiada yang lebih mudah."

Untuk membaca data daripada fail pada cakera, kami mempunyai kelas FileInputStream khas , yang melaksanakan antara muka InputStream . Adakah anda mahu menulis data ini ke fail lain? Untuk ini, kami mempunyai kelas FileOutputStream , yang melaksanakan antara muka OutputStream . Kod berikut menunjukkan perkara yang anda perlu lakukan untuk menyalin data dari satu fail ke fail yang lain.

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 bahawa kami telah menulis kelas dan menambahkan  kebolehan InputStream  dan  OutputStream padanya.

Jika kami melaksanakan antara muka ini dengan betul, maka contoh kelas kami kini boleh disimpan atau dibaca daripada fail. Hanya dengan membaca kandungan mereka menggunakan kaedah baca . Atau mereka boleh dimuatkan daripada fail dengan mencipta objek dan menggunakan kaedah tulis untuk menulis kandungan fail.

"Mungkin satu contoh?"

"Tentu."

class MyClass
{
private ArrayList<Integer> list;
}

Sekarang kami akan menambah kaedah baca dan tulis padanya

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

Sudah tentu, ini bukan pelaksanaan antara muka InputStream dan OutputStream, tetapi ia sangat serupa.

"Ya, saya faham. Jadi bagaimana anda menyimpan kandungan objek sedemikian ke dalam fail?"

"Biar saya berikan satu 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! Ia benar-benar serupa dengan bekerja dengan InputStream/OutputStream. Strimnya manis!"

"Dan kemudian beberapa!"