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 comme vous utiliseriez System.out pour écrire dans la console.
Un BufferedWriter est un moyen efficace d'écrire dans un fichier (ou toute autre chose), car il tamponnera les caractères dans la mémoire Java avant (probablement, selon l'implémentation) de passer en C pour faire le écrire dans le fichier.
Il n'y a pas de concept tel qu'un "PrintReader"; le plus proche que vous obtiendrez est probablement Java.util.Scanner .
PrintWriter donne plus de méthodes (println), mais la différence la plus importante (et inquiétante) dont il faut être conscient est que elle avale les exceptions.
Vous pouvez appeler checkError plus tard pour voir si des erreurs se sont produites, mais vous utiliserez généralement PrintWriter pour des choses comme écrire sur la console - ou dans des applications "rapides et sales" où vous ne veulent pas être dérangés par les 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 d'exceptions" sont regroupés dans la même classe - le formatage est évidemment utile dans de nombreux endroits où vous ne le faites pas veulent que les exceptions soient avalées. Ce serait bien de voir BufferedWriter obtenir les mêmes capacités à un moment donné ...
Comme indiqué dans la réponse de TofuBeer, les deux ont leurs spécialités. Pour tirer pleinement parti de PrintWriter (ou de tout autre écrivain) mais aussi utiliser l'écriture tamponnée, vous pouvez envelopper BufferedWriter avec celle nécessaire 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 rédacteur le plus amélioré pour écrire des données de caractères dans un fichier.
Le principal avantage de PrintWriter sur FileWriter et BufferedWriter est:
- 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);
Nous pouvons écrire tout 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); //65bufferedwriter.write(65); //Aprintwriter.println(true); //true
En général, un Writer envoie sa sortie immédiatement au flux de caractères ou d'octets sous-jacent. Sauf si une sortie rapide est requise, il est conseillé d'enrouler un BufferedWriter autour de tout Writer dont les opérations write () peuvent être coûteuses, telles que FileWriters et OutputStreamWriters. Par exemple,
Remarque: le contenu du texte dans les blocs de code est automatiquement renvoyé à la ligne
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 invocation d'une méthode print () entraînerait la conversion de caractères en octets qui seraient ensuite écrits immédiatement dans le fichier, ce qui peut être très inefficace.
BufferedWriter - Écrit du texte dans un flux de caractères de sortie, en tamponnant 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.