ஜாவாவில் உள்ளீடு/வெளியீடு. FileInputStream, FileOutputStream மற்றும் BufferedInputStream வகுப்புகள்

"வணக்கம்! இன்றைய பாடத்தில், ஜாவாவில் உள்ள உள்ளீடு மற்றும் வெளியீட்டு ஸ்ட்ரீம்கள் பற்றிய எங்கள் உரையாடலைத் தொடர்வோம் ( Java I/O ). இது இந்தத் தலைப்பில் முதல் பாடம் அல்ல, நிச்சயமாக இது கடைசி பாடமாக இருக்காது :) ஜாவா மொழி I/O உடன் பணிபுரிய பல வழிகளை வழங்குகிறது. இந்தச் செயல்பாட்டைச் செயல்படுத்தும் சில வகுப்புகள் உள்ளன, எனவே அவற்றைப் பல பாடங்களாகப் பிரித்துள்ளோம் — எனவே நீங்கள் தொடக்கத்தில் இருந்து குழப்பமடைய மாட்டீர்கள் :) கடந்த காலத்தில் பாடங்கள், BufferedReaderமற்றும் InputStreamசுருக்க வகுப்புகள் மற்றும் பல வழித்தோன்றல்களை நாங்கள் தொட்டோம் OutputStream. இன்று நாம் 3 புதிய வகுப்புகளைக் கருத்தில் கொள்வோம்: FileInputStream,  FileOutputStream, மற்றும்  BufferedInputStream.

FileOutputStream வகுப்பு

வகுப்பின் முக்கிய நோக்கம் FileOutputStreamஒரு கோப்பில் பைட்டுகளை எழுதுவதாகும். சிக்கலான எதுவும் இல்லை :) FileOutputStreamஎன்பது சுருக்க வகுப்பின் செயலாக்கங்களில் ஒன்றாகும் OutputStream. கட்டமைப்பாளரில், இந்த வகுப்பின் பொருள்கள் இலக்கு கோப்பிற்கான பாதையை (பைட்டுகள் எழுதப்பட வேண்டிய இடத்தில்) அல்லது ஒரு Fileபொருளை எடுக்கின்றன. ஒவ்வொன்றின் உதாரணங்களையும் நாங்கள் ஆராய்வோம்:

public class Main { 

   public static void main(String[] args) throws IOException { 

       File file = new File("C:\\Users\\Username\\Desktop\\test.txt"); 
       FileOutputStream fileOutputStream = new FileOutputStream(file); 

       String greetings = "Hi! Welcome to CodeGym — The best site for would-be programmers!"; 

       fileOutputStream.write(greetings.getBytes()); 
       fileOutputStream.close(); 
   } 
}

பொருளை உருவாக்கும் போது File, ​​நாம் விரும்பிய பாதையை கட்டமைப்பாளருக்கு அனுப்பினோம். நாங்கள் அதை முன்கூட்டியே உருவாக்க வேண்டியதில்லை: அது இல்லை என்றால், நிரல் அதை உருவாக்கும். கூடுதல் பொருளை உருவாக்காமல், பாதையுடன் ஒரு சரத்தைக் கடந்து செல்லலாம்:

public class Main { 

    public static void main(String[] args) throws IOException { 

       FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Username\\Desktop\\test.txt"); 
       String greetings = "Hi! Welcome to CodeGym — The best site for would-be programmers!"; 

       fileOutputStream.write(greetings.getBytes()); 
       fileOutputStream.close(); 
   } 
} 

இரண்டு நிகழ்வுகளிலும் முடிவு ஒரே மாதிரியாக இருக்கும். நாங்கள் எங்கள் கோப்பைத் திறந்து பின்வருவனவற்றைக் காணலாம்:

Hi! Welcome to CodeGym — The best site for would-be programmers!

ஆனால் இங்கே ஒரு நுணுக்கம் உள்ளது. மேலே உள்ள எடுத்துக்காட்டில் உள்ள குறியீட்டை தொடர்ச்சியாக பல முறை இயக்க முயற்சிக்கவும். கோப்பினைப் பார்த்து, இந்த கேள்விக்கு பதிலளிக்கவும்: அதில் எத்தனை வரிகள் உள்ளன? ஒன்று மட்டும். ஆனால் நீங்கள் பல முறை குறியீட்டை இயக்கியுள்ளீர்கள். ஒவ்வொரு முறையும் தரவு மேலெழுதப்படுகிறது - பழையது புதியதாக மாற்றப்படுகிறது. அது நமக்குப் பொருந்தவில்லை என்றால், கோப்பில் வரிசையாக எழுத வேண்டும் என்றால் என்ன செய்வது? ஒரு கோப்பில் தொடர்ச்சியாக மூன்று முறை வாழ்த்து எழுத விரும்பினால் என்ன செய்வது? இது எல்லாம் மிகவும் எளிமையானது. ஒவ்வொரு சந்தர்ப்பத்திலும் நமக்கு என்ன நடத்தை தேவை என்பதை மொழி அறிய முடியாது என்பதால், FileOutputStreamகன்ட்ரக்யூட்டர் கூடுதல் அளவுருவை எடுக்கலாம் —boolean append. அதன் மதிப்பு உண்மையாக இருந்தால், தரவு கோப்பின் முடிவில் எழுதப்படும். அது தவறானதாக இருந்தால் (இயல்புநிலையாக இது தவறானது), பழைய தரவு அழிக்கப்பட்டு புதிய தரவுகளால் மாற்றப்படும். எங்கள் மாற்றியமைக்கப்பட்ட குறியீட்டை மூன்று முறை இயக்குவதன் மூலம் இதைச் சரிபார்க்கலாம்:

public class Main { 

   public static void main(String[] args) throws IOException { 

       FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\Username\\Desktop\\test.txt", true); 
       String greetings = "Hi! Welcome to CodeGym — The best site for would-be programmers!\r\n"; 

       fileOutputStream.write(greetings.getBytes()); 
       fileOutputStream.close(); 
   } 
} 

கோப்பு உள்ளடக்கங்கள்:

Hi! Welcome to CodeGym — The best site for would-be programmers! 
Hi! Welcome to CodeGym — The best site for would-be programmers! 
Hi! Welcome to CodeGym — The best site for would-be programmers!

இப்போது அது வேறு! I/O வகுப்புகளைப் பயன்படுத்தும் போது இந்த அம்சத்தைப் பற்றி மறந்துவிடாதீர்கள். நான் பணிகளில் மணிநேரம் செலவழித்த ஒரு காலம் இருந்தது, என் மூளையை மணிக்கணக்கில் அலைக்கழித்தேன், கோப்புகளிலிருந்து எனது தரவு எவ்வாறு மறைகிறது என்பதைப் புரிந்துகொள்ள முயற்சித்தேன் :) நிச்சயமாக, மற்ற I/O வகுப்புகளைப் போலவே, இந்த முறையைப் பயன்படுத்த மறக்காதீர்கள் close(). இலவச வளங்களுக்கு.

FileInputStream வகுப்பு

இதற்கு FileInputStreamஎதிர் நோக்கம் உள்ளது - ஒரு கோப்பிலிருந்து பைட்டுகளைப் படிக்கிறது. FileOutputStreamமரபுரிமையைப் போலவே OutputStream, இந்த வர்க்கம் சுருக்க வகுப்பிலிருந்து பெறப்படுகிறது InputStream. எங்கள் " test.txt " கோப்பில் சில வரிகளை எழுதுவோம் :

"So close no matter how far 
Couldn't be much more from the heart 
Forever trusting who we are 
And nothing else matters"

இதைப் பயன்படுத்தி ஒரு கோப்பிலிருந்து தரவைப் படிப்பது எப்படி இருக்கும் FileInputStream:

public class Main { 

   public static void main(String[] args) throws IOException { 

       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\test.txt"); 

       int i; 

       while((i=fileInputStream.read())!= -1){ 

           System.out.print((char)i); 

       } 
   } 
}

கோப்பிலிருந்து ஒரு பைட்டைப் படித்து, படித்த பைட்டுகளை எழுத்துகளாக மாற்றி அவற்றை கன்சோலில் காண்பிக்கிறோம். இதோ கன்சோல் வெளியீடு:

So close no matter how far 
Couldn't be much more from the heart 
Forever trusting who we are 
And nothing else matters

BufferedInputStream வகுப்பு

BufferedInputStreamகடந்த காலப் பாடங்களின் அறிவைக் கொண்டு, எங்களுக்கு ஏன் வகுப்பு தேவை என்பதையும், அதனுடன் ஒப்பிடும்போது என்ன நன்மைகள் உள்ளன என்பதையும் நீங்கள் எளிதாகச் சொல்லலாம் என்று நினைக்கிறேன் FileInputStream:) நாங்கள் ஏற்கனவே இடையக ஸ்ட்ரீம்களை எதிர்கொண்டுள்ளோம், எனவே நீங்கள் தொடர்ந்து படிக்கும் முன் யூகிக்க முயற்சிக்கவும் (அல்லது நினைவில் கொள்ளவும்) :) முக்கியமாக I/O ஐ மேம்படுத்துவதற்கு இடையக ஸ்ட்ரீம்கள் தேவை. ஒரு கோப்பிலிருந்து படிப்பது போன்ற தரவு மூலத்தை அணுகுவது செயல்திறன் அடிப்படையில் ஒரு விலையுயர்ந்த செயலாகும், மேலும் ஒவ்வொரு பைட்டையும் படிக்க ஒரு கோப்பை அணுகுவது வீணானது. அதனால்தான் BufferedInputStreamதரவை ஒரு நேரத்தில் ஒரு பைட் அல்ல, ஆனால் தொகுதிகளில் படிக்கிறது, மேலும் அவற்றை தற்காலிகமாக ஒரு சிறப்பு இடையகத்தில் சேமிக்கிறது. நாம் கோப்பை அணுகும் எண்ணிக்கையைக் குறைப்பதன் மூலம் நிரலை மேம்படுத்த இது உதவுகிறது. இது எப்படி இருக்கும் என்று பார்ப்போம்:

public class Main { 

   public static void main(String[] args) throws IOException { 

       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\test.txt"); 

       BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream, 200); 

       int i; 

       while((i = bufferedInputStream.read())!= -1){ 

           System.out.print((char)i); 
       } 
   } 
} 

இங்கே நாம் ஒரு BufferedInputStreamபொருளை உருவாக்கினோம். InputStreamஅதன் கன்ஸ்ட்ரக்டர் வர்க்கம் அல்லது அதன் சந்ததியினரின் உதாரணத்தை எடுத்துக்கொள்கிறார் , அதனால் FileInputStreamசெய்வார். கூடுதல் வாதமாக, இது இடையக அளவை பைட்டுகளில் எடுக்கும். இந்த வாதத்திற்கு நன்றி, தரவு இப்போது கோப்பிலிருந்து ஒரு நேரத்தில் ஒரு பைட் அல்ல, ஆனால் ஒரு நேரத்தில் 200 பைட்டுகள் படிக்கப்படும்! கோப்பு அணுகல்களின் எண்ணிக்கையை எவ்வளவு குறைத்துள்ளோம் என்று கற்பனை செய்து பாருங்கள். FileInputStreamசெயல்திறனை ஒப்பிட்டுப் பார்க்க, நீங்கள் ஒரு பெரிய உரைக் கோப்பை எடுத்து (பல மெகாபைட் உரை) மற்றும் பயன்படுத்தி கன்சோலைப் படித்து வெளியிடுவதற்கு மில்லி விநாடிகளில் எவ்வளவு நேரம் ஆகும் என்பதை ஒப்பிடலாம் BufferedInputStream. இரண்டு விருப்பங்களையும் நிரூபிக்கும் குறியீடு இங்கே:

public class Main { 

   public static void main(String[] args) throws IOException { 

       Date date = new Date(); 

       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\textBook.rtf"); 
       BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream); 

       int i; 
       while((i = bufferedInputStream.read())!= -1){ 

           System.out.print((char)i); 
       } 

       Date date1 = new Date(); 
       System.out.println((date1.getTime() - date.getTime())); 
   } 
} 

 
public class Main { 

   public static void main(String[] args) throws IOException { 

       Date date = new Date(); 
       FileInputStream fileInputStream = new FileInputStream("C:\\Users\\Username\\Desktop\\26951280.rtf"); 

       int i; 
       while((i = fileInputStream.read())!= -1){ 

           System.out.print((char)i); 
       } 


       Date date1 = new Date(); 
       System.out.println((date1.getTime() - date.getTime())); 
   }
}

எனது கணினியில் 1.5 MB கோப்பைப் படிக்கும் போது, FileInputStream​​வேலையை ~3500 மில்லி விநாடிகளில் முடித்தேன், ஆனால் BufferedInputStreamஅதை ~1700 மில்லி விநாடிகளில் நிர்வகித்தேன். நீங்கள் பார்க்க முடியும் என, இடையக ஸ்ட்ரீம் வேலையை மேம்படுத்தியது, அதை பாதியாக குறைத்தது! :) I/O வகுப்புகளை தொடர்ந்து படிப்போம் — விரைவில் சந்திப்போம்!