Accueil
Java Standard Edition
Java EE 5
Visual Basic .Net 2005
Visual C++ .Net 2005
Visual C# .Net 2005
Cours ASP .Net 2.0
Postgresql
Linux
Visual Studio 2008
ASP 3.0 Classique
Cours Javascript - DOM - DHTML
Cours Ajax
VBA
Assembleur
Perl
Membres
L'auteur du site
Nouveautés sur le site
Contacts
Plan du site
Exécution d'un programme
Les archives Jar
Les classes abstraites
Les interfaces
Les tableaux
La généricité
Les énumérations
Les classes internes
Classes anonymes et internes locales
Les threads: généralités
Les threads(2): synchronisation
E/S(1):InputStream et OutputStream
E/S(2):FileInputStream et FileOutputStream
E/S(3):Reader et Writer
E/S(4):FilterInputStream et FilterOutputStream
E/S(5):Les filtres d'octets: PrintStream
E/S(6):Les filtres d'octets: DataInputStream et DataOutputStream
E/S(7):Les filtres d'octets: BufferedInputStream et BufferedOutputStream
E/S(8):Flux de caractères: PrintWriter
E/S(9):Flux de caractères: FilterReader et FilterWriter
E/S(10):Flux de caractères: InputStreamReader, OutputStreamWriter, StreamDecoder, StreamEncoder
E/S(11):Flux de caractères: BufferedReader et BufferedWriter
E/S(12):Flux de caractères: FileReader et FileWriter
La classe String (java.lang)
Les collections: L'interface Collection(java.lang)
Les collections(2): L'interface List(java.util)
Les collections(3): AbstractCollection(java.util)
Les collections(4): AbstractList(java.util)
La bibliothèque Swing en Java
Les bases de données en Java
JDBC ( Java Database Connectivity )
Les interfaces graphiques
Les fichiers de configuration en Java
INSTALLATION JAVA EE 5, JRE 6, ECLIPSE, TOMCAT, ETC SOUS LINUX
INSTALLATION JAVA EE 5, JRE 6, ECLIPSE, TOMCAT, ETC SOUS WINDOWS
Les applications Web en java
Les filtres Java (javax.servlet.Filter)
I Généralités
I.1 Le formulaire principal
I.2 Les objets créés par Visual
I.3 Les variables références
I.4 Le garbage collector
II Créer évènements
II.1 Rappel évènements
II.2 Procédure à suivre
II.2.1 Créer son EventArgs
II.2.2 Créer EmetEvent
II.2.3 Déclarations autres
I Généralités
I.1 Applications winforms
I.2 Applications MFC
I.3 Objets managés ou pas
I.4 Objets non managés
I.5 Objets managés - handle
I.6 Le top-level ^
II Créer évènements
II.1 Rappel évènements
II.2 Procédure à suivre
II.2.1 Créer son EventArgs
II.2.2 Créer EmetEvent
II.2.3 Déclarations autres
I Généralités
I.1 Puissant et Accessible
I.2 Créer ses classes
II Créer évènements
II.1 Rappel évènements
II.2 Procédure à suivre
III Les services Windows
IV Le .net remoting
V Communication Tcp avec TcpClient et TcpListener
II.2.1 Créer son EventArgs
II.2.2 Créer EmetEvent
II.2.3 Déclarations autres
I Généralités
I.1 Un EDI formidable
I.2 Inclure C# ou VB
I.3 L'objet Response
I.4 Les évènements
II ASP .net et les bdd
II.1 Essayer plusieurs fois la requête
I 2.1 Fichiers distincts
I.2.2 Avec la balise script
I.2.3 Inclure réellement
I.2.4 Avec Response.Write()
I.3.1 La méthode Response.Redirect()
I.4.1 Résoudre problème post
Installation Postgre Linux
Cours Postgresql
Le Shell Unix( Linux, Ubuntu)
Les scripts C-Shell
Programmation système Unix
Reseau Linux
Les iptables
Windows Presentation Foundation(WPF)
Le Framework 3.0
Windows Workflow Foundation(WF)
ASP 3.0 Classique
Cours Javascript - DOM - DHTML
Chat Ajax
VBA Excel 2003
Assembleur
Perl
Inscription
Liste membres
Livre d'or
Forum
Accueil
>
Java Standard Edition
>
E/S(4):FilterInputStream et FilterOutputStream
____________________________________________________________________________________________________
Connexion
Les entrées-sorties(4) - Les filtres de flux binaires
Sommaire :
I)Généralités
II) La classe java.io.FilterInputStream
III) Liste des méthodes
IV) Conclusions sur FilterInputStream
V) La classe java.io.FilterOutputStream
VI) Liste des méthodes de FilterOutputStream
I)Généralités
Les classes de base pour les filtres de flux binaires sont
public class FilterInputStream extends InputStream
et
public class FilterOutputStream extends OutputStream
Ces deux classes représentent des filtres, qui s'appliquent à un flux d'entrée binaire ou un flux de sortie. Un tel filtre prend comme source de donnée le flux en question, et transforme les données ou ajoute de nouvelles fonctionnalités.
II) La classe java.io.FilterInputStream
public class FilterInputStream extends InputStream
La classe hérite directement de java.io.InputStream.
//(...) /** * The input stream to be filtered. */ protected volatile InputStream in; /** * Creates a <code>FilterInputStream</code> * by assigning the argument <code>in</code> * to the field <code>this.in</code> so as * to remember it for later use. * * @param in the underlying input stream, or <code>null</code> if * this instance is to be created without an underlying stream. */ protected FilterInputStream(InputStream in) { this.in = in; } //(...)
On remarque une propriété protected, appelée "in", et contenant le flux InputStream à filtrer.
Remarquons également un unique constructeur, qui prend le flux InputStream en paramètre, et qui affecte la propriété "in" avec celui-ci.
III) Liste des méthodes
public int read() throws IOException { return in.read(); } public int read(byte b[]) throws IOException { return read(b, 0, b.length); } public int read(byte b[], int off, int len) throws IOException { return in.read(b, off, len); } public long skip(long n) throws IOException { return in.skip(n); } public int available() throws IOException { return in.available(); } public void close() throws IOException { in.close(); } public synchronized void mark(int readlimit) { in.mark(readlimit); } public synchronized void reset() throws IOException { in.reset(); } public boolean markSupported() { return in.markSupported(); }
On remarque que les méthodes sont toutes les méthodes de InputStream qui sont redéfinies. Leur implémentation est minimale, c'est-à-dire qu'elles ne font qu'appeler la méthode correspondante de l'objet flux de base(le "in"). Ceci va de soi, car FilterInputStream est la classe de base pour les filtres d'entrée d'octets, par conséquent le filtre ne fera rien.
IV) Conclusions sur FilterInputStream
On remarque de l'implémentation de FilterInputStream, que le filtre et le flux sous-jacent sont deux objets différents.
Deuxième remarque: le filtre est lui-même un flux d'entrée binaire( il hérite de InputStream, et ses méthodes appellent celles du flux sous-jacent). Il serait donc plus exact de nommé la classe "Flux d'entrée filtré", plutôt que filtre. Cependant il est vrai que ce n'est pas un vrai flux non plus, car il se sert d'un autre flux pour produire le flux de données.
Les classes qui hériteront de FilterInputStream n'auront qu'à implémenter les transformations qu'elles souhaitent, ainsi que les ajouts de fonctionnalités. Mais elles auront toutes en commun l'objet "in" en attribut, etc...
Remarquons qu'on construit un objet filtre à partir d'un objet flux. Le flux ne "filtre" pas lui-même les données, car la définition d'un flux, c'est d'être fidèle aux données du flux! C'est pour cette raison que les transformations et ajouts ne sont pas implémentées directement dans les classes de flux.
Autre question: pourquoi avoir mis le flux sous-jacent sous forme d'objet attribut? N'oublions pas que le "in" est un InputStream, ce qui signifie qu'il peut être de n'importe quelle classe héritant de la classe InputStream, ce peut même être un autre filtre! Le principe est de créer un nouveau flux, qui va utiliser les méthodes du flux de base.
Sans cette façon de faire, si on avait voulu faire un filtre simplement en héritant de la classe de flux qu'on veut filtrer, il aurait fallu réécrire les mêmes classes de filtres pour chaque classe de flux! Ici on peut appliquer notre filtre sur n'importe quel flux. On peut même appliquer un filtre sur un filtre, car un filtre est lui-même un InputStream!
V) La classe java.io.FilterOutputStream
public class FilterOutputStream extends OutputStream
Cette classe est similaire à FilterInputStream, mais pour les flux de sortie.
Son attribut, comparable au "in", est:
protected OutputStream out;
Elle possède ununique constructeur:
public FilterOutputStream(OutputStream out) { this.out = out; }
VI) Liste des méthodes de FilterOutputStream
Toutes les méthodes appellent la méthode correspondante du flux en question, sauf deux méthodes write, mais qui se servent de write(int b), qui elle fait uniquement out.write(b).
public void write(int b) throws IOException { out.write(b); }
public void write(byte b[]) throws IOException { write(b, 0, b.length); }
Elle utilise write(byte b[], int off, int len), donc write(int b).
public void write(byte b[], int off, int len) throws IOException { if ((off | len | (b.length - (len + off)) | (off + len)) < 0) throw new IndexOutOfBoundsException(); for (int i = 0 ; i < len ; i++) { write(b[off + i]); } }
Utilise write(int b).
public void flush() throws IOException { out.flush(); }
public void close() throws IOException { try { flush(); } catch (IOException ignored) { } out.close(); }
IV) Conclusions sur FilterInputStream
V) La classe java.io.FilterOutputStream
VI) Liste des méthodes de FilterOutputStream
RETOUR HAUT