BuffreredReader மற்றும் InputStreamReader வகுப்புகளுடன் பணிபுரிய பயிற்சி செய்யுங்கள்

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

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

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

public class Main {

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

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

இந்தக் குறியீட்டை இயக்கி, "Й" என்ற சிரிலிக் எழுத்தை உள்ளிட்டால், வெளியீடு:

Й
208
153
10 

சிரிலிக் எழுத்துக்கள் நினைவகத்தில் 2 பைட்டுகளை ஆக்கிரமித்து, அவை திரையில் காட்டப்படும். எண் 10 என்பது ஒரு வரி ஊட்ட எழுத்தின் தசம பிரதிநிதித்துவமாகும், அதாவது Enter ஐ அழுத்துவதன் மூலம். பைட்டுகளைப் படிப்பது மிகவும் மகிழ்ச்சி அளிக்கிறது, எனவே பயன்படுத்துவது System.inமிகவும் வசதியானது அல்ல. சிரிலிக் (மற்றும் பிற) எழுத்துக்களை சரியாகப் படிக்க, நாங்கள் InputStreamReaderஒரு ரேப்பராகப் பயன்படுத்துகிறோம்:

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); 
       } 
   } 
} 

"Й" என்ற அதே எழுத்தை உள்ளிடுகிறோம், ஆனால் இந்த முறை முடிவு வேறுபட்டது:

Й 
1049 
10

InputStreamReaderஇரண்டு பைட்டுகளை (208 மற்றும் 153) 1049 என்ற ஒற்றை எண்ணாக மாற்றியது. எழுத்துகளைப் படிப்பது என்பது இதுதான். 1049 சிரிலிக் எழுத்து "Й" உடன் ஒத்துள்ளது. இது உண்மை என்பதை நாம் எளிதாக நம்பலாம்:

public class Main { 

   public static void main(String[] args) throws IOException { 
       char x = 1049; 
       System.out.println(x); 
   } 
} 

கன்சோல் வெளியீடு:

Й

மேலும் forBufferedReader(மற்றும் பொதுவாக, BufferedAnythingYouWant), செயல்திறனை மேம்படுத்துவதற்கு இடையக வகுப்புகள் பயன்படுத்தப்படுகின்றன. தரவு மூலத்தை அணுகுவது (கோப்பு, கன்சோல், வலை ஆதாரம்) செயல்திறன் அடிப்படையில் மிகவும் விலை உயர்ந்தது. எனவே, அணுகல்களின் எண்ணிக்கையைக் குறைப்பதற்காக, BufferedReaderஒரு சிறப்பு இடையகத்தில் தரவைப் படித்து, குவித்து, அதை அங்கிருந்து பெறுகிறோம். இதன் விளைவாக, தரவு மூலத்தை அணுகும் முறைகளின் எண்ணிக்கை குறைக்கப்படுகிறது - ஒருவேளை பல அளவு ஆர்டர்களால்! இன்னுமொரு BufferedReaderஅம்சம் மற்றும் அதன் சாதரணத்தை விட அதன் நன்மை InputStreamReader, மிகவும் பயனுள்ள 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 ("The user entered the following text:"); 
       System.out.println(s); 
       reader.close(); 
   } 
}

BufferedReader+InputStreamReader is faster than InputStreamReader alone 
The user entered the following text: 
BufferedReader+InputStreamReader is faster than InputStreamReader alone

நிச்சயமாக, BufferedReaderமிகவும் நெகிழ்வானது. நீங்கள் விசைப்பலகையுடன் பணிபுரிய மட்டும் அல்ல. எடுத்துக்காட்டாக, தேவையான URLஐ வாசகருக்கு அனுப்புவதன் மூலம், இணையத்திலிருந்து நேரடியாகத் தரவைப் படிக்கலாம்:

public class URLReader { 

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

       URL oracle = new URL("https://www.oracle.com/index.html"); 
       BufferedReader in = new BufferedReader( 
               new InputStreamReader(oracle.openStream())); 

       String inputLine; 
       while ((inputLine = in.readLine()) != null) 
           System.out.println(inputLine); 
       in.close(); 
   } 
}

கோப்பு பாதையை கடந்து ஒரு கோப்பிலிருந்து தரவைப் படிக்கலாம்:

public class Main { 

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

       FileInputStream fileInputStream = new FileInputStream("testFile.txt"); 
       BufferedReader reader = new BufferedReader(new InputStreamReader(fileInputStream)); 

       String str; 

       while ((str = reader.readLine()) != null)   { 
           System.out.println (str); 
       } 

       reader.close(); 
   } 
}

System.out ஐ மாற்றுகிறது

இப்போது நாம் இதுவரை தொடாத ஒரு சுவாரஸ்யமான திறனைப் பார்ப்போம். நீங்கள் நிச்சயமாக நினைவில் வைத்திருப்பது போல், Systemவகுப்பில் இரண்டு நிலையான புலங்கள் உள்ளன - System.inமற்றும்  System.out. இந்த இரட்டை சகோதரர்கள் ஸ்ட்ரீம் பொருள்கள். System.inஒரு InputStream. மற்றும் System.out ஒரு PrintStream. இப்போதே, நாம் பேசுவோம்  System.out. வகுப்பின் மூலக் குறியீட்டில் நாம் இறங்கினால் System, இதைப் பார்ப்போம்:

public final class System { 
……………... 
public final static PrintStream out = null; 
 ………… 
} 

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

PrintStream filePrintStream = new PrintStream(new File("C:\\Users\\Username\\Desktop\\test.txt"));

முழு குறியீடும் இப்படி இருக்கும்:

public class SystemRedirectService { 

   public static void main(String arr[]) throws FileNotFoundException 
   { 
       PrintStream filePrintStream = new PrintStream(new File("C:\\Users\\Username\\Desktop\\test.txt"));
       /* Save the current value of System.out in a separate variable so that later 
       we can switch back to console output */ 

       PrintStream console = System.out; 
       // Assign a new value to System.out 
       System.setOut(filePrintStream); 
       System.out.println("This line will be written to the text file"); 

       // Restore the old value of System.out 
       System.setOut(console); 
       System.out.println("But this line will be output to the console!"); 
   } 
}

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