StringReader, StringWriter

"Hallo Amigo!"

"Hallo, Ellie!"

"Vandaag wil ik je vertellen over de StringReader- en StringWriter- klassen. In principe zal er niet veel nieuws voor je zijn, maar soms zijn deze klassen erg handig. Maar ik wil op zijn minst dat je weet dat ze bestaan."

"Deze klassen zijn de eenvoudigste implementaties van de abstracte Reader- en Writer-klassen. En ze zijn in wezen vergelijkbaar met FileReader en FileWriter. In tegenstelling tot deze werken deze echter niet met gegevens in een bestand op schijf. In plaats daarvan werken ze met een string in het geheugen van de JVM."

"Waarom zouden we zulke lessen nodig hebben?"

"Soms zijn ze nodig. In wezen is StringReader een adapter tussen de String- en Reader- klassen. En StringWriter is een string die Writer erft . Ja... ik kan zien dat dit niet de beste verklaring is. Het is beter om naar een paar voorbeelden eerst."

"Stel bijvoorbeeld dat u uw methode wilt testen, die gegevens leest van het Reader-object dat eraan is doorgegeven. We zouden het als volgt kunnen doen:"

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

"Met andere woorden, we hebben gewoon een string genomen, deze in een StringReader gewikkeld en die vervolgens doorgegeven in plaats van een Reader-object? En alles wordt eruit gelezen zoals we nodig hebben?"

"Ja. Hmm. En daar zit een punt in. Laten we nu de methoden van StringWriter testen. Om dit te doen, zullen we het voorbeeld ingewikkelder maken. Nu zal het niet alleen de regels lezen en ze op het scherm weergeven, maar het zal ze omkeren en uitvoeren naar het object Writer. Bijvoorbeeld:"

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

"We hebben een StringWriter- object gemaakt dat een string bevat die alles opslaat dat naar deze schrijver is geschreven . En om het te krijgen, hoef je alleen maar de toString () -methode aan te roepen."

"Hmm. Op de een of andere manier lijkt het allemaal te gemakkelijk. De executor-methode werkt met de reader- en writer- streamobjecten, maar we werken met strings in de main-methode.

"Is het allemaal zo eenvoudig?"

"Ja. Om een ​​String naar een Reader te converteren , schrijf gewoon dit:"

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

"En het converteren van een StringWriter naar een String is nog eenvoudiger:"

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

'Dit zijn naar mijn mening uitstekende lessen. Bedankt dat je me erover hebt verteld, Ellie.'