Lector de cadenas, escritor de cadenas

"¡Hola, amigo!"

"¡Hola, Ellie!"

"Hoy quiero hablarles sobre las clases StringReader y StringWriter . En principio, no habrá mucho que sea nuevo para ustedes, pero a veces estas clases son muy útiles. Pero, como mínimo, quiero que sepan que existen".

"Estas clases son las implementaciones más simples de las clases abstractas Reader y Writer. Y son básicamente similares a FileReader y FileWriter. Sin embargo, a diferencia de esas, estas no funcionan con datos en un archivo en el disco. En su lugar, funcionan con un String en la memoria de la JVM".

"¿Por qué necesitaríamos tales clases?"

"A veces son necesarios. Esencialmente, StringReader es un adaptador entre las clases String y Reader . Y StringWriter es un String que hereda Writer . Sí... Puedo decir que esa no es la mejor explicación. Será mejor mirar un par de ejemplos primero".

"Por ejemplo, suponga que desea probar su método, que lee los datos del objeto Reader que se le pasa. Podríamos hacerlo así:"

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

"En otras palabras, simplemente tomamos un String, lo envolvimos en un StringReader y luego lo pasamos en lugar de un objeto Reader. ¿Y todo se leerá como lo necesitamos?"

"Sí. Hmm. Y hay un punto en esto. Ahora probemos los métodos de StringWriter. Para hacer esto, haremos que el ejemplo sea más complicado. Ahora no simplemente leerá las líneas y las mostrará en la pantalla, sino que los revertirá y los enviará al objeto escritor. Por ejemplo:"

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

"Creamos un objeto StringWriter que contiene una cadena que almacena todo lo escrito en este escritor . Y para obtenerlo, solo necesita llamar al método toString ()".

"Hmm. De alguna manera, todo parece demasiado fácil. El método ejecutor funciona con los objetos de flujo de lectura y escritura , pero estamos trabajando con cadenas en el método principal.

"¿Es todo realmente así de simple?"

"Sí. Para convertir una cadena en un lector , solo escribe esto:"

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

"Y convertir un StringWriter en un String es aún más fácil:"

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

"Estas son clases excelentes, en mi opinión. Gracias por hablarme de ellas, Ellie".