சங்கிலியால் பிணைக்கப்பட்ட நீரோடைகள்

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(), இது மூல ஸ்ட்ரீமில் இருந்து தரவின் முழு சரங்களையும் ஒரே நேரத்தில் படிக்க அனுமதிக்கிறது. நீங்கள் இந்த முறையைப் பயன்படுத்தி ஒரு கோப்பைப் படிக்கலாம் மற்றும் அதன் உள்ளடக்கங்களை வரிக்கு வரி திரையில் காண்பிக்கலாம். உதாரணமாக:

இது எவ்வளவு வசதியானது என்பதை விளக்குவதற்கு நாங்கள் குறிப்பாக சில சிறிய குறியீட்டை எழுதினோம். இந்த குறியீட்டை இன்னும் கொஞ்சம் விரிவாக எழுதலாம்.

String src = "c:\\projects\\log.txt";

try(FileReader in = new FileReader(src);
BufferedReader reader = new BufferedReader(in))
{
   while (reader.ready())
   {
      String line = reader.readLine();
      System.out.println(line);
   }
}

3. கன்சோலில் இருந்து படித்தல்

மேலும் ஒரு சுவாரஸ்யமான உண்மை: Scannerவகுப்பு என்பது ஒரு இடைநிலை உள்ளீட்டு ஸ்ட்ரீமில் இருந்து தரவைப் படிக்கும் System.in, இது ஒரு தரவு ஸ்ட்ரீம் ஆகும்.

கன்சோலில் இருந்து ஒரு வரியைப் படிக்க இரண்டு வழிகள் உள்ளன:

InputStream stream = System.in;
Scanner console = new Scanner(stream);
String line = console.nextLine();

InputStream stream = System.in;
InputStreamReader reader = new InputStreamReader(stream);
BufferedReader buff = new BufferedReader(reader);
String line = buff.readLine();

எங்கள் நண்பர் வகுப்பின் நிலையான மாறியைத் தவிர வேறில்லை . இது யாருடைய பெயர் .System.ininSystemInputStreamin

எனவே, CodeGym பற்றிய உங்கள் ஜாவா ஆய்வுகளின் ஆரம்பத்திலிருந்தே, நீங்கள் தரவு ஸ்ட்ரீம்களுடன் பணிபுரிந்து, அவற்றிலிருந்து சங்கிலிகளை உருவாக்குகிறீர்கள். ஆனால் இப்போது நீங்கள் அதை அதிக விழிப்புணர்வுடன் செய்வீர்கள்.