Les flots de caractères sont des objets de classe Reader (flots de caractères d'entrée) ou Writer (flots de caractères de sortie). Les méthodes read et write de ces classes sont analogues à celles opérant sur des flots d'octets, à la différence que c'est un caractère 16 bits qui est lu ou écrit, et non un octet.
La conversion entre un flot d'octets et un flot de caractères se fait à l'aide des classes OutputStreamWriter et InputStreamReader, par décoration d'un flot d'octets :
InputStreamReader isr = new InputStreamReader(System.in);
Cette conversion permet éventuellement de spécifier le codage utilisé (par exemple, par la chaîne "UTF8" s'il s'agit du codage des caractères Unicode par une suite d'octets de longueur variable) pour lire un fichier "toto":
InputStreamReader isr =
new InputStreamReader(
new FileInputStream("toto"),
"UTF8"
);
Pour connecter un flot de caractères à un fichier, si la conversion par défaut est appropriée, il est plus simple de recourir aux classes FileWriter et FileReader, qui s'emploient de façon analogue à FileOutputStream et FileInputStream.
La classe PrintWriter permet d'écrire sur un flot de sortie des données en les représentant à l'aide de chaînes de caractères Unicode (16 bits), à l'aide des méthodes print et println (la représentation textuelle d'un objet est obtenue par la méthode toString). Pour bénéficier de ces méthodes, on doit procéder par décoration d'un objet de type Writer :
PrintWriter pw =
new PrintWriter(
new FileWriter("toto"));
...
pw.println("ici, un texte en caractères latins");
On peut également spécifier un codage afin d'écrire des caractères Unicode quelconques sur un fichier :
PrintWriter pw =
new PrintWriter(
new OutputStreamWriter(
new FileOutputStream("toto"),
"UTF8"
));
pw.println("ici, un mot grec : \u039B\u039F\u0393\u039F\u03A3");
Les 5 lettres de ce mot grec sont écrites sur le fichier sous la forme des 10 octets suivants (en notation hexadécimale) : CE 9B CE 9F CE 93 CE 9F CE A3.
Un flot de caractères de la classe BufferedReader permet des opérations supplémentaires (par exemple, lecture d'une ligne de texte, par la méthode readLine). Il est très courant de connecter un tel tampon à un flot de lecture sur un fichier :
BufferedReader in =
new BufferedReader( // décorateur
new FileReader("toto")); // délégué
String s = in.readLine();
Symétriquement, pour écrire sur un fichier, il est préférable de travailler avec un tampon :
PrintWriter out =
new PrintWriter( // décorateur
new BufferedWriter( // décorateur
new FileWriter("toto"))); // délégué
out.println("un long texte");
Les classes StringReader et StringWriter permettent de construire un flot de lecture ou d'écriture à partir d'une chaîne de caractères au lieu d'un fichier :
String s = ...;
StringReader in =
new StringReader(s);
La classe StringWriter est particulièrement utile pour construire une chaîne à partir d'autres chaînes, de façon plus efficace qu'en recourant à la méthode append. Par exemple une redéfinition de la méthode toString a souvent la forme suivante :
public String toString() {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw); // décorateur
// pw.print(...);
return sw.toString();
}