Buffered Stream යොදාගෙන File Copy කරන අන්දම

අපි මීට පෙර පාඩමෙන් Buffered stream පිලිබඳව අධ්‍යයනය කලා. අපි මෙම පාඩමෙන් එම සිද්ධාන්ත යොදාගනිමින් File copy කිරීම සඳහා වැඩසටහනක් ලිවීමට උත්සාහ කරමු. මේ සඳහා අපි එම buffered stream classes තුල ඇති read() ,write() , flush(), close() යන methods භාවිතයට ගනිමු. පහත දැක්වෙන්නේ ඒ සඳහා වන කේත කොටසයි.
FileOperations.java

/**       
*class  : FileOperations 
*Author : Kanishka Dilshan       
*Purpose: Using buffered Streams to copy a file  
*Blog   : http://javaxclass.blogspot.com       
*/ 

import java.io.*;

class FileOperations {
 public static final int BUFF_SIZE=8*1024*1024;//8 MB
 
 public boolean fileCopy(String source,String dest){
  boolean isCopied=false;
  BufferedInputStream buffIn=null;
  BufferedOutputStream buffOut=null;
  byte buffer[]=new byte[BUFF_SIZE];
  try{
   buffIn=new BufferedInputStream(new FileInputStream(source),8*1024*1024);
   buffOut=new BufferedOutputStream(new FileOutputStream(dest),8*1024*1024);
   
   int len;
   while((len=buffIn.read(buffer))>0){
    buffOut.write(buffer,0,len);
    buffOut.flush();
   }
   isCopied=true; //file copied successfully
  }catch(FileNotFoundException e){
   System.err.println("Cannot find the file : " + e.getMessage());
  }catch(IOException e){
   System.err.println("IO Error : " + e.getMessage());
  }finally{
   if(buffIn!=null){
    try{
     buffIn.close();
    }catch(IOException e){}
   }   
   if(buffOut!=null){
    try{
     buffOut.close();
    }catch(IOException e){}
   }
  }
  return isCopied;
 }
}  

FileCopy.java

class FileCopy{
 public static void main(String args[]){
  if(args.length!=2){
   System.out.println("Incorrect syntax!");
   System.out.println("Use Following Syntax");
   System.out.println("java FileCopy #source_file# #estination_file#");
   System.exit(0);
  }
  
  FileOperations fo=new FileOperations();
  boolean status=fo.fileCopy(args[0],args[1]);
  if(status==true){
   System.out.println("File was copied successfully!");
  }else{
   System.out.println("File was not copied");
  }
  
 }
}

අපි දැන් ඉහත වැඩසටහනේ ක්‍රියාකාරීත්වය අධ්‍යයනය කරමු.
Line 11 : මෙහිදී BUFF_SIZE ලෙස 8MB constant අගයක් declare කර ගැනීම සිදුකෙරෙනවා. පසුව  buffer එකේ ඇතිදෑ කියවීමට සහ buffer එකට ලිවීමට මෙම constant අගයට අනුව සකසන byte array එකක් යොදාගනු ලබනවා.

Line 12 : boolean isCopied=false; මෙය යොදාගන්නේ file එක සාර්ථකව කොපි වූවාද නැද්ද යන්න return කිරීම සඳහායි.

Line 17 : byte buffer[]=new byte[BUFF_SIZE]; මෙහිදී 8MB ප්‍රමාණයකින් යුතු "buffer" නම් byte array එකක් සකසාගනු ලැබේ.

Line 19, 20 : buffIn සහ buffOut යනුවෙන් buffered stream object 2ක් සකසාගනු ලැබේ(class type සලකා බලන්න) මින් buffIn object එක යොදාගනුයේ source file එක කියවීමටය. එමෙන්ම buffOut යොදාගනුයේ destination file එකට ලිවීමටය. මෙම object සැදිමේදී ඒවාට අදාල buffer size එකද විශේෂයෙන් සඳහන් කර ඇත.

Line 23 : මෙම while loop එක තුලදී මූලිකවම කාර්‍යයන් 2 ක් සිදුකෙරේ len=buffIn.read(buffer) මගින් සිදුකරන්නේ input stream එකෙන් කියවන ලද අගයන් buffer නම් byte array එකේ store කර len නම් int විචල්‍යය තුල කියවන ලද ඩේටා ප්‍රමාණය assign කිරීමයි. 

එහිදී සිදුකරන අනෙකුත් කාර්‍යය නම් එම කියවන ලද ඩේටා ප්‍රමාණය 0 ට වඩා වැඩිද යන්න පරීක්ෂා කර බැලීමයි. කියවන ලද ඩේටා ප්‍රමාණය -1 ලෙස ලැබේ නම් ඉන් ගම්‍ය වනුයේ stream එකෙහි අවසානයට ලඟාවී ඇති බවයි නැතහොත් end of file(EOF) බවයි මෙවිට output stream එකට ලිවීමට අවශ්‍ය නැත. කියවන ලද ඩේටා ප්‍රමාණය 0 නම්ද output stream එකට ලිවීමට අවශ්‍ය නැත.  එම නිසා (len=buffIn.read(buffer))>0 නම් condition එක true නම් පමණක් while loop එක ක්‍රියාත්මකවේ.

Line 24 : buffOut.write(buffer,0,len);   මෙහිදී සිදුකරනුයේ කියවන ලද ඩේටා (byte array එක) output stream එකට ලිවීමයි. 0 සහ len යන parameters වලින් කියවෙනුයේ එම byte array එකේ 0 සිට len යන අගය දක්වා byte ප්‍රමාණය output stream එකට ලිවිය යුතු බවයි.

Line 25 : buffOut.flush(); මෙහිදී output stream එක clear කිරීම සිදුකරයි. 

Line 27 :  while loop එක අවසන් වී මෙම line එකට පැමිණියා යනු file එක සාර්ථකව ලියා අවසන් බවට සහතික විය හැකිය මන්දයත් IO Operations සිදුකර ඇත්තේ exception handle කල හැකි පරිදි try-catch block තුලය. එම නිසා මෙහිදී isCopied නම් විචල්‍යයේ අගය true ලෙස සටහන් කරනු ලැබේ.

Line 32: catch block එක තුලදී සිදුකර ඇති දෑ පහසුවෙන් තේරුම් ගත හැකි නිසා finally block තුලදී කුමක් සිදුවන්නේද යන්න සලකා බලමු. මෙහිදී ඉහත open කරගන්නා ලද input සහ output stream 2ම close කිරීම සිදුකරයි මෙය සිදුකරන්නේ තවත් try-catch block එකක් තුලදීය. 

වැඩසටහන මගින් source file එකේ binary pattern එක ඒ ආකාරයෙන්ම destination file එකේ තිබේ දැයි බැලීමට hash calculator එකක් යොදාගත හැක.

මෙම ක්‍රියාදාමය වටහාගැනීම සඳහා ඉහත පැහැදිලි කිරීම ප්‍රමාණවත් යයි සිතමි. කෙසේ වෙතත් තවදුරටත් පැහැදිලි කල යුතු යමක් ඇත්නම් ඉදිරිපත් කරන මෙන් ඉල්ලා සිටින්න කැමතියි.

ඉහත දක්වා ඇති source code එක සහ byte code files ලබා ගැනීමට පහත දක්වා ඇති link එක භාවිතාකරන්න.