ජාවා තුල යෙදෙන I/O Streams යනු මොනවාද | Java I/O Streams

සියලුම පරිගණක භාෂාවන් හි Input සහ Output ක්‍රියාවලීන් සිදුකර ගැනීමට කිසියම් යාන්ත්‍රණයක් පවතිනවා. උදාහරණයක් වශයෙන් කිසියම් calculation එකක් සඳහා ලියන ලද පරිගණක  වැඩසටහනකට දත්ත input කිරීමට සහ එහි ප්‍රතිඵලය පිටතට ලබාදීම සඳහා යොදාගන්නා ක්‍රම සැලකිය හැකිය.

ජාවා වැඩසටහන් තුලදී Input සහ Output ක්‍රියාවලීන් සිදුකරගැනීමට විවිධ ක්‍රම පවතී ඒවා නම් Streams, Files, Channels යනාදී වශයෙනි. අපි මෙහිදී වැඩිදුරටත් සාකච්ඡා කරනුයේ ජාවා තුල යෙදෙන Streams පිලිබඳවයි.

ස්ට්‍රීම්(Streams) මගින් විවිධ Input සහ Output Sources(ප්‍රභව) නියෝජනය වීම සිදුකෙරේ. එනම් පරිගණක ක්‍රමලේඛකයාට streams භාවිතයෙන් input / output sources සමග සන්නිවේදනය කල හැකිය.  උදාහරණ ලෙස Disk Files, Sockets, Devices සහ වෙනත් Process එකක් වුවත් විය හැකිය.

අපි දැන් බලමු ස්ට්‍රීම් එකක ස්වභාවය කුමක්ද කියල. ස්ට්‍රීම් එකක් කිව්වම අපිට එකපාරට මතක් වෙන්නෙ ගලාගෙන යන ස්වභාවය නේ. ඒ වගේම තමයි ස්ට්‍රීම් එකක තිබෙන්නෙ කිසියම්  දත්ත ප්‍රවාහයක් ජාව තුල ස්ට්‍රීම් භාවිතයේදී එම ප්‍රවාහය මූලික දත්ත ආකාරයෙන් පැවතිය හැකියි නැතිනම් එම ප්‍රවාහය Object data ප්‍රවාහයක් උනත් විය හැකියි.  Stream එකක පවතින්නේ data sequence එකක්.

උදා: Binary stream එකක්

1000100010000000000100

පරිගණන වැඩසටහන් මගින් Data Source එකක් ප්‍රවේශනය කිරීමේදී(Access) සිදුවන ක්‍රියාවලිය පහත පරිදි රුපමය වශයෙන් පෙන්විය හැකිය.

Input Stream  එකක් ක්‍රියාකරන අයුරු

Output Stream  එකක් ක්‍රියාකරන අයුරු

*කහ පාටින් දැක්වෙන්නේ Stream එකයි.

ඇතැම් ස්ට්‍රීම් එතුලින් දත්ත ගමන් කරවීමට සහය දක්වන අතර(උදා : FileInputStream,) ඇතැම් ඒවා එතුලින් යන දත්ත වෙනත් ආකාරයකට/ස්වභාවයකට පත්කරනු ලබයි(උදා: GZIPInputStream, DeflaterOutputStream).

Streams තුලින් යවන්නාවූ දත්ත වල ස්වභාවය අනුව මූලික වශයෙන් ස්‍ර්ටීම් වර්ග 2ක් හඳුනාගත හැකිය. 

• Character Streams

මෙමගින් මිනිසාට කියවිය හැකි ආකාරයේ දත්ත ගලා යාම සිදුකෙරේ(උදා : ඉලක්කම්, අකුරු යනාදිය)

• Byte Streams

මේවායේ යවනුයේ machine-formatted ආකාරයේ දත්තවේ. මේවා පවතිනුයේ ද්වීමය(binary) ආකාරයෙනි(උදා:110110).

අදාලතාවය අනුව සුදුසු Stream ආකාරය තෝරාගත යුතුය. අනෙකුත් සියලුම ස්ට්‍රීම් වර්ගයන්හි පදනම වනුයේ Byte Stream වේ.

සුදුසු Stream එක තෝරාගන්නේ කෙසේද?

• කිසියම් data source එකක් low-level මට්ටමෙන් ප්‍රවේශනය කිරීමට අවශ්‍ය විට byte stream එක සුදුසුය.උදා: data file copy කිරීම, Audio files edit කිරීම යනාදියේදී. 
• Data source එක text data වලින් සමන්විත නම් සහ text manipulations  අවශ්‍ය විටදී character streams භාවිතාකල හැකිය.

ජාවා වැඩසටහනක් තුල මෙම ස්ට්‍රීම් භාවිතා වන්නේ කේසේදැයි අපි දැන් බලමු.

මුලින්ම බලමු character stream කියවීමට FileReader යොදාගන්නා අයුරු.

view plaincopy to clipboardprint?

1. /**       
2. *class  : CharOperations 
3. *Author : Kanishka Dilshan       
4. *Purpose: Showing how to use character streams 
5. *Blog   : http://javaxclass.blogspot.com       
6. */   
7.   
8.   
9. import java.io.*;  
10.   
11. public class CharOperations{  
12.  public static void main(String args[]){  
13.   FileReader fileRdr=null;  
14.   FileWriter fileWr=null;  
15.   try{  
16.    fileRdr=new FileReader("myCharFile.txt");  
17.    fileWr=new FileWriter("newCharFile.txt");  
18.    int tmp;  
19.    while((tmp=fileRdr.read())!=-1){  
20.     fileWr.write(tmp);  
21.    }  
22.   }catch(FileNotFoundException e){  
23.    System.err.println("File NOt Found : " + e.getMessage());  
24.   }catch(IOException e){  
25.    System.err.println("IO Exception : " + e.getMessage());  
26.   }finally {  
27.    try{  
28.     if(fileRdr!=null){  
29.      fileRdr.close();  
30.     }  
31.       }catch(IOException e){}  
32.    try{     
33.     if(fileWr!=null){  
34.      fileWr.close();  
35.     }  
36.    }catch(IOException e){}  
37.   }  
38.  }  
39. }  

/**      
*class  : CharOperations
*Author : Kanishka Dilshan      
*Purpose: Showing how to use character streams
*Blog   : http://javaxclass.blogspot.com      
*/ 


import java.io.*;

public class CharOperations{
 public static void main(String args[]){
  FileReader fileRdr=null;
  FileWriter fileWr=null;
  try{
   fileRdr=new FileReader("myCharFile.txt");
   fileWr=new FileWriter("newCharFile.txt");
   int tmp;
   while((tmp=fileRdr.read())!=-1){
    fileWr.write(tmp);
   }
  }catch(FileNotFoundException e){
   System.err.println("File NOt Found : " + e.getMessage());
  }catch(IOException e){
   System.err.println("IO Exception : " + e.getMessage());
  }finally {
   try{
    if(fileRdr!=null){
     fileRdr.close();
    }
      }catch(IOException e){}
   try{   
    if(fileWr!=null){
     fileWr.close();
    }
   }catch(IOException e){}
  }
 }
}

පැහැදිලි කිරීම:

FileReader සහ FileWriter යනු පිලිවෙලින් myCharFile.txt සහ newCharFile.txt ට ලිවීමට තෝරාගත් Stream classes වේ. ඒවායින් සාදාගත් fileRdr සහ fileWr objects යොදාගෙන source file එකෙන් කියවීම සහ destination file එකට ලිවීම සිදුකෙරේ. මේවා character streams නිසා කියවීම සහ ලිවීම සිදුකරනුයේ character ආකාරයට ය. while loop එක තුලදී සිදුකෙරෙනුයේ input stream එකෙන් character by character කියවා output stream එකට character by character ලිවීමයි.

එහිදී while loop එකේ condition එක වශයෙන් යොදා ඇත්තේ කියවන ලද character එකෙහි integer අගය -1 ට සමානදැයි බැලීමයි. එම කියවන ලද අගය -1 නම් එයින් සඳහන් වනුයේ අප සිටින්නේ EOF(End of the file) හි  බවය(ෆයිල් එකෙහි අවසානයේ බවය). මේවා try block එකක් තුල යෙදීමට හේතුව ස්ට්‍රීම් සමග ගනුදෙනු කිරීමේදී පැනනැගිය හැකි exception හසුකර ගැනීමයි.(Exception පිලිබඳ මීට පෙර සාකච්ඡා කර තිබේ).  අවසානයේ open කරගන්නා ලද ස්ට්‍රීම් වසාදැමීම සිදුකර ඇත.( line 29 සහ line 34) මෙසේ ස්ට්‍රීම් close කිරීම අනිවාර්යයෙන්ම කල යුත්තකි. නැතහොත් අප ලියන වැඩසටහන් වල resource leaks ඇතිවීමට හේතුවේ. එය වැඩසටහනක ඇති විශාල ගැටලුවකි.