BufferedReader, BufferedWriter

"C'est encore moi."

« Salut, Élie ! »

"Aujourd'hui, j'aimerais tout vous dire sur BufferedReader et BufferedWriter ."

« Tu m'en as déjà parlé. Ils ne sont vraiment pas si compliqués.

"OK. Alors dis-moi comment fonctionne BufferedReader ."

" BufferedReader est comme un convertisseur 110/220V."

"Vous devez transmettre au constructeur BufferedReader l' objet Reader à partir duquel les données seront lues. Un objet BufferedReader lit de gros morceaux de données du lecteur et les stocke en interne dans un tampon. C'est pourquoi l'utilisation d'un BufferedReader pour lire à partir d'un lecteur est plus rapide que de lire directement à partir d'un lecteur ."

"C'est vrai. Et qu'en est-il de BufferedWriter ?"

"C'est un jeu d'enfant. Supposons que nous écrivions sur un FileWriter . Les données sont écrites sur le disque immédiatement. Si nous écrivons fréquemment de petits morceaux de données, nous toucherons beaucoup le disque, ce qui ralentira beaucoup le programme. Mais si nous utilisons un BufferedWriter comme "convertisseur", alors l'opération d'écriture est beaucoup plus rapide. Lorsque vous écrivez sur un BufferedWriter , il enregistre les données dans un tampon interne. Lorsque le tampon est plein, il écrit les données sur le Writer en tant que un seul gros morceau. C'est beaucoup plus rapide.

« Hmm. Parfait. Mais qu'as-tu oublié ?

"Une fois que vous avez terminé d'écrire, vous devez appeler la méthode flush() sur l' objet BufferedWriter pour le forcer à envoyer toutes les données encore dans le tampon au Writer ."

"Et quoi d'autre?"

"Quoi d'autre ? Oh ! Tant que le tampon n'a pas été écrit dans le Writer , les données peuvent être supprimées et/ou remplacées."

« Amigo ! Je suis impressionné ! Tu es un expert ! Eh bien, je vais te parler de nouvelles classes :  ByteArrayStream et PrintStream .

"Par exemple, ByteArrayInputStream et ByteArrayOutputStream ."

"Ces classes ressemblent un peu à StringReader et StringWriter . Sauf que StringReader lit les caractères ( char ) d'une chaîne ( String ), mais InputStream lit les octets d'un tableau d'octets ( ByteArray )."

StringWriter écrit des caractères ( char ) dans une chaîne, tandis que ByteArrayOutputStream écrit des octets dans un tableau d'octets interne. Lorsque vous écrivez dans un StringWriter , sa chaîne interne s'allonge et lorsque vous écrivez dans un ByteArrayOutputStream , son tableau d'octets interne se développe également de manière dynamique.

"Rappelez-vous l'exemple qui vous a été donné dans la dernière leçon :"

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

"Voici à quoi cela ressemblerait si cela fonctionnait en utilisant des octets au lieu de caractères :"

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

"Tout est identique à celui de l'exemple ci-dessus. Sauf que nous avons remplacé String par ByteArray, Reader par InputStream et Writer par OutputStream."

"Les deux seules autres étapes consistent à convertir la chaîne en un ByteArray et inversement. Comme vous pouvez le voir, cela se fait assez facilement :"

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

"Pour obtenir les octets qui ont déjà été ajoutés à un ByteArrayOutputStream, appelez la méthode toByteArray ()."

"Ah. Les similitudes avec StringReader/StringWriter sont assez fortes, surtout après que vous me les ayez signalées. Merci, Ellie, pour une leçon vraiment intéressante."

"Où partez-vous si pressé? J'ai encore un petit cadeau pour vous. Je veux vous parler de la classe PrintStream."

« PrintStream ? C'est la première fois que j'entends parler de cette classe.

"Ouais. Surtout, si vous ne comptez pas le fait que vous l'utilisez depuis le premier jour de vos études Java. Vous souvenez-vous de System.out ? Eh bien, System.out est une variable statique (de classe) du système class, et son type est... PrintStream ! C'est de là que viennent toutes ces méthodes print, println, etc.."

"Wow. Comme c'est intéressant. D'une certaine manière, je n'y ai même jamais pensé. Dis-m'en plus."

"Bien. D'accord, écoutez. La classe PrintStream a été inventée pour une sortie lisible. Elle se compose presque entièrement de méthodes print et println. Regardez ce tableau :"

"Il existe également plusieurs méthodes de format afin que vous puissiez générer des données à l'aide d'une chaîne de format. Par exemple :"

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.

"Oui, je me souviens. Nous avons déjà étudié la méthode de formatage de la classe String."

"C'est tout pour le moment."

"Merci, Ellie."