बफ़रेडरीडर, बफ़रेडराइटर

"मैं फिर से आ गया।"

"हाय, ऐली!"

"आज मैं आप सभी को BufferedReader और BufferedWriter के बारे में बताना चाहता हूँ ।"

"आपने मुझे उनके बारे में पहले ही बता दिया था। वे वास्तव में इतने जटिल नहीं हैं।"

"ठीक है। फिर मुझे बताओ कि बफ़रेडरीडर कैसे काम करता है।"

" बफर्डरीडर 110/220V कनवर्टर की तरह है।"

"आपको बफ़रेडरीडर कंस्ट्रक्टर को रीडर ऑब्जेक्ट पास करना होगा जो डेटा से पढ़ा जाएगा। एक बफ़रेडरीडर ऑब्जेक्ट रीडर से डेटा के बड़े हिस्से को पढ़ता है और उन्हें एक बफर में आंतरिक रूप से संग्रहीत करता है। यही कारण है कि एक रीडर से पढ़ने के लिए बफ़रडरडर का उपयोग करना तेज़ है एक पाठक से सीधे पढ़ने की तुलना में ।"

"यह सही है। और बफ़रेडराइटर के बारे में क्या ?"

"यह केक का एक टुकड़ा है। मान लीजिए कि हम एक फाइलराइटर को लिखते हैं। डेटा तुरंत डिस्क पर लिखा जाता है। यदि हम डेटा के छोटे-छोटे टुकड़े बार-बार लिखते हैं, तो हम डिस्क को बहुत हिट करेंगे, जो प्रोग्राम को बहुत धीमा कर देगा। लेकिन अगर हम BufferedWriter को 'कनवर्टर' के रूप में उपयोग करते हैं, तो लिखने का कार्य बहुत तेज होता है। जब आप BufferedWriter को लिखते हैं , तो यह डेटा को आंतरिक बफर में सहेजता है। जब बफर भर जाता है, तो यह लेखक को डेटा लिखता है एक बड़ा हिस्सा। यह बहुत तेज है।"

"हम्म। स्पॉट ऑन। लेकिन आप क्या भूल गए हैं?"

"लिखने के बाद, आपको BufferedWriter ऑब्जेक्ट पर फ्लश() विधि को कॉल करने की आवश्यकता है ताकि इसे बफर में अभी भी लेखक को कोई भी डेटा भेजने के लिए मजबूर किया जा सके ।"

"और क्या?"

"और क्या? ओह! जब तक लेखक को बफर नहीं लिखा गया है , तब तक डेटा को हटाया जा सकता है और/या बदला जा सकता है।"

"अमीगो! मैं प्रभावित हूँ! आप एक विशेषज्ञ हैं! ठीक है, तो मैं आपको कुछ नई कक्षाओं के बारे में बताऊँगा:  ByteArrayStream और PrintStream ।"

"उदाहरण के लिए, ByteArrayInputStream और ByteArrayOutputStream ।"

"ये वर्ग StringReader और StringWriter की तरह हैं । StringReader को छोड़कर एक स्ट्रिंग ( String ) से वर्ण ( char ) पढ़ता है , लेकिन InputStream एक बाइट सरणी ( ByteArray ) से बाइट्स पढ़ता है। "

StringWriter वर्ण ( char ) को एक स्ट्रिंग में लिखता है, जबकि 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);
 }
}

"उपरोक्त उदाहरण में सब कुछ वैसा ही है। सिवाय इसके कि हमने स्ट्रिंग को बाइटएरे से, रीडर को इनपुटस्ट्रीम से और राइटर को आउटपुटस्ट्रीम से बदल दिया।"

"केवल दो अन्य चरण स्ट्रिंग को बाइटएरे में परिवर्तित कर रहे हैं और फिर से वापस आ रहे हैं। जैसा कि आप देख सकते हैं, यह काफी आसानी से किया जाता है:"

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 क्लास के बारे में बताना चाहता हूँ।"

"प्रिंटस्ट्रीम? मैंने पहली बार उस वर्ग के बारे में सुना है।"

"हाँ। विशेष रूप से, यदि आप इस तथ्य की गणना नहीं करते हैं कि आप इसे अपने जावा अध्ययन के पहले दिन से उपयोग कर रहे हैं। क्या आपको System.out याद है ? ठीक है, System.out सिस्टम का एक स्थिर (वर्ग) चर है। क्लास, और इसका प्रकार है... PrintStream ! यह वह जगह है जहाँ ये सभी Print, 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.

"हाँ, मुझे याद है। हम पहले ही स्ट्रिंग क्लास के प्रारूप विधि का अध्ययन कर चुके हैं।"

"अभी के लिए इतना ही।"

"धन्यवाद, ऐली।"