Les fichiers en Java

Les fichiers en java
Brigitte Groléas
Les fichiers en Java
1. L’écriture en mode texte brut
 les informations sont écrites en claires,
 séparées par un séparateur quelconque défini par l’utilisateur
 utilisable par n’importe quelle application
 nécessite un parsing à l'arrivée pour analyser les données
4 classes "mères", abstraites, pour traiter les flots de données héritant directement
d'Object :
 pour traiter de flots d'octets
o la classe InputStream
o la classe OutputStream
 pour traiter de flots de caractères
o la classe Reader
o la classe Writer
La classe FileReader permet de lire des caractères dans un fichier.
La classe FileWriter permet d'écrire des caractères dans un fichier.
Problématique : comment sauvegarder (ou transporter) un objet sachant qu’il est
composé d’instance d’autres objets, c’est à dire, que tout un graphe d’instances lui
est associé.
2. La sérialisation
 Compresse les informations de l’objet pour qu’il soit ‘transportable’
 Les données dans le fichier ne peuvent pas être lues comme du texte par
une autre application
 L’objet, lorsqu’il est lu, est décompressé, et retrouve son existence dans un
tas (ie une vm)
 permet d'échanger des données entre applications distribuées,
 permet la persistance des objets : un objet est persistant si sa durée de
vie est supérieure au programme qui l'a créé. Une des façons d'obtenir de
le persistance est la sérialisation dans des fichiers.
la sérialisation, c'est lire/écrire un objet dans un flot (flux)

Les fichiers en java
Brigitte Groléas
La sérialisation
Lecture et écriture d’objets dans un fichier, sur un flux, sur un stream en général
Un objet serialisable est transformable en une suite séquentiel d'octets.
o en Java, au niveau de l'objet, il suffit d'implémenter l'interface
Serializable (qui n'a pas de méthode)
o de tels flots en Java sont :
 ObjectInputSteam en lecture, instancié à partir d'un
InputStream,
sa méthode readObject() peut lever une exception
ClassNotFoundException.
 readObject() renvoie un Object donc il faut faire un cast
pour récupérer le bon type
 ObjectOutputSteam en écriture, instancié à partir d'un
OutputStream
sa méthode writeObject()
 les classes FileInputStream et FileOutputStream :
o sont des sous-classes de respectivement InputStream et OutputStream
o sont des flots (flux) pour la lecture/écriture des octets
o permettent d'accéder à des fichiers sur disque
o instancie un flot à partir d'un objet File

Les fichiers en java
Brigitte Groléas
Lire et écrire un texte dans le fichier
FileWriter fw;
fw = new FileWriter( "c:/titio.txt",true);
// true pour ouvrir en ajout
fw.write( "velo\n");
fw.close();
///////////////////
System.out.println("lecture car par car");
FileReader reader = new FileReader("c:/titio.txt");
int lu;
char c;
do {
lu = reader.read();
if (lu != -1) {
c = (char) lu;
System.out.print( c);
}
} while (lu != -1); // tant que l'on est pas à la fin du fichier
reader.close();
}catch (Exception e) { }
//////////////////
System.out.println("lecture ligne à ligne");
FileReader fr = new FileReader( "c:/titio.txt");
BufferedReader br = new BufferedReader(fr); // pour ligne ligne à ligne
String s = br.readLine() ;
System.out.println(s);
fr.close();
Lire et écrire un token dans le fichier
Lire des entiers dans un fichier ne contenant que des entiers.
int somme = 0;
FileReader f = new FileReader("c:/titi.txt");
// Le fichier titi.txt contient 12 13 22 44 33 22
StreamTokenizer truc = new StreamTokenizer(f); // découpe le fichier en truc
while(truc.nextToken() == StreamTokenizer.TT_NUMBER) {
// S'arrete au premier non chiffre rencontré
somme += (int)truc.nval;
}
f.close();
System.out.println(somme);

Les fichiers en java
Brigitte Groléas
La classe File
////////////////////
System.out.println("tester l'existence d'un fichier");
File f = new File("c:/titio.txt");
if (f.exists()) System.out.println("existe");
else System.out.println("existe pas");
////////////////////
System.out.println("recuperer le nom sans le chemin");
File file = new File("c:/titio.txt");
System.out.println(file.getName());//affiche titio.txt
////////////////////
System.out.println(" renommer un fichier");
File nouveauNom=new File("c:/suiv.txt");
file.renameTo(nouveauNom);
// le fichier doit être fermé pour que ca fonctionne
//////////////////////
System.out.println("Lister les fichiers d'un répertoire");
File repertoire = new File("c:/");
String[] listeFichiers;
listeFichiers=repertoire.list();
for (int i=0;i < listeFichiers.length;i++)
System.out.println(listeFichiers[i]);
/////////////
Fenêtre de choix
JFileChooser dialogue = new JFileChooser();
if (dialogue.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
// dialogue.showOpenDialog(null) fenetre modale de saisie
// peut retourner APPROVE_OPTION ou CANCEL_OPTION
File fichier = dialogue.getSelectedFile();
// FileWriter ecrire = new FileWriter(fichier.getPath(), true);
FileWriter ecrire = new FileWriter(fichier);
ecrire.write("cerise");
ecrire.close();
}
System.exit(0);

Les fichiers en java
Brigitte Groléas
Lire les 20 premiers octets du fichier titi et les afficher à l’écran
package fichier;
import java.io.*;
public class Fic {
public static void main (String [ ] args) {
try {
// Ouverture du fichier titi
InputStream fluxFichier = new FileInputStream ("c:/titi.txt");
byte contenuFichier [ ] = new byte [20]; // Lecture des 20 premiers octets
fluxFichier.read (contenuFichier);
System.out.println (new String (contenuFichier));
fluxFichier.close (); // Fermeture du fichier
}
catch (IOException e) {
System.out.println (e);
}
}
}
RandomAccessFile
Fichier à accès aléatoire
Vous devez connaître la taille et la position de l’enregistrement. Mais cette taille
n’est pas nécessairement identique pour tous les enregistrements.
Constructeurs :
RandomAccessFile(File f, String mode)
RandomAccessFile(String n, String mode)
Mode =
 "r" Ouverture en lecture seule
 "rw" Ouverture en lecture/écriture. Si le fichier n'existe pas, on essaie de le
créer.
 "rws" Ouverture en lecture/écriture. La mise à jour du contenu du fichier et
de ses méta données est faite de façon synchrone.
 "rwd" Ouverture en lecture/écriture. La mise à jour du contenu du
fichier est faite de façon synchrone.
long getFilePointer()
pour trouver où on se trouve dans le fichier
void seek(long pos)
pour se déplacer vers un nouvel emplacement dans le fichier