Différence entre java.io.PrintWriter et java.io.BufferedWriter?

Veuillez consulter le code ci-dessous:

// A.class
File file = new File("blah.txt");
FileWriter fileWriter = new FileWriter(file);
PrintWriter printWriter = new PrintWriter(fileWriter);

// B.class
File file = new File("blah.txt");
FileWriter fileWriter = new FileWriter(file);
BufferedWriter bWriter = new BufferedWriter(fileWriter);

Quelle est la différence entre ces deux méthodes?

Quand devrions-nous utiliser PrintWriter sur BufferedWriter?

La référence API pour BufferedWriter et PrintWriter détaille les différences.

La principale raison d'utiliser PrintWriter est d'avoir accès aux méthodes printXXX comme println (). Vous pouvez essentiellement utiliser un PrintWriter pour écrire dans un fichier, tout comme vous utiliseriez System.out pour écrire sur la console.

Un BufferedWriter est un moyen efficace d'écrire dans un fichier (ou quoi que ce soit d'autre), car il mettra en mémoire tampon les caractères dans la mémoire Java avant (probablement, selon l'implémentation) de passer en C pour écrire dans le fichier.

Il n'y a pas de concept tel que "PrintReader"; le plus proche que vous obtiendrez est probablement java.util.Scanner .

PrintWriterdonne plus de méthodes ( println), mais la différence la plus importante (et inquiétante) à prendre en compte est qu'elle avale les exceptions .

Vous pouvez appeler checkErrorplus tard pour voir si des erreurs se sont produites, mais vous l'utiliserez généralement PrintWriterpour des choses comme l'écriture sur la console - ou dans des applications "rapides et sales" où vous ne voulez pas être dérangé par des exceptions (et où la fiabilité à long terme n'est pas un problème).

Je ne sais pas pourquoi les aspects "capacités de formatage supplémentaires" et "ne pas avaler les exceptions" sont regroupés dans la même classe - le formatage est évidemment utile dans de nombreux endroits où vous ne voulez pas que les exceptions soient avalées. Ce serait bien de voir BufferedWriterobtenir les mêmes capacités à un moment donné ...

Comme dit dans la réponse de TofuBeer, les deux ont leurs spécialités. Pour tirer pleinement parti de PrintWriter (ou de tout autre graveur) mais également utiliser l'écriture tamponnée, vous pouvez envelopper le BufferedWriter avec celui dont vous avez besoin comme ceci:

PrintWriter writer = new PrintWriter(
                         new BufferedWriter (
                             new FileWriter("somFile.txt")));

PrintWriter expose simplement les méthodes d'impression sur n'importe quel Writer en mode caractère.

BufferedWriter est plus efficace que, selon ses méthodes tamponnées. Et il est livré avec une méthode newLine (), en fonction de votre plate-forme système, pour manipuler correctement les fichiers texte.

Le BufferedReader permet de lire un texte à partir d'un fichier, avec des octets convertis en caractères. Il permet de lire ligne par ligne.

Il n'y a pas de PrintReader, vous devez choisir une autre implémentation de Reader en fonction du format de votre entrée.

PrintWriter est le Writer le plus amélioré pour écrire des données de caractères dans un fichier.

Le principal avantage de PrintWriter par rapport à FileWriter et BufferedWriter est:

1. PrintWriter peut communiquer directement avec le fichier et peut également communiquer via un objet Writer.

PrintWriter printwriter = new PrintWriter("blah.txt");

(ou)

FileWriter filewriter = new FileWriter("blah.txt");
PrintWriter printwiter = new PrintWriter(filewriter);

2. Nous pouvons écrire n'importe quel type de données primitives directement dans le fichier (car nous avons des versions surchargées supplémentaires des méthodes PrintWriter, c'est-à-dire print () et println ()).

   printwriter.print(65); //65
bufferedwriter.write(65); //A
printwriter.println(true); //true

En général, un Writer envoie immédiatement sa sortie au caractère ou au flux d'octets sous-jacent. À moins qu'une sortie rapide ne soit requise, il est conseillé d'encapsuler un BufferedWriter autour de tout Writer dont les opérations write () peuvent être coûteuses, comme FileWriters et OutputStreamWriters. Par exemple,

Remarque: le contenu du texte dans les blocs de code est automatiquement enveloppé de mots

PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("foo.out")));

mettra en mémoire tampon la sortie de PrintWriter dans le fichier. Sans mise en mémoire tampon, chaque appel d'une méthode print () entraînerait la conversion des caractères en octets qui seraient alors immédiatement écrits dans le fichier, ce qui peut être très inefficace.

BufferedWriter - Écrit du texte dans un flux de caractères de sortie, mettant en mémoire tampon les caractères d'un flux de caractères. PrintWriter - Imprime des représentations formatées d'objets dans un flux de sortie de texte.

Je pense que la raison de l'utilisation de PrintWriter est déjà mentionnée ci-dessus, mais l'une des raisons importantes est que vous transmettez un objet fichier directement au constructeur PrintWriter, ce qui facilite son utilisation.

File file=new File(“newfile.txt”);
PrintWriter pw=new PrintWriter(file);