Input/ouput dans des fichiers

Page 1
Lire et écrire dans un fichier texte
Lire et écrire dans des fichiers peut s’avérer complexe, car plusieurs objets doivent être
utilisés pour parcourir correctement les fichiers. En Java, les streams sont bien sûr
représentés par des classes définies dans le package java.io :
 FileInputStream. input stream pour les accès fichiers en entrée.
 FileOutputStream. output stream pour les accès fichiers en sortie.
 InputStreamReader. Effectue la conversion octet/caractère pour les fichiers textes
 OutputStreamReader.
 BufferedReader. stream bufférisé (utiliser un tampon pour lire des lignes entières)
 File. une classe encapsulant les fichiers disque.
Il y a deux types de fichiers que l’ont peut manipuler:
 Format binaire
 Format texte
Format binaire
 Les éléments sont représentés par une séquence d’octets (bytes)
 L’entier 12,345 sera stocké comme la séquence d’octets : 00 00 30 39
 Utilise des objets de la classe InputStream et OutputStream
 Plus compact et plus efficient
 Pour lire: FileInputStream inputStream = new FileInputStream ("input.bin");
 Pour écrire: FileOutputStream outputStream = new FileOutputStream("output.bin");
File file = new File ("Fichier.bmp");
try{
FileInputStream in = new FileInputStream (file);
try{
int next = in.read();
while (next != -1){
System.out.print(next + " ");
next = in.read();
}
in.close();
}catch (IOException exception){
System.out.println ("Erreur de lecture " + exception.getMessage());
}
}catch (FileNotFoundException exception){
System.out.println (exception.getMessage());
}
read retournera le prochain
octet comme un int ou -1 si
la fin du fichier est atteint
getMessage affiche
Fichiers.doc (Le fichier
spécifié est introuvable)

Page 2
Format texte
 Lisible par les humains
 C’est une séquence de caractères
 La valeur 12345 sera stocké comme la séquence de caractères: ‘1’ ‘2’ ‘3’ ‘4’ ‘5’
 Pour lire: FileReader reader = new FileReader ("input.txt");
 Pour écrire: FileWriter writer = new FileWriter("output.txt");
 Si le texte est formaté et que la lecture doit être manipulée plus spécifiquement,
on utilise les objets FileInputStream, InputStreamReader et BufferedReader
Exemple de lecture dans un fichier texte.
FileReader fr = new FileReader("texte.txt");
while( i != -1 ){
i=fr.read(); // on lit le caractère et on note son code dans i
c=(char) i;
System.out.print(c);
}
Exemple de lecture dans un fichier texte.
try{
String fichier = "fichier.txt";
BufferedReader f= new BufferedReader(new InputStreamReader(
new FileInputStream(fichier)));
String ligne;
while ((ligne = f.readLine()) != null)
System.out.println(ligne);
f.close();
}catch (FileNotFoundException e){
System.out.println(e.toString());
}catch (Exception e) {
System.out.println(e.toString());
}
Exemple d’écriture dans un fichier texte.
FileWriter f;
try{
f = new FileWriter("nombre.txt");
PrintWriter sortie = new PrintWriter(f);
for(int i=0;i<10;i++)
sortie.println(i + " " + i*i);
sortie.close();
}catch (IOException e){
e.printStackTrace();
}
printStackTrace affiche le type d’exception, le message et la propagation
d'une exception de méthodes en méthodes
java.io.FileNotFoundException: Fichiers.doc (Le fichier spécifié est introuvable)
at java.io.FileInputStream.open(Native Method)
at java.io.FileInputStream.<init>(FileInputStream.java:138)
at exercice1.FichierBinaire.main(FichierBinaire.java:17)
toString affiche le type d’exception et le message
java.io.FileNotFoundException: Fichiers.doc
(Le fichier spécifié est introuvable)

Page 3
Lire un fichier avec Scanner
Rien de plus simple que de lire un fichier avec la classe Scanner, cette classe propose toute une
série de constructeurs pour construire un objet Scanner à partir d'un objet File, d'un objet
InputStream, ...
Une fois l'objet Scanner construit, on peut utiliser toutes les méthodes de cette classe qui sont
extrêmement riches, rappelez-vous. Imaginons par exemple que l'on aie un fichier qui contienne
des noms de personnes avec leur année de naissance comme ceci :
Sébastien 1984
Cédric 1985
John 1976
Avec l'objet Scanner, on va pouvoir lire le fichier de manière très précise et par exemple afficher
l'âge de chacune des personnes présente dans le fichier.
Exemple d’écriture dans un fichier texte.
try{
File f = new File("annuaire.txt");
Scanner scanner = new Scanner(f);
String nom;
int anneeActuel = 2014;
int anneeNaiss;
try{
while(true){
nom = scanner.next();
anneeNaiss = scanner.nextInt();
System.out.println(nom + " (" +
(anneeActuel - anneeActuel) + " ans)");
}
}catch (NoSuchElementException exception){
break; //fin de fichier atteinte
}
scanner.close();
}catch (FileNotFoundException exception){
System.out.println ("Le fichier n'a pas été trouvé");
}
Dans tous les exemples présentés, on créait à chaque fois une variable pour chaque objet créé,
variable que l'on passait ensuite comme paramètre au constructeur suivant, c'était leur seul rôle
mis à part l'appel à la méthode close qui n'est en fait pas nécessaire, en effet, fermer l'objet de
haut niveau va fermer ceux de bas niveau également. On peut éviter de déclarer plein de
variables supplémentaires si on le souhaite comme le montre l'exemple suivant.
// Version développée
File f = new File ("annuaire");
FileReader fr = new FileReader (f);
BufferedReader br = new BufferedReader (fr);
Scanner scanner = new Scanner (br);
// Version compacte
Scanner scanner = new Scanner (new BufferedReader (new FileReader
(new File ("annuaire"))));