స్ట్రింగ్ రీడర్, స్ట్రింగ్ రైటర్

"హాయ్, అమిగో!"

"హాయ్, ఎల్లీ!"

"ఈరోజు నేను మీకు StringReader మరియు StringWriter తరగతుల గురించి చెప్పాలనుకుంటున్నాను . సూత్రప్రాయంగా, మీకు కొత్తవి ఎక్కువ ఉండవు, కానీ కొన్నిసార్లు ఈ తరగతులు చాలా ఉపయోగకరంగా ఉంటాయి. కానీ, కనీసం, మీరు తెలుసుకోవాలని నేను కోరుకుంటున్నాను. అవి ఉనికిలో ఉన్నాయని."

"ఈ తరగతులు అబ్‌స్ట్రాక్ట్ రీడర్ మరియు రైటర్ క్లాస్‌ల యొక్క సరళమైన అమలులు. మరియు అవి ప్రాథమికంగా ఫైల్‌రీడర్ మరియు ఫైల్‌రైటర్‌ల మాదిరిగానే ఉంటాయి. అయితే, వాటిలా కాకుండా, ఇవి డిస్క్‌లోని ఫైల్‌లోని డేటాతో పని చేయవు. బదులుగా, అవి స్ట్రింగ్‌తో పని చేస్తాయి. JVM జ్ఞాపకార్థం."

"మాకు అలాంటి తరగతులు ఎందుకు అవసరం?"

"కొన్నిసార్లు అవి అవసరమవుతాయి. ముఖ్యంగా, StringReader అనేది స్ట్రింగ్ మరియు రీడర్ తరగతుల మధ్య ఒక అడాప్టర్ . మరియు StringWriter అనేది రైటర్‌ను వారసత్వంగా పొందే స్ట్రింగ్ . అవును... అది ఉత్తమ వివరణ కాదని నేను చెప్పగలను. ఒక జంటను చూడటం మంచిది. మొదటి ఉదాహరణలు."

"ఉదాహరణకు, మీరు మీ పద్ధతిని పరీక్షించాలనుకుంటున్నారని అనుకుందాం, అది దానికి పంపబడిన రీడర్ ఆబ్జెక్ట్ నుండి డేటాను రీడ్ చేస్తుంది. మేము దీన్ని ఇలా చేయవచ్చు:"

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

 // This line is key: we "convert" the String into a Reader.
 StringReader reader = new StringReader(test);

 executor(reader);
}

public static void executor(Reader reader) throws Exception
{
 BufferedReader br = new BufferedReader(reader);
 String line;
 while (line = br.readLine() != null)
 {
 System.out.println(line);
 }
}

"మరో మాటలో చెప్పాలంటే, మేము కేవలం స్ట్రింగ్‌ను తీసుకొని, దానిని స్ట్రింగ్‌రీడర్‌లో చుట్టి, ఆపై రీడర్ ఆబ్జెక్ట్‌కు బదులుగా పాస్ చేసాము? మరియు దాని నుండి మనకు అవసరమైన విధంగా ప్రతిదీ చదవబడుతుంది?"

"అవును. మ్. మరియు దీనికి ఒక పాయింట్ ఉంది. ఇప్పుడు స్ట్రింగ్‌రైటర్ యొక్క పద్ధతులను పరీక్షిద్దాం. దీన్ని చేయడానికి, మేము ఉదాహరణను మరింత క్లిష్టతరం చేస్తాము. ఇప్పుడు అది పంక్తులను చదివి స్క్రీన్‌పై ప్రదర్శించదు, బదులుగా అది వాటిని రివర్స్ చేస్తుంది మరియు రైటర్ ఆబ్జెక్ట్‌కి అవుట్‌పుట్ చేస్తుంది. ఉదాహరణకు:"

public static void main (String[] args) throws Exception
{
 // The Reader must read this String.
 String test = "Hi!\n My name is Richard\n I'm a photographer\n";

 // Wrap the String in a StringReader.
 StringReader reader = new StringReader(test);

 // Create a StringWriter object.
 StringWriter writer = new StringWriter();

 // Copy strings from the Reader to the Writer, after first reversing them.
 executor(reader, writer);

 // Get the text that was written to the Writer.
 String result = writer.toString();

 // Display the text from the Writer on the screen.
 System.out.println("Result: "+ result);
}

public static void executor(Reader reader, Writer writer) throws Exception
{
 BufferedReader br = new BufferedReader(reader);
String line;

 // Read a string from the Reader.
while (line = br.readLine()) != null)
 {

 // Reverse the string.
  StringBuilder sb = new StringBuilder(line);
  String newLine = sb.reverse().toString();

 // Write the string to the Writer.
  writer.write(newLine);
 }
}

"మేము ఈ రైటర్‌కు వ్రాసిన ప్రతిదాన్ని నిల్వ చేసే స్ట్రింగ్‌ను కలిగి ఉన్న స్ట్రింగ్‌రైటర్ ఆబ్జెక్ట్‌ను సృష్టించాము . మరియు దానిని పొందడానికి, మీరు కేవలం toString () పద్ధతికి కాల్ చేయాలి."

"హ్మ్. ఏదో ఒకవిధంగా ఇదంతా చాలా సులభం అనిపిస్తుంది. ఎగ్జిక్యూటర్ పద్ధతి రీడర్ మరియు రైటర్ స్ట్రీమ్ ఆబ్జెక్ట్‌లతో పని చేస్తుంది, కానీ మేము ప్రధాన పద్ధతిలో స్ట్రింగ్‌లతో పని చేస్తున్నాము.

"ఇదంతా చాలా సింపుల్ గా ఉందా?"

"అవును. స్ట్రింగ్‌ను రీడర్‌గా మార్చడానికి , ఇలా వ్రాయండి:"

String s = "data";
Reader reader = new StringReader(s);

"మరియు స్ట్రింగ్‌రైటర్‌ను స్ట్రింగ్‌గా మార్చడం మరింత సులభం:"

Writer writer = new StringWriter();
/* Here we write a bunch of data to the writer */
String result = writer.toString();

"నా అభిప్రాయం ప్రకారం ఇవి అద్భుతమైన తరగతులు. వాటి గురించి నాకు చెప్పినందుకు ధన్యవాదాలు, ఎల్లీ."