1. 07/2008

2.  Entrées/Sorties : Communication entre les
programmes et le monde extérieur.
 Les entrées : données fournis à un programme à
travers un périphérique d’entrée
( Ex: clavier, fichier, réseau, …)
 Les Sorties : résultats fournis par un programme
à travers un périphérique de sortie
( Ex: écran, fichier, réseau, …)

3.  Dans l’API de java, il existe des classes du package java.io
qui permettent de réaliser les E/S dans toute source ou
destination de données.
 Il y a deux groupes de classes :
 Classes pour les E/S par octets (flux d’octets) ayant pour
super-classes :
InputStream : lecture par octets
OutputStream : écriture par octet
 Classes pour les E/S par caractères (flux de caractères)
ayant pour super-classes :
Reader : lecture par caractère
Write : écriture par caractère

4.  System.in : flot d’entrée standard (clavier), instance de la classe
InputStream.
 On va utiliser 2 classes InputStreamReader et BufferedReader :
 BufferedReader : classe pour la lecture des caractères
Constructeur : BufferedReader (Reader in);
Quelques méthodes :
String readLine( ) throws IOException : lecture d’une ligne
texte et retourne null si fin de flux
void close( ) : fermeture du fichier
 InputStreamReader : classe pour le transfert des octets en
caractères
Constructeur : InputStreamReader ( InputStream in ) ;

5.  Exemple 1 :
import java.io.*;
classe Saisie {
public static void main ( String args[ ] ) throws IOException {
String s;
int n;
float r;
BufferedReader clavier = new BufferedReader(new InputStreamReader(System.in));
// lesctrure d’une chaîne de caratères
System.out.println( " Entrer une chaîne " );
s = clavier.readLine( );
// Lecture d’un entier
System.out.println( " Entrer une chaîne " );
s = clavier.readLine( );
n = Integer.parseInt( s );
// Lecture d’un réel
System.out.println( " Entrer une chaîne " );
s = clavier.readLine( );
r = new Float(s).floatValue( );
}
}

6. On va utiliser 2 classes PrintWriter et FileWriter :
 FileWriter : permet d’écrire des caractères dans un fichier
Constructeur : FileWriter (String nom) throws IOException ;
PrintWriter : permet d’écrire des objets dans un fichier
Constructeur : PrintWriter ( Writer out );
Quelques méthodes :
print et println : de la même façon qu’avec System.out
void close( ) : fermeture du fichier

7.  Exemple 2 :
import java.io.*;
classe EcrireFichText {
public static void main ( String args[ ] ) throws IOException {
int n = 2;
float r = 2.5;
PrintWriter fs = new PrintWriter (new FileWriter ( " toto.txt " ));
fs.println ( " Bonjour, comment ça va ? " );
fs.println ( " Un peu difficile ? " );
fs.println ( " Mais non, mais non " );
fs.println ( " Je peux écrire même un entier " +n );
fs.println ( " ou un réel " +r );
fs.println ( " Tout ce que je veux, bref ! " );
fs.println ( " Au revoir " );
fs.close( ) ;
}
}

8. On va utiliser les 2 classes BufferedReader et FileReader
du package java.io
 FileReader : permet de lire des caractères dans un fichier
Constructeur :
FileReader ( String nom ) throws FileNotFoundException;
Exemple 3 :
import java.io.*;
class LireFichText {
public static void main ( String args[ ] ) throws IOException {
String ligne;
BufferedReader fe = new BufferedReader ( new FileReader ( "toto.txt") );
while ( (ligne = fe.readLine( ) ) != null )
System.out.println ( ligne );
fe.close( ) ;
}
}

9. On va utiliser 2 classes DataOutputStream et FileOutputStream :
 DataOutputStream : permet l’écriture d’octets en tenant
compte des types simples de java.
Constructeur : DataOutputStream (InputStream in) ;
Quelques méthodes :
void writeUTF (String s) thrpws IOException : écrit un String
void writeInt (int i) throws IOException : écrit un entier
void writeFloat throws IOException : écrit un réel
 FileOutputStream : permet d’écrire des octets dans un fichier
Constructeur : FileOutputStream( String nom ) throws IOExecption;

10.  Exemple 4 :
import java.io.*;
classe EcrireFichBinaire {
public static void main ( String args[ ] ) throws IOException {
int n = 2;
float r = 2.5;
DataOutputStream fs = new DataOutputStream ( new FileOutputStream ( "toto.bin" ) );
fs.writeUTF ( " Bonjour " );
fs.writeInt ( n );
fs.writeFloat ( r );
fs.writeChars ( "a" );
fs.close( ) ;
}
}

11. On va utiliser 2 classes DataInputStream et FileIntputStream :
 DataInputStream : permet la lecture d’octets en tenant
compte des types simples de java.
Constructeur : DataInputStream (InputStream in) ;
Quelques méthodes :
void readUTF (String s) thrpws IOException : lit un String
void readInt (int i) throws IOException : lit un entier
void readFloat throws IOException : lit un réel
 FileInputStream : permet de lire des octets dans un fichier
Constructeur : FileInputStream( String nom ) throws FileNotFoundException;

12.  Exemple 5 :
import java.io.*;
classe LireFichBinaire {
public static void main ( String args[ ] ) throws IOException {
DataInputStream fs = new DataInputStream ( new FileInputStream ( "toto.bin" ) );
System.out.println ( fs.readUTF ( ) );
System.out.println (fs.readInt ( ) );
System.out.println (fs.readFloat ( ) );
System.out.println (fs.readChar ( ) );
fs.close( ) ;
}
}