voisin-polian : introduction à java 1 introduction à java - les flots - frédéric voisin –...
TRANSCRIPT
Voisin-Polian : Introduction à Java 1
Introduction à Java
- les flots -
Frédéric VOISIN – Nicole POLIAN
FIIFO - « Remise à Niveau »
Voisin-Polian : Introduction à Java 2
Vue partielle de la hiérarchie relative aux entrées-sortiesjava.io.Filejava.io.FileDescriptorjava.io.InputStream java.io.ByteArrayInputStream java.io.FileInputStream java.io.FilterInputStream java.io.BufferedInputStream java.io.DataInputStream java.io.LineNumberInputStream java.io.PushbackInputStream java.io.ObjectInputStream java.io.PipedInputStream java.io.SequenceInputStream java.io.StringBufferInputStreamjava.io.ObjectStreamClassjava.io.OutputStream java.io.ByteArrayOutputStream java.io.FileOutputStream java.io.FilterOutputStream java.io.BufferedOutputStream java.io.DataOutputStream java.io.PrintStream java.io.ObjectOutputStream java.io.PipedOutputStream ...
Voisin-Polian : Introduction à Java 3
java.io.Reader java.io.BufferedReader java.io.LineNumberReader java.io.CharArrayReader java.io.FilterReader java.io.PushbackReader java.io.InputStreamReader java.io.FileReader java.io.PipedReader java.io.StringReaderjava.io.Writer java.io.BufferedWriter java.io.CharArrayWriter java.io.FilterWriter java.io.OutputStreamWriter java.io.FileWriter java.io.PipedWriter java.io.PrintWriter java.io.StringWriterjava.security.Permissionjava.io.FilePermission
N'apparaît pas ici notamment la hiérarchie liée aux exceptions !
Voisin-Polian : Introduction à Java 4
Hiérarchie des interfaces
java.io.DataInput
java.io.ObjectInput
java.io.DataOutput
java.io.ObjectOutput
java.io.FileFilter
java.io.FilenameFilter
java.io.ObjectInputValidation
java.io.ObjectStreamConstants
java.io.Serializable
java.io.Externalizable
Voisin-Polian : Introduction à Java 5
Les flots
Un flot de données est une suite d’octets, issus d’une source et allant vers un but.
La source et le but peuvent être : un fichier une chaîne (en mémoire) un tableau d’octets (en mémoire) une socket un processus une URL . . . . . . . . . .
Le Package java.io contient de nombreuses classes traitant des entrées/sorties
Voisin-Polian : Introduction à Java 6
Les flots
Les flots en java sont structurés en deux hiérarchies distinctes, une pour les flots d’entrées et une pour les flots de sorties. Les deux classes de bases (abstraites) en sont InputStream OutputStream
Deux autres « hiérarchies » sont réservées aux entrées et sorties « textuelles » (avec une passerelle possible à partir des flots classiques). Les deux classes de base (abstraites) en sont Reader Writer
Voisin-Polian : Introduction à Java 7
Classes d’extraction et de fonctionnalité
les « classes d’extraction » servent à extraire des données d’une source les « classes de fonctionnalité » ajoutent des fonctionnalités Exemple :
la classe FileWriter (dérivée de Writer) permet d’extraire des données et de les « écrire »
la classe PrintWriter propose des fonctions évoluées (par exemple println)
On est souvent amener à composer les deux :
PrintWriter pr = new PrintWriter(new FileWriter("toto.txt "));
Voisin-Polian : Introduction à Java 8
Les flots d’octets en lecture
FileInputStream FilterInputStream ObjectInputStream
InputStream
BufferedInputStream DataInputStream
StringBufferInputStream
ByteArrayInputStream
PipedInputStream
SequenceInputStream
classes d’extraction classes de fonctionnalités
Voisin-Polian : Introduction à Java 9
Les flots d’octets en écriture
FileOutputStream FilterOutputStream ObjectOutputStream
OutputStream
BufferedOutputStream DataOutputStream
ByteArrayOutputStream
PipedOutputStream
classes d’extraction classes de fonctionnalités
PrintStream
Voisin-Polian : Introduction à Java 10
Les flots de caractères en lecture
BufferedReader FilterReader InputStreamReader
Reader
LineNumberReader PushbackReader
CharArrayReader StringReader
classes d’extraction classes de fonctionnalités
FileReader
PipedReader
Voisin-Polian : Introduction à Java 11
Les flots de caractères en écriture
BufferedWriter OutputStreamWriter CharArrayWriter
Writer
PrintWriter FilterWriter
classes d’extraction classes de fonctionnalités
FileWriter
PipedWriterStringWriter
Voisin-Polian : Introduction à Java 12
La classe FILE
La classe File permet de modéliser les chemins d’accès aux fichiers (et aux répertoires). Cela correspond à une « abstraction » de fichier.
Cette classe permet
de tester l’existence (et le type) d’un fichier de créer (ou de supprimer) un fichier de renommer un fichier de lister le contenu d’un répertoire . . . . . . . . . . . . .
Voisin-Polian : Introduction à Java 13
La classe File : constructeurs
Constructeurs
File (String Chemin)
File (String CheminPere, String cheminFils) CheminPere désigne un répertoire CheminFils désigne un chemin dans ce répertoire
File (File cheminPere, String cheminFils) CheminPere désigne un répertoire (via une « abstraction ») CheminFils désigne un chemin dans ce répertoire
Voisin-Polian : Introduction à Java 14
La classe File : méthodes
Les « attributs » du fichier
public boolean canRead()
public boolean canWrite()
public boolean exists()
public boolean isDirectory()
public boolean isFile()
public long lastModified()
public long length()
Voisin-Polian : Introduction à Java 15
La classe File : méthodes
Opérations sur les fichiers public boolean createNewFile()
// création si le fichier « nommé » (via son abstraction) n’existe pas
public boolean delete()
public void deleteOnExit()
public boolean renameTo(File dest) Opérations sur les répertoires
public boolean mkdir()
public boolean mkdirs() Contenu d’un répertoire
public String[] list()
public File[] listFiles()
Voisin-Polian : Introduction à Java 16
La classe File : méthodes
Autres méthodes
getName
getParent
toURL
setReadOnly
createTempFile
compareTo
equals
toString
Voisin-Polian : Introduction à Java 17
La classe File : exemple
public static void main (String[] args) throws IOException { File r, f; int i; String [] dir; r = new File("Exemple"); if (r.isDirectory()) { dir = r.list( ) ; // affichage du contenu de REP for(i=0; i < dir.length; i++) System.out.println(dir[i]); f = new File("Exemple/" + "toto.txt") ; // ou bien : f = new File("Exemple","toto.txt"); if (f.exists()) { System.out.println("toto.txt existe, sa taille est "
+ f.length()) ; File nf = new File("Exemple/", "titi.txt"); f.renameTo(nf); // renommage de toto.txt } else System.out.println("toto.txt n'existe pas"); dir = r.list(); for(i=0; i < dir.length; i++) System.out.println(dir[i]); } }
Voisin-Polian : Introduction à Java 18
La classe (abstraite) InputStream
Principales méthodes : abstract int read() // lecture d’un octet (doit être redéfinie) int read(byte[] b) int read(byte[] b, int off, int len)
lecture d’un tableau d’octets, retourne le nombre lu, -1 en cas de fin de flot
void close() int available() // retourne le nombre d’octets pouvant être lus
long skip (long n) consomme n octets du flot, retourne le nombre d’octets consommés
Voisin-Polian : Introduction à Java 19
InputStream
Deux classes dérivées FileInputStream, pour les fichiers, avec trois constructeurs FileInputStream(String nom) FileInputStream(File f) FileInputStream(FileDescriptor fd)
ByteArrayInputStream pour les données « en mémoire », avec deux constructeursByteArrayInputStream(byte[] b)
ByteArrayInputStream(byte[] b, int offset, int length)
Voisin-Polian : Introduction à Java 20
Exemple de lecture dans un fichier
public static void main (String[] args) { FileInputStream ficLect; int taille, i = 0, bt, offset; byte[] data; try { ficLect = new FileInputStream(args[0]); // ou bien File f = new File(args[0]); // ficLect = new FileInputStream(f); taille = ficLect.available(); System.out.println("taille : " + taille);
// lecture des donnees --------> cf. transparent suivant ficLect.close(); } catch (java.io.FileNotFoundException ex) { System.out.println("Fichier inexistant : " + ex); } catch (IOException ex) { System.out.println("erreur d'entree-sortie : " + ex); } }Q: Ce code est-il correct ?
Voisin-Polian : Introduction à Java 21
Exemple de lecture dans un fichier (suite)
lecture octet par octetdata1 = new byte[taille];bt = ficLect.read();while (bt != -1) { data1[i++] = (byte) bt;
bt = ficLect.read();}
lecture d'un coup data2 = new byte[taille]; i = ficLect.read(data2);
lecture par blocs data3 = new byte [taille] ; offset = 0 ; i = ficLect.read(data3, offset, 10); while (i > 0) { offset += i; i = ficLect.read(data3, offset, 10); }
Voisin-Polian : Introduction à Java 22
La classe (abstraite) OutputStream
Principales méthodes : abstract void write ()
écriture d’un octet (doit être redéfinie) void write(byte[] b) void write(byte[] b, int off, int len) écriture d’un tableau d’octets void close() void flush()
Voisin-Polian : Introduction à Java 23
OutputStream
Classes dérivées
FileOutputStream pour les fichiers, avec quatre constructeurs
FileOutputStream (String nom)
FileOutputStream(String nom, boolean append)
FileOutputStream(File f)
FileOutputStream(FileDescriptor fd)
ByteArrayOutputStream pour les données « en mémoire »
Voisin-Polian : Introduction à Java 24
Exemple d’écriture dans un fichier
public static void main (String[] args) { FileInputStream ficLect; FileOutputStream ficEcr1, ficEcr2; int taille, i = 0, bt, offset; byte[] data; try { ficLect = new FileInputStream(args[0]) ; taille=ficLect.available(); data=new byte[taille];
i=ficLect.read(data); ficLect.close(); // ecriture octet par octet ficEcr1 = new FileOutputStream(args[0] + ".c1"); for(i=0; i<taille; i++) { ficEcr1.write(data[i]);} ficEcr1.close( ) ;
// ecriture d’un seul coup ficEcr2 = new FileOutputStream(args[0] + ".c2") ; ficEcr2.write(data);
ficEcr2.close(); } catch (java.io.FileNotFoundException ex) { System.out.println("Fichier inexistant : " + ex );
} catch (IOException ex) { System.out.println("erreur d'entree-sortie : " + ex); } }
Voisin-Polian : Introduction à Java 25
InputStream
La classe dérivée FilterInputStream sert de classe de base à de nombreuses classes dérivées spécialisant la lecture.
Parmi celles-ci, la classe DataInputStream permet de lire les principaux types de données
constructeur à partir d’un InputStreamDataInputStream(InputStream input)
quelques méthodesboolean readBoolean();double readDouble();char readChar();. . . . . . . . . . . . . . .
Voisin-Polian : Introduction à Java 26
OutputStream
La classe dérivée FilterOutputStream sert de classe de base à de nombreuses classes dérivées spécialisant l’écriture.
Parmi celles-ci, la classe DataOutputStream permet d’écrire les principaux types de données
constructeur à partir d’un OutputStreamDataOutputStream(OutputStream output)
quelques méthodesvoid writeBoolean(boolean);void writeDouble(double);void writeChar(char);. . . . . . . . . . . . . . .
Voisin-Polian : Introduction à Java 27
Lecture/Ecriture avec Data….Stream
public static void main ( String[] args) { DataInputStream ficLect; DataOutputStream ficEcr; double pi = 3.141592, pi2; int ent = 12879, ent2; try { ficEcr = new DataOutputStream(new FileOutputStream(args[0])); ficEcr.writeDouble(pi); ficEcr.writeInt(ent); ficEcr.close();
ficLect = new DataInputStream(new FileInputStream(args[0])); pi2 = ficLect.readDouble(); ent2 = ficLect.readInt(); ficLect.close() ; System.out.println("pi=" + pi + " pi2=" + pi2); System.out.println("ent=" + ent + " ent2=" + ent2); } catch(java.io.FileNotFoundException ex){ System.out.println("Fichier inexistant : " + ex ); } catch (IOException ex) { System.out.println("erreur d'entree-sortie : " + ex); } }
Voisin-Polian : Introduction à Java 28
Lecture/Ecriture en mémoire
public static void main(String[] args) {
ByteArrayOutputStream ficMemoire ;
DataInputStream ficLect; DataOutputStream ficEcr;
byte bt[] ;
double pi = 3.141592, pi2; int ent = 12879, ent2;
try {
ficMemoire = new ByteArrayOutputStream();
ficEcr = new DataOutputStream(ficMemoire);
ficEcr.writeDouble(pi); ficEcr.writeInt(ent);
bt = ficMemoire.toByteArray();
ficEcr.close();
ficLect = new DataInputStream(
new ByteArrayInputStream(bt));
pi2 = ficLect.readDouble(); ent2 = ficLect.readInt();
ficLect.close();
} catch . . . . . . . . . .
Voisin-Polian : Introduction à Java 29
La classe PrintStream
Dérivée de la classe FilterOutputStream, la classe PrintStream permet les sorties « formatées » sur un flot de sortie
un constructeurPrintStream ( OutputStream os)
quelques méthodesvoid print ( int ) void println ( int )void print ( String )void println ( String ). . . . . . . . . . . . . . . . . .
Les champs statiques err et out de la classe System sont des PrintStream alors que le champ statique in est un InputStream
Il existe la classe PrintWriter (dérivée de Writer), plus récente, et très voisine
Voisin-Polian : Introduction à Java 30
Utilisation de la classe PrintStream
public static void main(String[] args) { PrintStream ficTexte; int i = 12; double pi = 3.141592; try { ficTexte = new PrintStream(new FileOutputStream(args[0])); ficTexte.println("premiere ligne de texte"); ficTexte.println("avec un entier : " + i); ficTexte.println("avec un double : " + pi); ficTexte.close(); } catch (java.io.FileNotFoundException ex) { System.out.println( "Fichier inexistant : " + ex); } catch (IOException ex) { System.out.println( "erreur d'entree-sortie :" + ex); }}
Contenu du fichier créépremiere ligne de texteavec un entier : 12avec un double : 3.141592
Voisin-Polian : Introduction à Java 31
Les classes Reader et Writer
La classe Reader est une classe abstraite spécialisée dans les entrées textuelles.
Une classe dérivée InputStreamReader avec le constructeur suivantInputStreamReader(InputStream is)
Une classe dérivée FileReader avec trois constructeursFileReader (File )FileReader (FileDescriptor fd)FileReader (String nom)
Une classe dérivée BufferedReader avec le constructeur suivantBufferedReader(Reader)
Avec une méthode pour la lecture d’une ligne de texteString readLine();
Une classe dérivée LineNumberReader avec le constructeur suivantLineNumberReader(Reader)
Voisin-Polian : Introduction à Java 32
Exemple de lecture d’un fichier « texte »
public static void main (String[] args) { BufferedReader ficLect; String ch; try { ficLect = new BufferedReader( new InputStreamReader(
new FileInputStream(args[0]))); while (ficLect.ready()) { ch = ficLect.readLine(); System.out.println(ch); } ficLect.close(); } catch (java.io.FileNotFoundException ex) { System.out.println("Fichier inexistant : " + ex); } catch (IOException ex) { System.out.println("erreur d'entree-sortie : " + ex ); }}
Voisin-Polian : Introduction à Java 33
Ecriture dans un fichier texte
public class PrintW {
public static void main(String[] args) throws IOException {
// avec PrintWriter bufferisé et vidage de buffer :
PrintWriter pt = new PrintWriter(
new BufferedWriter(
new FileWriter("toto.txt")), true);
pt.println("j'ecris dans toto.txt le " + 12 + " septembre");
// avec PrintStream bufferisé PrintStream pt2 = new PrintStream (
new BufferedOutputStream (
new FileOutputStream("tata.txt")));
pt2.println("j'ecris dans tata.txt le "+ 12 + " septembre");
pt2.flush(); // necessaire ou pt2.close ( ) }
}
Voisin-Polian : Introduction à Java 34
Exemple de lecture au clavier
public static void main( String[] args) { BufferedReader clavier; double dbl; int ent; String ch; try { clavier = new BufferedReader( new InputStreamReader(System.in));
ch = clavier.readLine(); dbl = Double.parseDouble(ch); ch = clavier.readLine(); ent = Integer.parseInt(ch);
clavier.close(); System.out.println("double lu : " + dbl); System.out.println("entier lu : " + ent); } catch (java.io.FileNotFoundException ex) { System.out.println("Fichier inexistant : " + ex); } catch (IOException ex) { System.out.println("erreur d'entree-sortie : " + ex ); }}
Voisin-Polian : Introduction à Java 35
La sérialisation
La sérialisation permet d’écrire ou de lire des objets dans un flot binaire (en tant qu’objets, sans avoir à les ramener à des éléments de types simples)
La sérialisation sert à : archiver des objets dans un fichier transmettre des objets sur un réseau faire communiquer des application par des appels à des méthodes distantes
(RMI)
La classe de l’objet doit implémenter l’interface java.io.Serializable
Cette interface ne contient aucune méthode, elle autorise simplement les objets de la classe à être sérialisé
Voisin-Polian : Introduction à Java 36
La sérialisation (suite)
La classe ObjectOutputStream permet d’écrire des objets sérialisables dans un flot binaire avec la méthode writeObject
La classe ObjectInputStream permet de lire des objets sérialisables dans un flot binaire avec la méthode readObject
Les objets composés de types primitifs ou d’objets sérialisables sont sérialisables. La sérialisation de l’instance de départ va entraîner la sérialisation des objets qui sont accessibles à partir d lui (graphe d’objets)
les « partages » (co-références) sont conservées dans un même flot binaire
la lecture demande des mécanismes internes particuliers (création d’instances sans appel aux constructeurs)
Voisin-Polian : Introduction à Java 37
La sérialisation (exemple)
class EssaiSerial implements Serializable { String chaine = "coucou"; double val = 3.14 ;}
public class Test { public static void main(String[] args) throws IOException, ClassNotFoundException { ObjectOutputStream s = new ObjectOutputStream( new FileOutputStream("toto.txt")); // ------> ecriture d’un objet dans le fichier toto .txt s.writeObject(new EssaiSerial()); s.close(); // ------> lecture d’un objet dans le fichier toto.txt ObjectInputStream e = new ObjectInputStream( new FileInputStream("toto.txt")); EssaiSerial es = (EssaiSerial) e.readObject(); e.close(); System.out.println(es.chaine + es.val); }
}