Gestion des entrée/sorties (Flux) · Memoire Centrale Memoire Secondaire Fic. Physique Flux Fic. Logique . Licence (DMI/FST Limoges)(TOB) 3 0. Associations entre flux Flux FileInputStream,

Licence (DMI/FST Limoges)(TOB) 1

Gestion des entrée/sorties (Flux) 0. Associations entre flux 1. Clavier/Ecran 2. Variables d'environnement 3. Copie par bloc d'un fichier 4. Utilisation du type texte pour l'entrée standard 5. Fichier à accès direct 6. Utilisation d'un fichier de type données 7. Utilisation d'un fichier de type texte 8. Ecriture et lecture d'objets


0. Associations entre flux Schéma représentant l'échange entre la mémoire centrale

et la mémoire secondaire (Le fichier logique est le premier flux).

Memoire Centrale

Memoire Secondaire

Fic. Physique

Fic. LogiqueFlux


0. Associations entre flux FluxFileInputStream,

InputStreamFileOutputStream,

OutputStreamInputStream[Reader]PrintStreamBufferedReaderBufferedWriter

Fichier logiqueFile

File

System.inSystem.outFileReader, ReaderFileWriter, Writer RandomAccessFile


0. Associations entre flux FluxDataInputStreamDataOutputStreamStreamTokenizerObjectInputStreamObjectOutputStream

Flux FileInputStreamFileOutputStreamFileInputStreamFileInputStreamFileOutputStream


0. Associations entre flux Rem1: Les constructeurs permettant

l'instanciation de ces différents flux ainsi que les méthodes permettant de les utiliser sont à consulter sur le site sun de la documentation java qui décrit les classes correspondantes et les méthodes associées.

Rem2: Les classes abstraites InputStream et OutputStream correspondent aux flux de type données et les classes abstraites Reader et Writer correspondent aux flux de type texte.


1. Clavier/Ecran Application: Programme qui lit une suite de

caractères sur le canal in (InputStream) et les affiche en majuscule sur le canal out (PrintStream). in et out sont des variables de la classe System.

Note: Les opérations d'E/S doivent être mises dans un try{}+catch{} ou dans une méthode avec throws IOException. Tout ce qui est dans try{} est contrôlé et traité par ce qui est dans catch{}.


1. Clavier/Ecranimport java.io.*;public class Majuscule{ public static void main(String args[]) { int x=0; System.out.println("Entrer une chaine : "); try { do { x=System.in.read(); //lect.car (code ascii) depuis in (InputStream) System.out.println(Character.toUpperCase((char)x)); } while (System.in.available()>0); // nb cars ds le buffer d'entree in System.out.println(System.in.available()+" cars sont en attente "); } catch(IOException e) {System.out.println(e.getMessage());} }}


2. Variables d'environnement Application: Programme permettant d'afficher les variables

d'environnement de la session courante.

import java.io.*;import java.util.Properties;public class Environ{ public static void main(String args[]) { Properties p= System.getProperties(); p.list(System.out); // affichage sur le out (PrintStream) }}


2. Variables d'environnement Application: affichage du répertoire courant ( « user.dir »)

et de la version java (« java.version »).// utiliser ce programme pour afficher une variable environnementpublic class Environ1{ public static void main(String args[]) { System.out.println(" user.dir :"+ System.getProperty

("user.dir")); System.out.println(" java. version :"+ System.getProperty

("java.version")); }}


3. Copie par bloc d'un fichier (classes File, FileInputStream et FileOutputStream) Application: Copie par bloc d'un fichier source dans un fichier

destination.import java.io.*;public class CopieFic{ public static void copie(String src, String dest) // méthode de classe { FileInputStream s=null; FileOutputStream d=null; try { File source = new File(src); // instanciation fichier logique File destination = new File(dest); s= new FileInputStream(source); // instanciation de flux d= new FileOutputStream(destination); byte tampon[]=new byte[1024]; int lu=0; do { lu= s.read(tampon); // lecture if (lu>0) d.write(tampon,0,lu); // écriture } while (lu>0); }


3. Copie par bloc d'un fichier (classes File, FileInputStream et FileOutputStream) catch (IOException e) {System.out.println(e.getMessage()); } finally // exécutée en fin ou après exception si pb { if (s!=null) {try {s.close(); } catch (IOException e){ }} // fermer le flux if (d!=null) {try {d.close(); } catch (IOException e){ }} } } public static void main(String args[]) { if (args.length !=2) System.out.println(" usage : java CopieFic <src> <dest>" ); else copie(args[0], args[1]); // méthode de classe }}


3. Copie par bloc d'un fichier (classes File, FileInputStream et FileOutputStream) Rem: args[0] du main() correspond au premier argument

mais non au programme exécutable comme c'est le cas en C. et args.length est équivalent à argc (nombre d'arguments


4. Utilisation du type texte pour l'entrée standard (classes BufferedReader et InputStreamReader) Application: Programme permettant de lire depuis le clavier

(System.in) une chaine, un entier et un réel en tant que chaine de caractères.

import java.io.*;public class Lecteur{ static BufferedReader fe= new BufferedReader( new

InputStreamReader (System.in)); // Lire une chaine au clavier public String lireChaine() { String rep=""; // initialisation try { rep=fe.readLine(); } catch (IOException e) { System.out.println (e.getMessage());} return(rep); }


4. Utilisation du type texte pour l'entrée standard (classes BufferedReader et InputStreamReader) // Lecture d'un entier public int lireEntier() { int n=0; String rep=""; try { rep=fe.readLine(); n=Integer.parseInt(rep); // conversion chaine>entier } catch (IOException e) { System.out.println("\n Retapez un entier ");} return(n); }


4. Utilisation du type texte pour l'entrée standard (classes BufferedReader et InputStreamReader) // lecture d'un reel public float lireReel() { float n=0; String rep=""; try { rep=fe.readLine(); n=Float.valueOf(rep).floatValue(); // conversion chaine>réel // n=Float.parseFloat(rep); } catch (IOException e) { System.out.println("\n Retapez un reel ");} return(n); }}Rem: On aurait pu écrire de la même manière une méthode pour la

lecture d'un double ou d'un caractère.


4. Utilisation du type texte pour l'entrée standard (classes BufferedReader et InputStreamReader)// Test Lecteurclass TestLecteur{ public static void main(String args[]) { String ch; int ent; float reel; Lecteur lec=new Lecteur(); // instanciation d'un Lecteur System.out.println( "Entrer une chaine "); ch=lec.lireChaine(); System.out.println( "valeur de la chaine : "+ch); System.out.println( "Entrer un entier "); ent=lec.lireEntier(); System.out.println( "valeur de l'entier : "+ent); System.out.println( "Entrer un reel "); reel=lec.lireReel(); System.out.println( "valeur du reel : "+reel); }}


5. Fichier à accès direct (classe RandomAccessFile) Application: Programme permettant de créer un fichier de

nombres entiers aléatoires de le fermer puis de l'ouvrir pour le lire en entier et en fin de se positionner sur le 5ème entier qu'on relit et qu'on affiche.

import java.io.*;import java.util.Random; // génération nbr aléatoirepublic class AccesDir{ static final int taille=4; // taille d'un entier public static void main(String args[]) { RandomAccessFile f; // flux d'accés direct Random v= new Random(); // Composant alea. int x;


5. Fichier à accès direct (classe RandomAccessFile)// creation d'un fichier à acces direct, de 10 entiers. try { f=new RandomAccessFile("FicDir","rw"); // Lecture-Ecriture for (int ind=0;ind<10;ind++) {x=v.nextInt()%100; // nbr entre 0 et 99 System.out.println(ind + ": "+x); // verif. f.writeInt(x); // ecriture ds le fichier } f.close(); } catch (IOException e) { System.exit(1);} // arret


5. Fichier à accès direct (classe RandomAccessFile)// Lecture du fichier à accés direct try { f=new RandomAccessFile("FicDir","r");// Lecture System.out.println(" Taille du fichier (Octets) : "+ f.length()); System.out.println(" contenu du fichier : "); long y; // position ds le fic. En octets for (int ind=0;ind<f.length()/taille;ind++) {y=f.getFilePointer(); //Pos. Curseur (0 au début) x=f.readInt(); // lect. entier, le curs. est déplacé de 4 Oc. System.out.println(y + ": "+x); }


5. Fichier à accès direct (classe RandomAccessFile)// positionnement sur le 5ème elet y=(5*taille); f.seek(y);// acces direct, curseur en 20 x=f.readInt(); System.out.println(" contenu du 5eme elet : "+x); f.close(); } catch (IOException e) { System.out.println("pb IO: "

+e.getMessage());} }}


6. Utilisation d'un fichier de type données (classes DataInputStream, DataOutputStream et RandomAccessFile) Application: Programme permettant d'écrire des notes d'étudiants

dans un fichier puis de les lire depuis ce fichier.

// Classe décrivant des étudiants et des opérations d'E/Simport java.io.*;public class Etudiant{ int num; String nom; float note; Etudiant (int num,String nom, float note) { this.num=num; this.nom=nom; this.note=note; } Etudiant() { this(0,"",0);}// constructeur pour initialisation // Contenu d'une instance sous forme de chaine public String chaine() { return(num+" "+nom+" "+note);}


6. Utilisation d'un fichier de type données (classes DataInputStream, DataOutputStream et RandomAccessFile)// Ecrire l'etudiant ds le fichier (DataOutputStream) void ecrireEtu( DataOutputStream fs) { try { fs.writeInt(num);fs.writeChars(nom);fs.writeFloat(note);} catch (IOException e) {System.out.println("ecrireEtu " +

e.getMessage());} }// Lire l'etudiant depuis le fichier (DataInputStream ) void lireEtu( DataInputStream fe) { try { num=fe.readInt(); for (int ind=0;ind<10;ind++) nom+=fe.readChar(); note=fe.readFloat(); } catch (IOException e) {System.out.println("lireEtu " +

e.getMessage());} }


6. Utilisation d'un fichier de type données (classes DataInputStream, DataOutputStream et RandomAccessFile)// Lire directe. l'etudiant depuis le fichier (RandomAccessFile) void lireEtuD( RandomAccessFile fe, int no) { try { fe.seek(no*(4+20+4)); // 1 unicode (1 car = 2 Octets) num=fe.readInt(); for (int ind=0;ind<10;ind++) nom+=fe.readChar(); note=fe.readFloat(); } catch (IOException e) {System.out.println("lireEtuD " +

e.getMessage());} }} // fin classe Etudiant


6. Utilisation d'un fichier de type données (classes DataInputStream, DataOutputStream et RandomAccessFile)//programme pour lire directement dans le fichier étudiantimport java.io.*;public class LectureDirecte { public static void main (String args[]) throws IOException { RandomAccessFile fr = new RandomAccessFile("Etudiant.dat","r"); Etudiant etu = new Etudiant(); // initialise etu. etu.lireEtuD(fr,2); // se positionne sur l'etudiant de rang 2 (3ème) System.out.println(etu.chaine()); }}

Rem: On suppose que le fichier Etudiant.dat a été créé préalablement


6. Utilisation d'un fichier de type données (classes DataInputStream, DataOutputStream et RandomAccessFile)//programme pour ecrire (créer) et lire un fichier d'étudiantsimport java.io.*;public class DataEtudiant { DataEtudiant( String titre) { System.out.println(titre + « \n »); }


6. Utilisation d'un fichier de type données (classes DataInputStream, DataOutputStream et RandomAccessFile)// Ecrire des donnees dans le fichier void ecritData() { String ch = new String (" Donnees a ecrire \n"); DataOutputStream fs=null; try { fs = new DataOutputStream ( new FileOutputStream ("Etudiant.dat") ); Etudiant e1= new Etudiant((int)1,"Dupont ",(float)15.5) ; e1.ecrireEtu(fs); Etudiant e2= new Etudiant((int)2,"Dubois ",(float)12.5) ; e2.ecrireEtu(fs); Etudiant e3= new Etudiant((int)3,"Dumont ",(float)17.5) ; e3.ecrireEtu(fs); ch= ch +e1.chaine()+ "\n"+e2.chaine()+ "\n"+e3.chaine()+ "\n"; fs.close(); } catch (IOException e) {System.out.println("ecritData " + e.getMessage());} System.out.println(ch); // verification affichage }


6. Utilisation d'un fichier de type données (classes DataInputStream, DataOutputStream et RandomAccessFile) // Lire des donnees depuis le fichier void litData() { String ch = new String (" Donnees Lues \n"); DataInputStream fe=null; try { fe = new DataInputStream ( new FileInputStream ("Etudiant.dat") ); Etudiant e1= new Etudiant(); e1.lireEtu(fe); Etudiant e2= new Etudiant(); e2.lireEtu(fe); Etudiant e3= new Etudiant(); e3.lireEtu(fe); ch= ch +e1.chaine()+ "\n"+e2.chaine()+ "\n"+e3.chaine()+ "\n"; fe.close(); } catch (IOException e) {System.out.println("litData " + e.getMessage());} System.out.println(ch); // affichage global }


6. Utilisation d'un fichier de type données (classes DataInputStream, DataOutputStream et RandomAccessFile) public static void main (String args[]) { // ecrire les donnees etudiants DataEtudiant de1=new DataEtudiant( " Appel Ecriture "); de1.ecritData(); // lire les donnees etudiants DataEtudiant de2=new DataEtudiant( "Appel Lecture "); de2.litData(); }}

Rem0: Les valeurs des champs, dans ecritData, auraient pu être saisiesRem1: Les fux DataInputStream et DataOutputStream sont plus élaborés

que FileInputStream et FileOutputStream, ils permettent des E/S plus fines.

Rem2: On aurait pu hériter d' un conteneur de type Frame (fenêtre) et ajouter un composant graphique TextArea (zone de texte) pour réaliser nos affichages (S.o.p)


7. Utilisation d'un fichier de type texte ( classes BufferedReader, FileReader et StringTokenizer ) Application: Programme qui permet de lire des informations

structurées depuis un fichier texte (créé par éditeur). Il y aura deux types de lecture du texte, une avec champs de longeur fixe l'autre avec séparateur.

// classe permettant de décrire la structure du Textepublic class Texte { String nom=""; String tel=""; int age=0; float fact=0; public String chaine() { return(nom+" "+tel+" "+age+" "+fact);}}


7. Utilisation d'un fichier de type texte ( classes BufferedReader, FileReader et StringTokenizer ) // programme pour lire un fichier texte créé par editeurimport java.io.*;import java.util.*; // pour StringTokenizer (separateur de texte)public class LireTexte { String chT=""; // pour affichage LireTexte( String titre) { System.out.println(titre + « \n »); }


7. Utilisation d'un fichier de type texte ( classes BufferedReader, FileReader et StringTokenizer ) // Lire depuis le fichier des champs de longueur fixe void litFix() { BufferedReader fe=null; try { fe = new BufferedReader( new FileReader("TexteF.dat"));// fic. créé par éditeur String ch=””; while ((ch=fe.readLine())!=null) //!=EOF { Texte t= new Texte(); t.nom=ch.substring(0,10); t.tel=ch.substring(10,20); String s=ch.substring(20,24).trim();// supr. Esp. age t.age= Integer.parseInt(s); t.fact=Float.valueOf(ch.substring(24,34)).floatValue(); // parseFloat System.out.println(t.chaine()); chT= chT +t.chaine()+ "\n"; } fe.close(); System.out.println(chT); } catch (IOException e) {System.out.println("litFix "+e.getMessage());} }


7. Utilisation d'un fichier de type texte (classes BufferedReader, FileReader et StringTokenizer ) // Lire depuis le fichier des donnees avec separateur void litSep() { BufferedReader fe=null; try { fe = new BufferedReader( new FileReader("TexteS.dat")); // créé par éditeur String ch=””; while ((ch=fe.readLine())!=null) //!=EOF { Texte t= new Texte(); StringTokenizer st= new StringTokenizer(ch,"/"); // séparateur '/ ' t.nom=st.nextToken(); t.tel=st.nextToken(); t.age= Integer.parseInt(st.nextToken()); t.fact=Float.valueOf(st.nextToken()).floatValue(); System.out.println(t.chaine()); chT= chT +t.chaine()+ "\n"; } fe.close(); System.out.println(chT); } catch (IOException e) {System.out.println("litSep " + e.getMessage());} }


7. Utilisation d'un fichier de type texte ( classes BufferedReader, FileReader et StringTokenizer ) public static void main (String args[]) { // Lire les donnees de fichier texte (champ fixe) LireTexte t1=new LireTexte( " Lecture champ fixe "); t1.litFix(); // Lire les donnees de fichier texte (avec séparateur) LireTexte t2=new LireTexte( " Lecture separateur "); t2.litSep(); }}

Rem1: Les fux BufferedReader et BufferedWriter sont plus élaborés que FileReader et FileWriter, ils permettent des E/S plus fines.

Rem2: On aurait pu hériter d' un conteneur de type Frame (fenêtre) et ajouter un composant graphique TextArea (zone de texte) pour réaliser nos affichages (S.o.p)


8. Ecriture et lecture d'objets (classes ObjectOutputStream et ObjectInputStream) Application: Programme permettant d'écrire trois étudiants en tant

qu'objets puis de les lire en tant qu'objets// classe décrivant un type d'objets Etudiant1import java.io.*; // necessaire pour l'interface Serializablepublic class Etudiant1 implements Serializable{ int num; String nom; float note; Etudiant1 (int num,String nom, float note) { this.num=num; this.nom=nom; this.note=note; } Etudiant1() { this(0,"",0);} public String chaine() { return(num+" "+nom+" "+note);}}


8. Ecriture et lecture d'objets (classes ObjectOutputStream et ObjectInputStream)

// programme pour ecrire et lire un fichier d'objets Etudiant1import java.io.*;public class DataEtudiant1 { public static void main (String args[]) throws ClassNotFoundException { // ecrire les donnees objets etudiants try { ObjectOutputStream fs=null; fs = new ObjectOutputStream ( new FileOutputStream ("Etudiant1.dat")); Etudiant1 e1= new Etudiant1((int)1,"Dupont",(float)15.5); fs.writeObject(e1); Etudiant1 e2= new Etudiant1((int)2,"Dubois",(float)12.5) ; fs.writeObject(e2); Etudiant1 e3= new Etudiant1((int)3,"Dumont",(float)17.5); fs.writeObject(e3);

fs.close(); } catch (IOException e) {System.out.println("ecrire Objet " + e.getMessage());}


8. Ecriture et lecture d'objets (classes ObjectOutputStream et ObjectInputStream)// Lire des donnees objets etudiants try { ObjectInputStream fe=null; fe = new ObjectInputStream ( new FileInputStream ("Etudiant1.dat") ); Etudiant1 e1= (Etudiant1)fe.readObject(); Etudiant1 e2= (Etudiant1)fe.readObject(); Etudiant1 e3= (Etudiant1)fe.readObject(); fe.close(); System.out.println(e1.chaine()); System.out.println(e2.chaine()); System.out.println(e3.chaine()); } catch (IOException e) {System.out.println("lire Object " + e.getMessage());} }}Rem0: Les valeurs des champs auraient pu être saisies dans le main, sans

compléter les chaines par des espaces.

Documents

Gestion des entrée/sorties (Flux) · Memoire Centrale Memoire Secondaire Fic. Physique Flux Fic. Logique . Licence (DMI/FST Limoges)(TOB) 3 0. Associations entre flux Flux FileInputStream,