Choix de streams

Version imprimable

Choix de streams

Bonjour,
Je dois préparer un petit document sur la manipulation de fichiers en Java. Le package IO est très riche et il m'est difficile de choisir un jeu réduit de classes permettant de simplifier le travail du développeur.
Ce document est destiné à des débutants.
J'ai retenu un certain nombre de méthode de travail qui me semblent très générales. Pouvez-vous me dire ce que vous pensez de mes choix ?
je vous remercie d'avance pour vos remarques et suggestion.

Pour les fichier texte:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
    public void writeText()throws IOException{
        // Ecriture d'un fichier texte
        PrintWriter f1=new PrintWriter(new FileWriter("c:/test.txt"));
        f1.println("1 Albert");
        f1.println("2 Bernard");
        f1.close();
    }
 
    public void addText()throws IOException{
        // Ecriture d'un fichier texte
        PrintWriter f=new PrintWriter(new FileWriter("c:/test.txt",true));
        f1.println("3 Claude");
        f1.println("4 Daniel");
        f.close();
    }
 
    public void readText()throws IOException{
         // Lecture d'un fichier texte
        BufferedReader f=new BufferedReader(new FileReader("c:/test.txt"));
        String s;
        s = f.readLine();
        while( s != null){
            System.out.println(s);
            s = f.readLine();
        }
        f.close();
    }
 
    public void readFormattedText()throws IOException{
         // Lecture d'un fichier texte
        Scanner f=new Scanner(new FileReader("c:/test.txt"));
        String s;
        int n;
        while( f.hasNext() ){
            n = f.nextInt();
            s = f.nextLine();
            System.out.printf("<%d> <%s>\n",n,s);
        }
        f.close();
    }

Pour les fichiers binaires:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
    public void save( DataOutputStream f, Personne p )throws IOException{
        f.writeLong( p.getMatricule() ) ;
        f.writeUTF( p.getNom() ) ;
        f.writeBoolean( p.getMarie() ) ;
        f.writeDouble( p.getTaille() ) ;
    }
 
    // Lit une Pers. Retourne null si EOF
    public Personne load( DataInputStream f ){
        Personne p = null ;
        try{
            long matricule = f.readLong() ;
            String nom     = f.readUTF();
            boolean marie  = f.readBoolean();
            Double taille  = f.readDouble();
            p = new Personne(matricule,nom,marie,taille) ;
        } catch( IOException e ){
        }
        return p ;
    }
 
    public void writeBinary()throws IOException{
        // Ecriture du fichier
        DataOutputStream f = new DataOutputStream( new FileOutputStream("c:/test.dat") );
        save( f, new Personne(11,"Albert",true,1.23) ) ;
        save( f, new Personne(22,"Bernard",false,1.8) ) ;
        f.close() ;
    }
 
    public void readBinary()throws IOException{
        DataInputStream f = new DataInputStream( new FileInputStream("c:/test.dat") );
        Personne p ;
 
        p = load(f) ;
        while( p!=null ){
            System.out.println( p ) ;
            p = load(f) ;
        }
        f.close() ;
    }
 
    public void addBinary()throws IOException{
        // Ecriture du fichier
        DataOutputStream f = new DataOutputStream( new FileOutputStream("c:/test.dat",true));
        save( f, new Personne(33,"Claude",true,1.23) ) ;
        save( f, new Personne(44,"Daniel",false,1.8) ) ;
        f.close() ;
    }

Pour les fichiers d'objets:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
    // La classe Peronne implémente Serializable
    public void writeObject()throws IOException{
        // Ecriture du fichier
        ObjectOutputStream f = new ObjectOutputStream( new FileOutputStream("c:/test.dat") );
        f.writeObject(new Personne(11,"Albert",true,1.23));
        f.writeObject(new Personne(22,"Bernard",false,1.8));
        f.close() ;
    }
 
    public void readObject()throws Exception{
        ObjectInputStream f = new ObjectInputStream( new FileInputStream("c:/test.dat") );
        Personne p ;
        boolean eof = false;
 
        while( !eof ) {
            try {
                p = (Personne)f.readObject();
                System.out.println( p ) ;
            } catch(EOFException e) {
                eof = true;
            }
        }
        f.close() ;
    }
 
    public void addObject()throws Exception{
       // Le mode append ne fonctionne pas à cause de l'en-tête posé au début de l'écriture.
       // Il faut donc effectuer un mutation par copie dans un fichier temporaire 
        ObjectInputStream fLu = new ObjectInputStream( new FileInputStream("c:/test.dat") );
        ObjectOutputStream fTmp = new ObjectOutputStream( new FileOutputStream("c:/test.tmp") );
        Personne p ;
        boolean eof = false;
 
        while( !eof ) {
            try {
                p = (Personne)fLu.readObject();
                fTmp.writeObject(p);
            } catch(EOFException e) {
                eof = true;
            }
        }
        fLu.close() ;
        fTmp.writeObject(new Personne(33,"Claude",true,1.23));
        fTmp.writeObject(new Personne(44,"Daniel",false,1.8));
        fTmp.close() ;
 
        File file;
        file=new File("c:/test.dat");
        file.delete();
        file=new File("c:/test.tmp");
        file.renameTo(new File("c:/test.dat"));
    }

19/06/2007, 09h58
afrikha

Salut,

As-tu jeté un coup d'oeil à cet article , je l'ai écrit justement pour que le lecteur y voit plus clair concernant java.io .

J'espère qu'il t'aidera ;)

@+
20/06/2007, 09h50
gelam

Merci pour ce document. Il me sera très utile pour ma préparation.
Pour mes étudiants je voulais pouvoir dans un premier temps leur offrir un certain nombre de recettes "qui généralement marchent" quitte à revenir plus tard en détail sur le package IO et le concept de décorateur.
A bientôt
20/06/2007, 10h10
afrikha
Citation:

Envoyé par gelam

Pour mes étudiants je voulais pouvoir dans un premier temps leur offrir un certain nombre de recettes "qui généralement marchent"

Les combinaisons les plus utilisés sont :
- new BufferedReader(new FileReader("entree.txt")) pour lire un fichier texte.
- new BufferedWriter(new FileWriter("sortie.txt")) pour écrire dans un fichier texte.
- new BufferedInputStream(new FileInputStream("fichierBinaire1")) pour lire un fichier binaire.
- new BufferedOutputStream(new FileOutputStream("fichierBinaire2")) pour écrire dans un fichier binaire.
Voilà, j'espère que c'est clair. Si ce n'est pas le cas n'hésite pas à poser des questions ;)

@+
20/06/2007, 10h22
nicØB

Bonjour,

Ca pourrait être intéressant d'évoqué le Scanner pour lire un fichier par exemple.

Salut,

Citation:

Envoyé par gelam

Pour mes étudiants je voulais pouvoir dans un premier temps leur offrir un certain nombre de recettes "qui généralement marchent"

Puisque c'est pour des étudiants, autant leurs donner de bonnes habitudes dès le début en utilisant des try/finally pour fermer les flux correctement dans tous les cas, par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 public void addText()throws IOException{ // Ecriture d'un fichier texte PrintWriter f=new PrintWriter(new FileWriter("c:/test.txt",true)); try { f1.println("3 Claude"); f1.println("4 Daniel"); } finally { f.close(); } }
Plus d'info : Comment libérer proprement les ressources (ou comment utiliser proprement les bloc try/finally) ?

a++

20/06/2007, 11h38
gelam

Merci pour ces premières remarque.
Pour le Scanner j'en parle avec les fichiers textes...
Je pensais utiliser le PrintWriter pour les méthodes print(), println() et printf().
Je pensais utiliser les DataInputStream et DataOutputStream pour les méthodes readxxx() et writexxx() où xxx sont des types de base ce qui éviterait les conversions vers ou depuis des tableaux de bytes.
Je tiendrai compte de la remarque sur le bloc try-finally pour la fermeture du flot.