"Magsisimula tayo sa mga stream para sa input/output ng file. Pero una muna."

Mayroong dalawang klase para sa pagbabasa at pagsusulat ng mga file: FileInputStream at FileOutputStream . Tulad ng malamang na nahulaan mo na, ang FileInputStream ay maaaring sunud-sunod na magbasa ng mga byte mula sa isang file, at ang FileOutputStream ay maaaring sunud-sunod na magsulat ng mga byte sa isang file. Narito ang mga pamamaraan na mayroon ang mga klase na ito:

Pamamaraan Ano ang ginagawa ng pamamaraan 
FileInputStream(String fileName);
 — Ito ang tagabuo. Hinahayaan ka nitong tukuyin ang pangalan ng isang file sa disk, kung saan magbabasa ng data ang nilikhang bagay. 
int read();
 — Ang pamamaraang ito ay nagbabasa ng isang byte mula sa file at ibinabalik ito. Ang halaga ng pagbabalik ay pinalawak sa isang int. 
int available();
 — Ibinabalik ng paraang ito ang bilang ng mga hindi pa nababasa (available) byte. 
void close();
 — Ang pamamaraang ito ay «nagsasara» sa batis. Tawagan mo ito kapag tapos ka nang magtrabaho sa stream.
Isinasagawa ng object ang mga operasyong housekeeping na kailangan para isara ang file, atbp.
Sa puntong ito, hindi ka na makakapagbasa ng anumang data mula sa stream.
Java university

Para lamang sa kasiyahan nito, kalkulahin natin ang kabuuan ng lahat ng mga byte sa isang file. Narito ang hitsura ng code:

Isama ang lahat ng mga byte sa isang file 
public static void main(String[] args) throws Exception
{
 //Create a FileInputStream object bound to «c:/data.txt».
 FileInputStream inputStream = new FileInputStream("c:/data.txt");
 long sum = 0;

 while (inputStream.available() > 0) //as long as there are unread bytes
 {
  int data = inputStream.read(); //Read the next byte
  sum +=  data; //Add it to the running total
 }
 inputStream.close(); // Close the stream

 System.out.println(sum); // Display the sum on the screen.
}

"Napagmasdan na namin ang isang bagay na tulad nito. Paano nakaayos ang FileOutputStream?"

"OK. Tingnan mo ito:"

Pamamaraan Ano ang ginagawa ng pamamaraan 
FileOutputStream (String fileName);
 "Ito ang constructor. Hinahayaan ka nitong tukuyin ang pangalan ng isang file sa disk, kung saan magsusulat ng data ang nilikhang bagay." 
void write(int data);
 "Isinulat ng paraang ito ang susunod na byte, pinuputol ang data sa isang byte." 
void flush();
 "Ang data na isusulat ay kadalasang unang kinokolekta sa malalaking bloke sa memorya, at pagkatapos ay isusulat lamang sa disk."

Pinipilit ng flush command na maisulat sa disk ang lahat ng hindi na-save na impormasyon.

 
void close();
 "Isinasara" ng pamamaraang ito ang stream. Tatawagin mo ito kapag tapos ka nang magtrabaho sa stream."
Ang bagay ay pagkatapos ay nagsasagawa ng mga pagpapatakbo ng housekeeping na kinakailangan upang isara ang file, atbp.

Hindi ka na makakasulat ng data sa stream, at awtomatikong tinatawag ang flush.

"Ayan yun?"

"Oo, mayroon lang talagang isang paraan para sa pagsusulat: write(). Nagsusulat lamang ito ng isang byte sa isang pagkakataon. Ngunit hinahayaan ka nitong magsulat ng maraming impormasyon hangga't gusto mo sa file."

Ang programming ay isang proseso ng paghahati ng isang malaki at kumplikadong gawain sa maraming maliliit. Sa esensya ang parehong proseso ay nangyayari dito: ang pagbabasa at pagsusulat ng malalaking bloke ng data ay nahahati sa pagbabasa at pagsusulat sa kagat-laki ng mga piraso—isang byte sa bawat pagkakataon.

Narito kung paano mo magagamit ang mga klase na ito para kumopya ng file sa disk:

Kopyahin ang isang file sa disk 
public static void main(String[] args) throws Exception
{
 //Create a stream to read bytes from a file
 FileInputStream inputStream = new FileInputStream("c:/data.txt");
 //Create a stream to write bytes to a file
 FileOutputStream outputStream = new FileOutputStream("c:/result.txt");

 while (inputStream.available() > 0) //as long as there are unread bytes
 {
  int data = inputStream.read(); // Read the next byte into the data variable
  outputStream.write(data); // and write it to the second stream
 }

 inputStream.close(); //Close both streams. We don't need them any more.
 outputStream.close();
}

"Salamat, Rishi. Sa wakas naiintindihan ko na kung paano gumagana ang code na ito."