Mga karaniwang interface: InputStream, OutputStream

"Kumusta, Amigo! Ngayon sasabihin ko sa iyo ang tungkol sa dalawang interface: InputStream at OutputStream . Idineklara ang mga ito bilang mga abstract na klase, ngunit kung maghuhukay ka ng mas malalim, makikita mo na ang mga ito ay mahalagang mga interface . Halos lahat ng kanilang mga pamamaraan ay abstract, maliban sa ilang hindi gaanong kabuluhan na mga pamamaraan. Sila ay katulad na katulad ng " bodyguard " na isinaalang-alang natin kanina."

Ang mga ito ay napaka-kagiliw-giliw na mga interface. Sa ngayon, sadyang tatawagin ko silang mga interface , para maunawaan mo kung bakit namin kailangan ang mga ito. At pagkatapos ay pag-uusapan natin kung bakit sila ay talagang mga abstract na klase.

"Okay. So ano itong mga interface?"

"Sasabihin ko sa iyo nang walang karagdagang abala."

Ang Java ay may ganitong kawili-wiling bagay na tinatawag na " stream ". Ang stream ay isang napakasimpleng entity. At ang pagiging simple nito ay ang susi para sa isang napakalakas na paraan upang makipagpalitan ng data. Mayroong dalawang uri ng stream: stream para sa pagbabasa at stream para sa pagsusulat .

Tulad ng malamang na nahulaan mo na, maaari kang sumulat ng data sa isang stream para sa pagsusulat . Mayroon itong paraan ng pagsulat para dito. Maaari kang magbasa ng data mula sa isang stream para sa pagbabasa . Mayroon itong read () na paraan para dito.

Ang InputStream  ay ang interface para sa isang stream na sumusuporta sa pagbabasa. Tinutukoy nito ang sumusunod na kakayahan: «mababasa sa akin ang mga byte».

Katulad nito, ang OutputStream , ang OutputStream ay isang interface para sa isang stream na sumusuporta sa pagsusulat. Tinutukoy nito ang sumusunod na kakayahan: «maaaring isulat sa akin ang mga byte».

"Ayan yun?"

"Medyo. Ngunit ang buong punto ay ang Java ay may maraming klase na maaaring gumana sa InputStream at OutputStream . Halimbawa, gusto mong magbasa ng file mula sa disk at ipakita ang mga nilalaman nito sa screen. Walang mas madali."

Upang basahin ang data mula sa isang file sa disk, mayroon kaming espesyal na klase ng FileInputStream , na nagpapatupad ng interface ng InputStream . Gusto mo bang isulat ang data na ito sa isa pang file? Para dito, mayroon kaming klase ng FileOutputStream , na nagpapatupad ng interface ng OutputStream . Ipinapakita ng sumusunod na code kung ano ang kailangan mong gawin upang kopyahin ang data mula sa isang file patungo sa isa pa.

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

Isipin na nagsulat kami ng isang klase at nagdagdag ng  mga kakayahan sa InputStream  at  OutputStream dito.

Kung maayos nating ipinatupad ang mga interface na ito, ang mga pagkakataon ng ating klase ay maaari na ngayong i-save sa o basahin mula sa isang file. Sa pamamagitan lamang ng pagbabasa ng kanilang mga nilalaman gamit ang read method. O maaari silang mai-load mula sa isang file sa pamamagitan ng paglikha ng isang bagay at paggamit ng paraan ng pagsulat upang isulat ang mga nilalaman ng file.

"Baka isang halimbawa?"

"Oo naman."

class MyClass
{
private ArrayList<Integer> list;
}

Ngayon ay magdaragdag kami ng mga paraan ng pagbasa at pagsulat dito

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

Siyempre, hindi ito isang pagpapatupad ng mga interface ng InputStream at OutputStream, ngunit ito ay halos magkapareho.

"Oo, naiintindihan ko. Kaya paano mo ise-save ang mga nilalaman ng naturang bagay sa isang file?"

"Hayaan mong bigyan kita ng isang halimbawa:"

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! Ito ay talagang katulad ng pagtatrabaho sa InputStream/OutputStream. Ang mga stream ay matamis!"

"At pagkatapos ay ilan!"