Filtre sur flux de données

Après avoir vu comment gérer de manières très basique des flux de données, nous allons améliorer le traitement de ces données.

En effet, il y a de forte chance que vous ayez besoin de traiter une ligne complète d'un flux de type caractère, plutôt que de traiter un caractère à la fois pour obtenir le contenu de cette même ligne !

Et il y a encore d'autres exemples du même style !

Ces traitements sont proposés dans une seconde catégorie de classes: Les filtres sur flux de données provenant du paquetage java.io.

Le principe de nommage des filtres est identique à celui utilisé pour nommé les flux de données:

Tout d'abord, il faut distinguer les classes de flux sur caractères et les classes de flux binaires. Et pour ces flux, si vous voulez faire une lecture ou une écriture.

Nous avons donc:

Les classes de flux de type caractères dérivant de:

• java.io.Reader pour la lecture
• java.io.Writer pour l'écriture

Les classes java.io.Reader et java.io.Writer étant des classes abstraires.

Les noms de ces classes se termineront ainsi par Reader ou Writer suivant le cas pour lire ou écrire des caractères.

Les classes de flux de type binaires dérivant de:

• java.io.InputStream pour la lecture
• java.io.OutputStream pour l'écriture

Les classes java.io.InputStream et java.io.OutputStream étant elles aussi des classes abstraires.

Les noms de ces classes se termineront cette fois-ci par InputStream ou OutputStream suivant le cas.

Ce qu'il reste à définir, c'est le filtre que l'on veut appliquer et là encore, il suffira de préfixer:

Pour InputStream

-> ObjectInputStream (sérialisation)

-> FilterInputStream

-> BufferedInputStream (gestion d'un tampon en mémoire)

-> DataInputStream (gestion des données binaires d'un type primitif autre que byte)

-> PushbackInputStream (gestion des retours en arrière pendant la lecture d'un flux)

Pour OutputStream

-> ObjectOutputStream (sérialisation)

-> FilterOutputStream

-> BufferedOutputStream (gestion d'un tampon en mémoire)

-> DataOutputStream (gestion des données binaires d'un type primitif autre que byte)

-> PrintStream (gestion des flux de données au format texte)

Pour Reader

-> InputStreamReader (gestion de l'encode des caractères des flux de données binaires)

-> FilterReader

-> PushbackReader (gestion des retours en arrière pendant la lecture d'un flux)

-> BufferedReader

-> LineNumberReader

Pour Writer

-> OutputStreamWriter

-> FilterWriter

-> BufferedWriter

-> PrintWriter

Le préfixe: Object que l'on applique à InputStream ou OutputStream sera étudié dans le chapitre sérialisation des objets...

Il s'agit en fait de charger ou de sauver l'instance d'un objet en mémoire (sérialisation).

D'autres préfixes: Zip, GZIP et Jar dans le paquetage java.util.zip et java.util.jar...

Fermeture d'un filtre

Tout comme les flux, tous filtres ouverts devront être fermés. Nous utiliserons pour cela la méthode close.

On préfèrera utiliser la méthode close() dans un bloc finally, permettant ainsi une fermeture propre du flux, qu'il y ait eu ou non une exception. Dans le même principe, la déclaration de la variable permettant d'identifier le flux (monFluxFichier dans mon exemple) sera à déclarer hors du bloc try et cette variable sera positionnée à null. Cela permet de tester celle-ci avant de faire un close(). Si la variable est toujours à null lors du finally, c'est que le flux n'a pas été ouvert, donc rien à faire (voir exemples ci-dessus) !

Principales méthodes des classes de filtres

Exemple de code simple

Dans le code suivant, nous allons récupérer toutes les lignes pour les comptabiliser et les afficher. Nous afficherons aussi la taille du fichier.

import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TstMain1 { public static void main(String[] args) { // TODO Auto-generated method stub FileReader monFluxFichier = null; BufferedReader monFiltre = null; try { File file; monFluxFichier = new FileReader (file=new File ("c:\\services")); monFiltre = new BufferedReader(monFluxFichier); int x = 0; String ligne = null; do { try { ligne = monFiltre.readLine(); if (ligne != null) { // S'il y a une ligne, incrémenter le compteur x++; // Nous aurons ainsi le nombre de lignes lus // Affichons la ligne System.out.println (ligne); } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }while (ligne != null); System.out.println ("\nNombre de lignes lues:"+x); System.out.println("Taille du fichier:"+file.length()); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { if (monFiltre != null) try { monFiltre.close(); } catch (IOException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } // Erreur ou pas, voyons si on doit fermer le fichier if (monFluxFichier != null) try { monFluxFichier.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }

Cumuler les filtres

Nous avons vu que jusqu'à présent, nous nous contentions de pluger un filtre sur un flux. Mais il sera possible de faire de même avec des filtres:

filtre 2 + filtre 1 + flux

Par exemple:

Appliquer un filtre DataOutputStream sur BufferedOutputStream sur un flux OutputStream.

Pb.: le type n'étant pas le même entre DataOutputStram et BufferedOutputStream, JAVA ne va pas aimer. Qu'à cela ne tienne, il existe un type qui est commun aux deux, il suffira donc d'utiliser: le type OutputStream.