StringReader, StringWriter

„Hallo, Amigo!“

„Hallo, Ellie!“

„Heute möchte ich Ihnen etwas über die Klassen StringReader und StringWriter erzählen . Im Prinzip wird es für Sie nicht viel Neues geben, aber manchmal sind diese Klassen sehr nützlich. Aber ich möchte, dass Sie es zumindest wissen dass es sie gibt.

„Diese Klassen sind die einfachsten Implementierungen der abstrakten Reader- und Writer-Klassen. Und sie ähneln grundsätzlich FileReader und FileWriter. Im Gegensatz zu diesen funktionieren diese jedoch nicht mit Daten in einer Datei auf der Festplatte. Stattdessen arbeiten sie mit einem String.“ im Speicher der JVM.

„Warum brauchen wir solche Kurse?“

„Manchmal werden sie benötigt. Im Wesentlichen ist StringReader ein Adapter zwischen den Klassen String und Reader . Und StringWriter ist ein String, der Writer erbt . Ja ... ich weiß, das ist nicht die beste Erklärung. Es ist besser, sich ein paar anzusehen von Beispielen zuerst.

„Angenommen, Sie möchten Ihre Methode testen, die Daten aus dem an sie übergebenen Reader-Objekt liest. Wir könnten es so machen:“

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

„Mit anderen Worten, wir haben einfach einen String genommen, ihn in einen StringReader verpackt und diesen dann anstelle eines Reader-Objekts übergeben? Und alles wird daraus gelesen, wie wir es brauchen?“

"Ja. Hmm. Und das hat seinen Sinn. Jetzt testen wir die Methoden von StringWriter. Dazu machen wir das Beispiel komplizierter. Jetzt werden die Zeilen nicht einfach gelesen und auf dem Bildschirm angezeigt es wird sie umkehren und an das Writer-Objekt ausgeben. Zum Beispiel:"

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

„Wir haben ein StringWriter- Objekt erstellt, das einen String enthält, der alles speichert, was an diesen Writer geschrieben wurde. Und um es zu erhalten, müssen Sie nur die toString ()-Methode aufrufen .“

„Hmm. Irgendwie scheint das alles zu einfach zu sein. Die Executor-Methode funktioniert mit den Reader- und Writer- Stream-Objekten, aber wir arbeiten mit Strings in der Main-Methode.

„Ist das wirklich alles so einfach?“

„Ja. Um einen String in einen Reader umzuwandeln , schreiben Sie einfach Folgendes:“

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

„Und das Konvertieren eines StringWriter in einen String ist noch einfacher:“

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

„Das sind meiner Meinung nach ausgezeichnete Kurse. Danke, dass du mir davon erzählt hast, Ellie.“