விசைப்பலகையில் இருந்து படித்தல்: "வாசகர்கள்"

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

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

ஆனால் நாம் இன்னும் பதிலளிக்காத ஒரு கேள்வி உள்ளது.

உலகில் இது எப்படி வேலை செய்கிறது?

உண்மையில், திட்டங்கள் அரிதாகவே முற்றிலும் சுயாதீனமானவை. அவை மற்ற நிரல்கள், அமைப்புகள், இணையம் போன்றவற்றுடன் தொடர்பு கொள்கின்றன. "தொடர்பு" என்பதன் மூலம், நாம் முக்கியமாக "தரவு பரிமாற்றம்" என்று பொருள்படுகிறோம். அதாவது, அவை சில வெளிப்புறத் தரவைப் பெறுகின்றன மற்றும் உள் நிரல் தரவை எங்காவது அனுப்புகின்றன. தரவுகளை பரிமாறிக்கொள்ளும் நிரல்களின் எடுத்துக்காட்டுகள் அன்றாட வாழ்வில் ஏராளமாக உள்ளன. எடுத்துக்காட்டாக, பல வலைத்தளங்கள் பதிவு செய்வதற்குப் பதிலாக உங்கள் Facebook அல்லது Twitter கணக்கைப் பயன்படுத்தி உள்நுழைய அனுமதிக்கின்றன. இந்தச் சூழ்நிலையில், இரண்டு புரோகிராம்கள் (எ.கா. ட்விட்டர் மற்றும் நீங்கள் உள்நுழையும் இணையதளம்) தேவையான தரவைப் பரிமாறிக் கொள்கின்றன. நீங்கள் வெற்றிகரமாக உள்நுழைந்துள்ளீர்கள் என்பதே இறுதி முடிவு. "ஸ்ட்ரீம்" என்ற வார்த்தைதரவு பரிமாற்ற செயல்முறையை விவரிக்கப் பயன்படுகிறது. இந்தப் பெயர் எங்கிருந்து வந்தது? உங்கள் அனுபவத்தில், "நீரோடை" என்பது நிரலாக்கத்தை விட நதிகளுடன் தொடர்புடையதாக இருக்கலாம். அது தற்செயலானது அல்ல :) ஒரு ஸ்ட்ரீம், சாராம்சத்தில், நகரும் தரவு. வேறு வார்த்தைகளில் கூறுவதானால், நிரலாக்கத்தில், பாய்வது தண்ணீர் அல்ல - மாறாக பைட்டுகள் மற்றும் எழுத்துக்கள் வடிவத்தில் தரவு. டேட்டா ஸ்ட்ரீமில் இருந்து பிட் டேட்டாவைப் பெற்று, அவற்றைப் பயன்படுத்தலாம். மீண்டும், நாங்கள் தண்ணீர்/ஓட்ட ஒப்புமையைப் பயன்படுத்துவோம்: நீங்கள் ஆற்றில் இருந்து தண்ணீரை உறிஞ்சி சூப் தயாரிக்கலாம், நெருப்பை அணைக்கலாம் அல்லது உங்கள் பூக்களுக்கு தண்ணீர் பாய்ச்சலாம். ஸ்ட்ரீம்கள் எந்த தரவு மூலத்துடனும் வேலை செய்ய உங்களை அனுமதிக்கின்றன: இணையம், உங்கள் கணினியின் கோப்பு முறைமை அல்லது வேறு ஏதாவது - இது எந்த வித்தியாசத்தையும் ஏற்படுத்தாது. ஸ்ட்ரீம்கள் ஒரு உலகளாவிய கருவி. அவை ஒரு நிரலை எங்கிருந்தும் (உள்ளீடு ஸ்ட்ரீம்கள்) தரவைப் பெறவும், அதை எங்கும் அனுப்பவும் (வெளியீட்டு ஸ்ட்ரீம்கள்) அனுமதிக்கின்றன. அவர்களின் பணி ஒன்றுதான்: ஒரு இடத்திலிருந்து தரவை எடுத்து மற்றொரு இடத்திற்கு அனுப்புவது. இரண்டு வகையான நீரோடைகள் உள்ளன:

1. தரவைப் பெற உள்ளீட்டு ஸ்ட்ரீம்கள் பயன்படுத்தப்படுகின்றன
2. அவுட்புட் ஸ்ட்ரீம்கள் தரவை அனுப்புவதற்கானவை.

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

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

பாடங்களைப் படிக்கும்போது, ​​இந்த வரி மிகவும் பயமுறுத்துவதாக நீங்கள் நினைக்கவில்லையா? :) இது எப்படி வேலை செய்கிறது என்பதை ஆராய்ந்து பார்த்தவுடன் அப்படி இருக்காது. விஷயங்களை சரியாக வைப்போம். நாம் இறுதியில் தொடங்குவோம். System.inஒரு InputStreamபொருள், நாம் ஆரம்பத்தில் பேசிய வகுப்பின் ஒரு உதாரணம். இது கணினி உள்ளீட்டு சாதனத்துடன் (விசைப்பலகை) இணைக்கப்பட்ட உள்ளீட்டு ஸ்ட்ரீம் ஆகும். சொல்லப்போனால், இந்த ஸ்ட்ரீமை நீங்கள் மறைமுகமாக அறிந்திருக்கிறீர்கள். எல்லாவற்றிற்கும் மேலாக, நீங்கள் அதன் "சக பணியாளரை" அடிக்கடி பயன்படுத்துகிறீர்கள் - System.out! System.outகணினி வெளியீட்டு ஸ்ட்ரீம் ஆகும். உங்களுக்குப் பிடித்தமான முறையின் மூலம் கன்சோலில் தரவை வெளியிட இது பயன்படுகிறது System.out.println(), நீங்கள் தொடர்ந்து பயன்படுத்தும் :) System.outஇது கன்சோலுக்கு தரவை அனுப்புவதற்கான ஸ்ட்ரீம் ஆகும்.System.inவிசைப்பலகையில் இருந்து தரவைப் பெறுவதற்கானது. எல்லாம் எளிது :) மேலும் என்ன, இந்த பெரிய கட்டுமானம் இல்லாமல் நாம் விசைப்பலகையில் இருந்து தரவு படிக்க முடியும். நாம் எளிமையாக எழுதலாம்: System.in.read();

public class Main {

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

       while (true) {
           int x = System.in.read();
           System.out.println(x);
       }
   }
}

வகுப்பில் InputStream(நினைவில் கொள்ளுங்கள், System.inஒரு InputStreamபொருள்) read()தரவைப் படிக்க உங்களை அனுமதிக்கும் ஒரு முறை உள்ளது. ஒரு சிக்கல் உள்ளது: இது பைட்டுகளைப் படிக்கிறது, எழுத்துக்கள் அல்ல . ஆங்கில எழுத்துக்களைப் பயன்படுத்துவது சலிப்பை ஏற்படுத்துகிறது, எனவே கீபோர்டில் இருந்து "魚" என்ற சீன எழுத்தை படிக்க முயற்சிப்போம் (இந்த கடிதத்தை இங்கிருந்து நகலெடுத்து PC இல் ctrl + v அல்லது Mac இல் Command + v பயன்படுத்தி கன்சோலில் ஒட்டவும்). இந்த எழுத்துக்கு 'ஒரு மீன்' என்று பொருள். கன்சோல் வெளியீடு: 魚 233 173 154 10 இந்த சின்னமும் மற்ற பல சீனங்களும் கணினியின் நினைவகத்தில் 3 பைட்டுகளை ஆக்கிரமித்துள்ளன (லத்தீன் எழுத்துக்களைப் போலல்லாமல், இது வெறும் 1 பைட் மட்டுமே). இந்த வழக்கில், ஸ்ட்ரீமில் இருந்து 4 பைட்டுகள் படிக்கப்படுகின்றன: முதல் மூன்று "魚" என்ற எழுத்தைக் குறிக்கிறது, மற்ற பைட்கள் ஒரு புதிய வரியைக் குறிக்கின்றன (Enter). அதன்படி, System.inஅதன் அலங்காரமற்ற வடிவத்தில் எங்களுக்கு ஒரு விருப்பமாக இல்லை. மனிதர்களுக்கு (அரிதான விதிவிலக்குகளுடன்!) பைட்டுகளைப் படிக்கத் தெரியாது. ஆனால் InputStreamReaderவகுப்பு மீட்புக்கு வருகிறது! இது என்ன வகையான விலங்கு என்று பார்ப்போம்.

BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

நாம் InputStreamReaderSystem.in பொருளுக்கு செல்கிறோம் . வகுப்பின் பெயர் சொல்கிறது! நாம் ஒரு பொருளை உருவாக்கி, அதில் இருந்து தரவைப் படிக்கும் உள்ளீட்டு ஸ்ட்ரீமை அனுப்புகிறோம். இந்த நிலையில்... InputStreamReader

new InputStreamReader(System.in)

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

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

   public static void main(String[] args) throws IOException {
       InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("C:\\Users\\username\\Desktop\\testFile.txt"));
   }
}

இங்கே நாம் ஒரு FileInputStream(ஒரு சுவையை InputStream) உருவாக்கி, கோப்பு பாதையில் கடந்து, ஸ்ட்ரீமையே க்கு அனுப்புகிறோம் InputStreamReader. இப்போது அது கோப்பிலிருந்து தரவைப் படிக்க முடியும் (ஒரு கோப்பு உண்மையில் பாதையில் இருந்தால், நிச்சயமாக). InputStreamReaderதரவைப் படிக்க வகுப்பின் முறையைப் பயன்படுத்துகிறோம் read()(தரவின் ஆதாரம் முக்கியமில்லை: கன்சோல், கோப்பு அல்லது வேறு எங்காவது). System.in.read()மற்றும் க்கு என்ன வித்தியாசம் InputStreamReader.read()?\ "魚" என்ற எழுத்தை மீண்டும் ஒரு உடன் படிக்க முயற்சிப்போம் InputStreamReader. உண்மையில் படித்ததை நான் உங்களுக்கு நினைவூட்டுகிறேன் System.in.read(): 魚 233 173 154 10InputStreamReader அதே வேலையை எப்படி செய்கிறது ?

public class Main {

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

       InputStreamReader reader = new InputStreamReader(System.in);
       while (true) {
           int x = reader.read();
           System.out.println(x);
       }
   }
}

கன்சோல் வெளியீடு: 魚 39770 10 வேறுபாடு உடனடியாகத் தெரியும். கடைசி பைட் (புதிய வரியைக் குறிக்கும்) மாறாமல் உள்ளது (எண் 10), ஆனால் "魚" எழுத்து "39770" என்ற ஒற்றைக் குறியீட்டாக மாற்றப்பட்டது. எழுத்துக்களை வாசிப்பது என்றால் இதுதான்! 39770 என்பது "魚" என்ற எழுத்தைக் குறிக்கிறது என்று நீங்கள் நம்பவில்லை என்றால், உங்களை நீங்களே சமாதானப்படுத்துவது எளிது :)

import java.io.IOException;

public class Main {

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

       char x = 39770;
       System.out.println(x);
   }
}

கன்சோல் வெளியீடு: 魚 ஆனால் InputStreamReaderமிகவும் நன்றாக இருந்தால், நமக்கும் ஏன் தேவை BufferedReader? InputStreamReaderதரவைப் படிப்பது மற்றும் பைட்டுகளை எழுத்துகளாக மாற்றுவது எப்படி என்று தெரியும். நாம் இன்னும் என்ன கேட்க முடியும்? ஏன் இன்னொரு வாசகர்? :/ பதில் மிகவும் எளிது: அதிக செயல்திறன் மற்றும் வசதிக்காக . செயல்திறனுடன் ஆரம்பிக்கலாம். தரவைப் படிக்கும்போது BufferedReader, ​​​​அது ஒரு பஃபர் எனப்படும் ஒரு சிறப்புப் பகுதியைப் பயன்படுத்துகிறது, அங்கு அது படிக்கும் எழுத்துக்களை "சேமித்து வைக்கிறது". இறுதியில், நிரலில் இந்த எழுத்துக்கள் தேவைப்படும்போது, ​​அவை நேரடியாக தரவு மூலத்திலிருந்து (விசைப்பலகை, கோப்பு, முதலியன) இல்லாமல், இடையகத்திலிருந்து எடுக்கப்படும். இது நிறைய வளங்களை சேமிக்கிறது. இது எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்து கொள்ள, ஒரு பெரிய நிறுவனத்தில் ஒரு கூரியரை கற்பனை செய்து பாருங்கள். கூரியர் ஒரு அலுவலகத்தில் அமர்ந்து, யாரோ ஒருவர் டெலிவரிக்காக பேக்கேஜ்களைக் கொண்டு வருவார் என்று காத்திருக்கிறார். ஒவ்வொரு முறையும் அவர் ஒரு புதிய தொகுப்பைப் பெறும்போது, ​​அவர் உடனடியாக சாலையில் செல்ல முடியும். ஆனால் பகலில் நிறைய தொகுப்புகள் இருக்கலாம். அலுவலகம் மற்றும் டெலிவரி முகவரிகளுக்கு இடையே அவர் நிறைய பயணங்களை மேற்கொள்ள வேண்டியிருக்கும். அதற்கு பதிலாக, கூரியர் தனது அலுவலகத்தில் ஒரு பெட்டியை வைக்கிறார். எல்லோரும் தங்கள் பொதிகளை பெட்டியில் வைக்கிறார்கள். இப்போது கூரியர் அமைதியாக பெட்டியை எடுத்து முகவரியிலிருந்து முகவரிக்கு நகர்த்தலாம். இது நிறைய நேரத்தை மிச்சப்படுத்துகிறது, ஏனென்றால் அவர் ஒவ்வொரு முறையும் அலுவலகத்திற்குத் திரும்ப வேண்டியதில்லை. இந்த எடுத்துக்காட்டில், பெட்டி ஒரு இடையகமாகும், மேலும் அலுவலகம் ஒரு தரவு மூலமாகும். கூரியர் ஒவ்வொரு முறையும் அலுவலகத்திற்குச் செல்வதை விட டெலிவரி செய்யும் போது ஒரு பெட்டியில் இருந்து பேக்கேஜ்களை எடுப்பது மிகவும் எளிதானது. பெட்ரோலையும் சேமிப்பார். இதேபோல், ஒரு நிரலில், ஒவ்வொரு முறையும் தரவு மூலத்தைப் பார்ப்பதை விட, ஒரு இடையகத்திலிருந்து தரவை எடுப்பது மிகவும் குறைவான வளங்களைக் கொண்டது. அதன் விளைவாக,BufferedReader+ தனியாக InputStreamReaderஇருப்பதை விட வேகமானதுInputStreamReader . செயல்திறனைக் கருத்தில் கொண்டோம். வசதி பற்றி என்ன? முக்கிய நன்மை என்னவென்றால், Bufferedreaderஒரு நேரத்தில் ஒரு எழுத்தை மட்டுமல்ல (அதன் முறையால் இதைச் செய்ய முடியும் என்றாலும் read()), ஆனால் ஒரு நேரத்தில் முழு வரிகளையும் படிக்க முடியும்! இது முறையைப் பயன்படுத்தி செய்யப்படுகிறது readLine();

public class Main {

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

       BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
       String s = reader.readLine();
       System.out.println("We read this line from the keyboard:");
       System.out.println(s);
   }
}

கன்சோல் வெளியீடு: ஜாவாவைக் கற்றுக்கொள்வதற்கான சிறந்த இணையதளம் CodeGym! விசைப்பலகையில் இருந்து இந்த வரியைப் படித்தோம்: ஜாவாவைக் கற்றுக்கொள்வதற்கான சிறந்த இணையதளம் CodeGym! பெரிய அளவிலான தரவைப் படிக்கும்போது இது மிகவும் பயனுள்ளதாக இருக்கும். எழுத்து மூலம் ஒன்று அல்லது இரண்டு வரிகளை வாசிப்பது இன்னும் சாத்தியமாகும். ஆனால் "போர் மற்றும் அமைதி"யில் ஒரு கடிதத்தை படிப்பது ஓரளவு சிக்கலாக இருக்கும் :)