1. InputStreamReader
வர்க்கம்
ஸ்ட்ரீம்களின் மற்றொரு சுவாரஸ்யமான அம்சம் என்னவென்றால், நீங்கள் பல ஸ்ட்ரீம்களை ஒன்றாக சங்கிலிகளாக இணைக்கலாம் . ஒரு ஸ்ட்ரீம் அதன் உள் தரவு மூலத்திலிருந்து மட்டுமல்ல, மற்றொரு ஸ்ட்ரீமிலிருந்தும் தரவைப் படிக்க முடியும் .
இது ஜாவாவில் மிகவும் சக்திவாய்ந்த பொறிமுறையாகும், இது ஒரு ஸ்ட்ரீமை மற்றொரு ஸ்ட்ரீமுடன் இணைப்பதன் மூலம் சிக்கலான தரவு வாசிப்பு காட்சிகளை உருவாக்குவதை சாத்தியமாக்குகிறது. அத்தகைய திட்டம் இதுபோல் தெரிகிறது:
ஒரு நிரல் தரவு ஸ்ட்ரீமில் இருந்து தரவைப் படிக்கும்போது, தரவு ஸ்ட்ரீம் அதன் தரவு மூலத்திலிருந்து தரவைப் படிக்கிறது, இது மற்றொரு தரவு ஸ்ட்ரீம் அல்லது ஒரு கோப்பு, எடுத்துக்காட்டாக.
மேலும் என்னவென்றால், ஒவ்வொரு டேட்டா ஸ்ட்ரீமையும் படித்து தரவை வழங்குவது மட்டுமல்லாமல், அதை மாற்றவும் அல்லது அதில் பல்வேறு செயல்பாடுகளைச் செய்யவும் முடியும். அத்தகைய "இடைநிலை ஸ்ட்ரீம்" ஒரு நல்ல உதாரணம் வர்க்கம் InputStreamReader
.
ஒரு கோப்பில் இருந்து தரவைப் படிக்கும் FileReader
ஒரு வகுப்பை நாங்கள் ஏற்கனவே அறிவோம் . Reader
அதன் தரவு எங்கிருந்து InputStreamReader
கிடைக்கும்? அது சரி - ஒரு இருந்து InputStream
.
நீங்கள் ஒரு பொருளை உருவாக்கும் போது , நீங்கள் ஒரு பொருள் அல்லது அதன் வழித்தோன்றல் வகுப்பில் InputStreamReader
தேர்ச்சி பெற வேண்டும் . InputStream
உதாரணமாக:
String src = "c:\\projects\\log.txt";
FileInputStream input = new FileInputStream(src);
InputStreamReader reader = new InputStreamReader(input);
வகுப்பில் InputStreamReader
உள்ள அனைத்து முறைகளும் வகுப்பில் உள்ளன Reader
, மேலும் அவை அதே வழியில் செயல்படுகின்றன.
வகுப்பிற்கும் இடையே உள்ள முக்கிய வேறுபாடு InputStreamReader
என்னவென்றால், FileReader
அவர்கள் எங்கிருந்து தரவைப் படிக்கிறார்கள் என்பதுதான். FileReader
ஒரு கோப்பிலிருந்து தரவைப் படிக்கிறது (duh — அதனால்தான் இது அழைக்கப்படுகிறது FileReader
), ஆனால் InputStreamReader
ஒரு லிருந்து தரவைப் படிக்கிறது InputStream
.
FileReader
முறையைப் பயன்படுத்தி ஒரு பொருளில் இருந்து ஒரு எழுத்தைப் படிக்கும்போது read()
, அது வட்டில் உள்ள கோப்பிலிருந்து இரண்டு பைட்டுகளைப் படித்து அவற்றை chars
.
InputStreamReader
முறையைப் பயன்படுத்தி ஒரு பொருளில் இருந்து ஒரு எழுத்தைப் படிக்கும்போது read()
, அது அதற்கு அனுப்பப்பட்ட பொருளிலிருந்து இரண்டு பைட்டுகளைப் படிக்கிறது FileInputStream
, இது கோப்பிலிருந்து தரவைப் படிக்கிறது. இதன் விளைவாக முறைகளுக்கான அழைப்புகளின் சங்கிலிread()
உள்ளது .
2. BufferedReader
வர்க்கம்
நீங்கள் அதிகம் பயன்படுத்தக்கூடிய மற்றொரு சுவாரஸ்யமான வகுப்பு BufferedReader
. இது மற்றொரு ஸ்ட்ரீமில் இருந்து தரவைப் படிக்கும் "இடைநிலை ஸ்ட்ரீம்" ஆகும்.
அதன் பெயர் குறிப்பிடுவது போல, BufferedReader
வகுப்பு என்பது ஒரு துணைப்பிரிவாகும் Reader
மற்றும் எழுத்துக்களைப் படிக்க உங்களை அனுமதிக்கிறது . ஆனால் மிகவும் சுவாரசியமான விஷயம் என்னவென்றால், நீங்கள் அதை ஒரு தரவு மூலத்தை ஒரு ஸ்ட்ரீம் வடிவத்தில் அனுப்ப வேண்டும், அதில் இருந்து எழுத்துக்களைப் படிக்கலாம் , அதாவது வகுப்பைப் பெறுகின்ற ஸ்ட்ரீம் Reader
.
என்ன பயன்? போலல்லாமல் InputStreamReader
, BufferedReader
வகுப்பு பைட்டுகளை எழுத்துகளாக மாற்றாது: இது எதையும் மாற்றாது. அதற்கு பதிலாக, இது தரவை இடையகப்படுத்துகிறது .
ஒரு நிரல் ஒரு பொருளிலிருந்து ஒரு எழுத்தைப் படிக்கும் போது BufferedReader
, பொருள் அதன் மூல ஸ்ட்ரீமில் இருந்து ஒரு பெரிய வரிசை எழுத்துக்களை ஒரே நேரத்தில் படிக்கிறது. மற்றும் அவற்றை உள்நாட்டில் சேமிக்கிறது.
பொருளில் இருந்து அடுத்த எழுத்தைப் படிக்கும்போது BufferedReader
, அது அதன் உள் இடையக வரிசையில் இருந்து அடுத்த எழுத்தைப் பிடித்து, தரவு மூலத்தை அணுகாமல் திருப்பித் தருகிறது. பஃபரில் உள்ள அனைத்து எழுத்துகளும் பயன்படுத்தப்பட்டால் மட்டுமே, அது மற்றொரு பெரிய எழுத்து வரிசையில் படிக்கும்.
வகுப்பில் BufferedReader
மிகவும் பயனுள்ள முறையும் உள்ளது - String readLine()
, இது மூல ஸ்ட்ரீமில் இருந்து தரவின் முழு சரங்களையும் ஒரே நேரத்தில் படிக்க அனுமதிக்கிறது. நீங்கள் இந்த முறையைப் பயன்படுத்தி ஒரு கோப்பைப் படிக்கலாம் மற்றும் அதன் உள்ளடக்கங்களை வரிக்கு வரி திரையில் காண்பிக்கலாம். உதாரணமாக:
இது எவ்வளவு வசதியானது என்பதை விளக்குவதற்கு நாங்கள் குறிப்பாக சில சிறிய குறியீட்டை எழுதினோம். இந்த குறியீட்டை இன்னும் கொஞ்சம் விரிவாக எழுதலாம்.
|
ஒரு FileReader பொருளை உருவாக்கவும். தரவு மூலமானது ஒரு கோப்பு. ஒரு BufferedReader பொருளை உருவாக்கவும். தரவு ஆதாரம் ஒரு FileReader . ரீடரில் இன்னும் தரவு இருக்கும் வரை ஒரு வரியைப் படியுங்கள் வரியைக் காட்டவும் |
நீங்கள் பல ஸ்ட்ரீம்களை ஒன்றாக இணைத்தால், முறையானது close()
அவற்றில் ஒன்றை மட்டுமே அழைக்க வேண்டும். அந்த ஸ்ட்ரீம் அதன் தரவு மூலத்தில் உள்ள முறையை அழைக்கும், மேலும் close()
இறுதி தரவு ஸ்ட்ரீமில் அழைக்கப்படும் வரை.
3. கன்சோலில் இருந்து படித்தல்
மேலும் ஒரு சுவாரஸ்யமான உண்மை: Scanner
வகுப்பு என்பது ஒரு இடைநிலை உள்ளீட்டு ஸ்ட்ரீமில் இருந்து தரவைப் படிக்கும் System.in
, இது ஒரு தரவு ஸ்ட்ரீம் ஆகும்.
கன்சோலில் இருந்து ஒரு வரியைப் படிக்க இரண்டு வழிகள் உள்ளன:
ஸ்கேனர் வகுப்பு | BufferedReader மற்றும் BufferedWriter வகுப்புகள் |
---|---|
|
|
எங்கள் நண்பர் வகுப்பின் நிலையான மாறியைத் தவிர வேறில்லை . இது யாருடைய பெயர் .System.in
in
System
InputStream
in
எனவே, CodeGym பற்றிய உங்கள் ஜாவா ஆய்வுகளின் ஆரம்பத்திலிருந்தே, நீங்கள் தரவு ஸ்ட்ரீம்களுடன் பணிபுரிந்து, அவற்றிலிருந்து சங்கிலிகளை உருவாக்குகிறீர்கள். ஆனால் இப்போது நீங்கள் அதை அதிக விழிப்புணர்வுடன் செய்வீர்கள்.