BufferedReader, BufferedWriter

"Sono di nuovo io."

"Ciao, Eli!"

"Oggi vorrei parlarvi di BufferedReader e BufferedWriter ."

"Me ne hai già parlato. Non sono poi così complicati."

"OK. Allora dimmi come funziona BufferedReader ."

" BufferedReader è come un convertitore 110/220V."

"Devi passare al costruttore BufferedReader l' oggetto Reader da cui verranno letti i dati. Un oggetto BufferedReader legge grossi blocchi di dati dal Reader e li memorizza internamente in un buffer. Ecco perché usare un BufferedReader per leggere da un Reader è più veloce piuttosto che leggere direttamente da un Reader ".

"Esatto. E cosa mi dici di BufferedWriter ?"

"È un gioco da ragazzi. Supponiamo di scrivere su un FileWriter . I dati vengono scritti su disco immediatamente. Se scriviamo piccoli bit di dati frequentemente, allora colpiremo molto il disco, il che rallenterà molto il programma. Ma se usiamo un BufferedWriter come 'convertitore', allora l'operazione di scrittura è molto più veloce.Quando scrivi su un BufferedWriter , salva i dati in un buffer interno.Quando il buffer è pieno, scrive i dati nel Writer come un singolo grosso pezzo. Questo è molto più veloce."

"Hmm. Perfetto. Ma cosa hai dimenticato?"

"Dopo aver finito di scrivere, devi chiamare il metodo flush() sull'oggetto BufferedWriter per costringerlo a inviare tutti i dati ancora nel buffer al Writer ."

"E che altro?"

"Cos'altro? Oh! Finché il buffer non è stato scritto nel Writer , i dati possono essere cancellati e/o sostituiti."

"Amigo! Sono impressionato! Sei un esperto! Bene, allora ti parlerò di alcune nuove classi:  ByteArrayStream e PrintStream ."

"Ad esempio, ByteArrayInputStream e ByteArrayOutputStream ."

"Queste classi sono un po' come StringReader e StringWriter . Tranne che StringReader legge i caratteri ( char ) da una stringa ( String ), ma InputStream legge i byte da un array di byte ( ByteArray )."

StringWriter scrive caratteri ( char ) in una stringa, mentre ByteArrayOutputStream scrive byte in una matrice di byte interna. Quando scrivi su un StringWriter , la sua stringa interna si allunga e quando scrivi su un ByteArrayOutputStream anche il suo array di byte interno si espande dinamicamente.

"Ricorda l'esempio che ti è stato dato nell'ultima lezione:"

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

"Ecco come apparirebbe se funzionasse usando i byte invece dei caratteri:"

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

"Tutto è come nell'esempio sopra. Tranne che abbiamo sostituito String con ByteArray, Reader con InputStream e Writer con OutputStream."

"Gli unici altri due passaggi sono la conversione di String in un ByteArray e viceversa. Come puoi vedere, questo viene fatto abbastanza facilmente:"

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

"Per ottenere i byte che sono già stati aggiunti a un ByteArrayOutputStream, chiama il metodo toByteArray ()."

"Ah. Le somiglianze con StringReader/StringWriter sono piuttosto forti, soprattutto dopo che me le hai fatte notare. Grazie, Ellie, per una lezione davvero interessante."

"Dove vai così di fretta? Ho ancora un regalino per te. Voglio parlarti del corso PrintStream."

"PrintStream? È la prima volta che sento parlare di quel corso."

"Sì. Specialmente, se non conti il ​​fatto che lo usi dal primo giorno dei tuoi studi su Java. Ricordi System.out ? Beh, System.out è una variabile statica (di classe) del sistema class, e il suo tipo è... PrintStream ! Da qui derivano tutti questi metodi print, println, ecc."

"Wow. Interessante. In qualche modo non l'ho nemmeno preso in considerazione. Dimmi di più."

"Bene. Okay, ascolta. La classe PrintStream è stata inventata per un output leggibile. Consiste quasi interamente di metodi print e println. Guarda questa tabella:"

"Esistono anche diversi metodi di formattazione in modo da poter emettere dati utilizzando una stringa di formato. Ad esempio:"

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.

"Sì, mi ricordo. Abbiamo già studiato il metodo format della classe String."

"È tutto per ora."

"Grazie, Eli."