உள்ளீடு/வெளியீடு ஸ்ட்ரீம்கள்

"வணக்கம், அமிகோ! இன்று நாம் உள்ளீடு/வெளியீட்டு ஸ்ட்ரீம்களைப் பற்றி அறிந்து கொள்வோம் . சில நாட்களுக்கு முன்பு இந்தத் தலைப்பைத் தேர்ந்தெடுத்தோம், ஆனால் இன்று அதை முழுமையாக ஆராய்வோம். உள்ளீடு/வெளியீட்டு ஸ்ட்ரீம்கள் 4 வகைகளாகப் பிரிக்கப்பட்டுள்ளன:"

1) ஸ்ட்ரீம்கள் அவற்றின் திசையின்படி பிரிக்கப்படுகின்றன: உள்ளீடு ஸ்ட்ரீம்கள் மற்றும் வெளியீடு ஸ்ட்ரீம்கள்

2) ஸ்ட்ரீம்கள் அவற்றின் தரவு வகைக்கு ஏற்ப பிரிக்கப்படுகின்றன: பைட்டுகளுடன் வேலை செய்யும் மற்றும் எழுத்துகளுடன் வேலை செய்யும் .

இங்கே இந்த பிரிவுகள் ஒரு அட்டவணையில் குறிப்பிடப்படுகின்றன:

ஒரு பொருள் InputStream இடைமுகத்தை செயல்படுத்தினால் , அதிலிருந்து பைட்டுகளை தொடர்ச்சியாக படிக்கும் திறனை அது ஆதரிக்கிறது.

ஒரு பொருள் OutputStream இடைமுகத்தை செயல்படுத்தினால் , அதற்கு பைட்டுகளை தொடர்ச்சியாக எழுதும் திறனை அது ஆதரிக்கிறது.

ஒரு பொருள் ரீடர் இடைமுகத்தை செயல்படுத்தினால் , அதிலிருந்து எழுத்துக்களை (எழுத்துக்களை) தொடர்ச்சியாக படிக்கும் திறனை அது ஆதரிக்கிறது.

ஒரு பொருள் ரைட்டர் இடைமுகத்தை செயல்படுத்தினால் , அது எழுத்துக்களை (எழுத்துக்கள்) தொடர்ச்சியாக எழுதும் திறனை ஆதரிக்கிறது.

ஒரு வெளியீடு ஸ்ட்ரீம் ஒரு பிரிண்டர் போன்றது. நாம் அச்சுப்பொறிக்கு ஆவணங்களை வெளியிடலாம். நாம் ஒரு வெளியீட்டு ஸ்ட்ரீமில் தரவை வெளியிடலாம்.

அதன் பங்கிற்கு, ஒரு உள்ளீட்டு ஸ்ட்ரீமை ஸ்கேனருடன் ஒப்பிடலாம், அல்லது ஒருவேளை ஒரு மின் நிலையத்துடன் ஒப்பிடலாம். ஸ்கேனர் மூலம், நம் கணினியில் ஆவணங்களைக் கொண்டு வரலாம். அல்லது ஒரு மின் நிலையத்தில் செருகி அதிலிருந்து மின்சாரத்தைப் பெறலாம். உள்ளீட்டு ஸ்ட்ரீமில் இருந்து தரவைப் பெறலாம்.

"அவை எங்கே பயன்படுத்தப்படுகின்றன?"

"இந்த வகுப்புகள் ஜாவாவில் எல்லா இடங்களிலும் பயன்படுத்தப்படுகின்றன. நமது பழக்கமான நண்பர் System.in என்பது சிஸ்டம் வகுப்பில் பெயரிடப்பட்ட நிலையான இன்புட்ஸ்ட்ரீம் மாறியாகும் . "

"சரியாகவா?! இவ்வளவு நேரம் நான் இன்புட் ஸ்ட்ரீமைப் பயன்படுத்துகிறேன், அதைக் கூட உணரவில்லை. System.out ஒரு ஸ்ட்ரீமா?"

"ஆம், System.out என்பது கணினி வகுப்பில் நிலையான பிரிண்ட்ஸ்ட்ரீம் ( அவுட்புட்ஸ்ட்ரீமின் வழித்தோன்றல் ) மாறி."

"நான் எப்பொழுதும் ஸ்ட்ரீம்களைப் பயன்படுத்துகிறேன், அது எனக்குத் தெரியாது என்று நீங்கள் கூறுகிறீர்களா?"

"ஆம், இந்த நீரோடைகள் எவ்வளவு வசதியானவை என்பதை அது நமக்குத் தெரிவிக்கிறது. நீங்கள் ஒன்றைப் பிடித்து அதைப் பயன்படுத்துங்கள்."

"ஆனால் System.in பற்றி நீங்கள் அப்படிச் சொல்ல முடியாது. நாங்கள் தொடர்ந்து அதில் BufferedReader அல்லது InputStreamReader ஐச் சேர்க்க வேண்டியிருந்தது."

"அது உண்மைதான். ஆனால் அதற்கான காரணங்களும் இருந்தன."

நிறைய தரவு வகைகள் உள்ளன, மேலும் அவற்றுடன் பணிபுரிய பல வழிகள் உள்ளன. எனவே நிலையான I/O வகுப்புகளின் எண்ணிக்கை மிக விரைவாக வளர்ந்தது, இருப்பினும் அவை எல்லாவற்றையும் கிட்டத்தட்ட ஒரே மாதிரியாகச் செய்தன. இந்த சிக்கலைத் தவிர்க்க, ஜாவா டெவலப்பர்கள் சுருக்கக் கொள்கையைப் பயன்படுத்தினர் மற்றும் வகுப்புகளை பல சிறிய பகுதிகளாகப் பிரித்தனர்.

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

System.out.println("Hello");

PrintStream console = System.out;
console.println("Hello");

ByteArrayOutputStream stream = new ByteArrayOutputStream();
PrintStream console = new PrintStream(stream);
console.println("Hello");

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

"அதைப்பற்றி இப்போதைக்கு கவலைப்பட வேண்டாம். எல்லாம் அதன் சொந்த நேரத்தில்."

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

"சரி. அப்புறம் எங்கிருந்து ஆரம்பிப்பது?"