BufferedReader, BufferedWriter

"மீண்டும் நான் தான்."

"ஹாய், எல்லி!"

"இன்று நான் உங்களுக்கு BufferedReader மற்றும் BufferedWriter பற்றி அனைத்தையும் கூற விரும்புகிறேன் ."

"அவற்றைப் பற்றி நீங்கள் ஏற்கனவே என்னிடம் கூறியுள்ளீர்கள். உண்மையில் அவை அவ்வளவு சிக்கலானவை அல்ல."

"சரி. அப்படியானால் BufferedReader எப்படி வேலை செய்கிறது என்று சொல்லுங்கள் ."

" BufferedReader என்பது 110/220V மாற்றி போன்றது."

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

"அது சரி. மற்றும் BufferedWriter பற்றி என்ன ?"

"இது ஒரு துண்டு கேக். நாம் ஒரு FileWriter க்கு எழுதுகிறோம் என்று வைத்துக்கொள்வோம். தரவு உடனடியாக வட்டில் எழுதப்படும். நாம் அடிக்கடி சிறிய பிட் தரவுகளை எழுதினால், நாம் வட்டில் நிறைய அடிப்போம், இது நிரலின் வேகத்தை குறைக்கும். ஆனால் நாம் ஒரு BufferedWriter ஐ 'கன்வெர்ட்டராக' பயன்படுத்தினால் , எழுதும் செயல்பாடு மிக வேகமாக இருக்கும். நீங்கள் BufferedWriter க்கு எழுதும் போது , ​​அது டேட்டாவை இன்டர்னல் பஃப்பரில் சேமிக்கிறது. பஃபர் நிரம்பியதும், அது எழுதுபவருக்கு தரவை இவ்வாறு எழுதுகிறது . ஒரு பெரிய துண்டு. இது மிகவும் வேகமானது."

"ம்ம். ஸ்பாட் ஆன். ஆனா என்ன மறந்துட்டே?"

"நீங்கள் எழுதி முடித்த பிறகு, BufferedWriter ஆப்ஜெக்டில் உள்ள ஃப்ளஷ்() முறையை அழைக்க வேண்டும், அது இன்னும் இடையகத்தில் உள்ள எந்தத் தரவையும் எழுத்தாளருக்கு அனுப்பும்படி கட்டாயப்படுத்த வேண்டும் . "

"பிறகு என்ன?"

"வேறென்ன? ஓ! எழுதுபவருக்கு இடையகம் எழுதப்படாத வரை , தரவு நீக்கப்படலாம் மற்றும்/அல்லது மாற்றப்படலாம்."

"அமிகோ! நான் ஈர்க்கப்பட்டேன்! நீங்கள் ஒரு நிபுணர்! சரி, சில புதிய வகுப்புகளைப் பற்றி நான் உங்களுக்குச் சொல்கிறேன்:  ByteArrayStream மற்றும் PrintStream ."

"எடுத்துக்காட்டாக, ByteArrayInputStream மற்றும் ByteArrayOutputStream ."

"இந்த வகுப்புகள் சற்று StringReader மற்றும் StringWriter போன்றவை . StringReader ஒரு சரத்திலிருந்து ( char ) எழுத்துக்களை ( char ) படிக்கிறது என்பதைத் தவிர , ஆனால் InputStream ஒரு பைட் வரிசையிலிருந்து ( ByteArray ) பைட்டுகளைப் படிக்கிறது."

StringWriter ஒரு சரத்திற்கு எழுத்துக்களை ( சார் ) எழுதுகிறது, அதே நேரத்தில் ByteArrayOutputStream ஒரு உள் பைட் வரிசைக்கு பைட்டுகளை எழுதுகிறது. நீங்கள் ஒரு StringWriter க்கு எழுதும் போது , ​​அதன் உள் சரம் நீளமாக வளரும், மேலும் ByteArrayOutputStream இல் எழுதும் போது அதன் உள் பைட் வரிசையும் மாறும் வகையில் விரிவடைகிறது.

"கடந்த பாடத்தில் உங்களுக்குக் கொடுக்கப்பட்ட உதாரணத்தை நினைவில் கொள்ளுங்கள்:"

public static void main (String[] args) throws Exception
{
 String test = "Hi!\n My name is Richard\n I'm a photographer\n";
 StringReader reader = new StringReader(test);

 StringWriter writer = new StringWriter();

 executor(reader, writer);

 String result = writer.toString();

 System.out.println("Result: "+ result);
}

public static void executor(Reader reader, Writer writer) throws Exception
{
 BufferedReader br = new BufferedReader(reader);
 String line;
 while ((line = br.readLine()) != null) {
 StringBuilder sb = new StringBuilder(line);
 String newLine = sb.reverse().toString();

 writer.write(newLine);
 }
}

"எழுத்துக்களுக்குப் பதிலாக பைட்டுகளைப் பயன்படுத்தி வேலை செய்தால் அது எப்படி இருக்கும் என்பது இங்கே:"

public static void main (String[] args) throws Exception
{
 String test = "Hi!\n My name is Richard\n I'm a photographer\n";
 InputStream inputStream = new ByteArrayInputStream(test.getBytes());

 ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

 executor(inputStream, outputStream);

 String result = new String(outputStream.toByteArray());
 System.out.println("Result: "+ result);
}

public static void executor(InputStream inputStream, OutputStream outputStream) throws Exception
{
 BufferedInputStream bis = new BufferedInputStream(inputStream);
 while (bis.available() > 0)
 {
  int data = bis.read();
  outputStream.write(data);
 }
}

"எல்லாமே மேலே உள்ள எடுத்துக்காட்டில் உள்ளது. தவிர, நாங்கள் String ஐ ByteArray, Reader ஐ InputStream மற்றும் Writer ஐ OutputStream என்று மாற்றினோம்."

"வேறு இரண்டு படிகள் மட்டுமே சரத்தை பைட்அரேயாக மாற்றுவது மற்றும் மீண்டும் மீண்டும். நீங்கள் பார்க்க முடியும், இது மிகவும் எளிதாக செய்யப்படுகிறது:"

public static void main (String[] args) throws Exception
{
 String test = "Hi!\n My name is Richard\n I'm a photographer\n";
 byte[] array = test.getBytes();

 String result = new String(array);
 System.out.println("Result: "+ result);
}

"ByteArrayOutputStream இல் ஏற்கனவே சேர்க்கப்பட்ட பைட்டுகளைப் பெற, toByteArray () முறையை அழைக்கவும்."

"ஆஹா. StringReader/StringWriter உடன் உள்ள ஒற்றுமைகள் மிகவும் வலுவானவை, குறிப்பாக நீங்கள் அவற்றை எனக்கு சுட்டிக்காட்டிய பிறகு. மிகவும் சுவாரஸ்யமான பாடத்திற்கு நன்றி, எல்லி."

"இவ்வளவு அவசரமாக எங்கே போகிறாய்? இன்னும் என்னிடம் ஒரு சிறிய பரிசு உள்ளது. நான் உங்களுக்கு PrintStream வகுப்பைப் பற்றி சொல்ல விரும்புகிறேன்."

"PrintStream? அந்த வகுப்பைப் பற்றி நான் முதல்முறையாகக் கேள்விப்படுகிறேன்."

"ஆமாம். குறிப்பாக, உங்கள் ஜாவா ஆய்வுகளில் முதல் நாளிலிருந்து நீங்கள் இதைப் பயன்படுத்துகிறீர்கள் என்பதை நீங்கள் கணக்கிடவில்லை என்றால், உங்களுக்கு System.out நினைவிருக்கிறதா ? சரி, System.out என்பது கணினியின் நிலையான (வகுப்பு) மாறியாகும். வகுப்பு, மற்றும் அதன் வகை... PrintStream ! இந்த அச்சு, println, போன்ற அனைத்து முறைகளும் இங்குதான் உருவாகின்றன."

"ஆஹா. எவ்வளவு சுவாரஸ்யமானது. எப்படியோ நான் அதை எண்ணவே இல்லை. இன்னும் சொல்லு."

"நல்லது. சரி, கேளுங்கள். PrintStream வகுப்பு படிக்கக்கூடிய வெளியீட்டிற்காக கண்டுபிடிக்கப்பட்டது. இது கிட்டத்தட்ட முழுவதுமாக அச்சு மற்றும் println முறைகளைக் கொண்டுள்ளது. இந்த அட்டவணையைப் பாருங்கள்:"

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

String name = "Kolan";
int age = 25;
System.out.format("My name is %s. My age is %d.", name, age);

My name is Kolan. My age is 25.

"ஆமாம், எனக்கு நினைவிருக்கிறது. நாங்கள் ஏற்கனவே ஸ்ட்ரிங் கிளாஸின் வடிவமைப்பு முறையைப் படித்திருக்கிறோம்."

"இப்பொழுது இத்துடன் நிறைவடைகிறது."

"நன்றி, எல்லி."