opération sur un fichier

Version imprimable

Bonjour,
Je suis plus ou moins débutant en JAVA et j'aimerais avoir l'avis d'expert dans ce langage sur le bout de code suivant que j'ai réalisé (lecture, écriture, suppression de fichier).
Je pense qu'il y a bcp de chose à améliorer/optimiser

Merci !

CLASSE FICHIER :

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
54
55
56
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class Fichier {
	public void lire_Fichier (String p_fich) throws IOException {
		BufferedReader w_lecture = null; 
		String ligne; 
 
		try {
			w_lecture = new BufferedReader (new FileReader(p_fich));
		}
		catch (FileNotFoundException exc) {
 
			System.out.println("Fichier inexistant !!!");
		}
 
		while ((ligne = w_lecture.readLine()) != null)
			System.out.println(ligne);
 
		w_lecture.close();		
	}
 
	public void ecrire_Fichier (String p_fich, String p_commentaire, boolean ajout) throws IOException {
 
		try {
			FileReader w_r = new FileReader(p_fich); 
			FileWriter w_c = new FileWriter(p_fich, ajout);
			w_c.write(p_commentaire);
			w_c.flush();
			w_c.close();
		}
		catch (FileNotFoundException exc) {
			System.out.println("fichier inexistant !!!");
		}
	}
 
	public boolean supprimer_Fichier (String p_fich) throws IOException {
		boolean resultat = true;
 
		try {
			FileReader w_r = new FileReader(p_fich);
			resultat = true;
		}
		catch (FileNotFoundException exc) {
			System.out.println("fichier inexistant !!!");
			resultat = false;
		}
		finally {
			return resultat;
		}
	}

CLASSE PRINCIPALE :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
import java.io.IOException;
 
public class principale {
        public static void main(String[] args) throws IOException {		
	        Fichier p_fichier = new Fichier();
		String w_c = "Bonjour ! Ceci est un test d'ecriture dans un fichier\n";
		p_fichier.ecrire_Fichier("texte", w_c, true);
		p_fichier.lire_Fichier("texte");
		if (p_fichier.supprimer_Fichier("texte") == true) {
			System.out.println("Fichier supprimé !");
		}
		else {
			System.out.println("Impossible de supprimer le fichier !");
		}
	}
}

20/03/2008, 14h11
in
Juste une ou deux remarques pour ma part :
- Il faut que tu fermes tes flux (reader et writer) dans des blocs finally pour être bien sûr de les fermer
- quand tu attrapes une exception, affiche au moins le message (getMessage) et éventuellement (toujours si tu es en phase de dev) la trace de l'exception (printStackTrace)
- enfin par convention le nom des classes prend une majuscule
sinon fonctionnellement j'ai pas vraiment regardé ...

Salut,
Toujours utiliser un try/finally pour les fermetures de fichier (lire Comment libérer proprement les ressources ? :faq:).
Gérer les exceptions de manières plus globales, et bien arrêter tout le traitement en cours.
Dans ce code :
Code:

1 2 3 4 5 6 7 8 9 10 try { w_lecture = new BufferedReader (new FileReader(p_fich)); } catch (FileNotFoundException exc) { System.out.println("Fichier inexistant !!!"); } while ((ligne = w_lecture.readLine()) != null) System.out.println(ligne);
Il y a une erreur typique d'une mauvaise gestion des exceptions :
[indent]:arrow: Si le fichier n'existe pas, on affiche un message mais on continue quand même à essayer de le lire (ce qui produira un NullPointer :?)
Dans la méthode ecrire_Fichier() tu ouvres aussi le fichier en lecture :koi: et tu ne le fermes même pas (par contre tu fermes deux foix celui en écriture) :
Code:

1 2 3 4 5 FileReader w_r = new FileReader(p_fich); FileWriter w_c = new FileWriter(p_fich, ajout); w_c.write(p_commentaire); w_c.flush(); w_c.close();
:arrow: ceci devient :
Code:

1 2 3 4 5 6 FileWriter writer = new FileWriter(p_fich, ajout); try { writer.write(p_commentaire); } finally { writer.close(); }
Dans supprimer_Fichier() tu ouvres le fichier en lecture ! Je n'ai pas compris pourquoi :koi:
De plus tu ne supprimes rien re-:koi:
Moins grave (mais quand même) : tu ne respectes pas les conventions de nommages (plein de _ partout) et tu as des noms de variables "bizarres" (w_c représente parfois une String ou un Writer selon le cas).
a++

[edit] En partie (bien) grillé par in ;)

20/03/2008, 14h40
in

Citation:

Envoyé par adiGuba

[edit] En partie (bien) grillé par in ;)

J'ai envie d'enlever mon message tellement le tien est :king:
20/03/2008, 14h45
Sinon

Merci bcp pour vos remarques :D

Alors si j'ouvre le fichier en lecture dans la métode ecrire_Fichier() et supprime_Fichier() c'est parce que c'est le seul moyen que j'ai trouvé pour tester si le fichier existe. Je ne veux pas le créer ni le supprimer s'il n'existe pas. Or avec le write() il créer le fichier s'il n'existe pas.

Dans supprime_Fichier() je ne sais pas trop comment supprimer le fichier en question :koi: Je crois que je n'utilise pas les bons types. Avec des "File" ce serait plus simple ?
20/03/2008, 14h49
adiGuba

Citation:

Envoyé par Sinon

Avec des "File" ce serait plus simple ?

Oui ! FileReader et FileWriter sont fait uniquement pour lire/écrire dans un fichier.
Pour tous ce qui concerne la gestion du fichier la classe File est plus appropriée...

a++

La classe File possede ses propres méthodes de tests d'existence, etc . c'est pratique en effet.

ta méthode ecrire fichier me trouble un peu
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public void ecrire_Fichier (String p_fich, String p_commentaire, boolean ajout) throws IOException { try { FileReader w_r = new FileReader(p_fich); FileWriter w_c = new FileWriter(p_fich, ajout); w_c.write(p_commentaire); w_c.flush(); w_c.close(); } catch (FileNotFoundException exc) { System.out.println("fichier inexistant !!!"); }
En effet je suis pas sur que toutes les méthodes appellées renvoient un FNFException ....( si le fichier existe mais pas les droits qu'il faut etc ... ?)
tu devrais rajouter un catch plus "générique" derriere.

Merci

Je vais reprendre progressivement en tenant compte de vos remarques :

Voici ma nouvelle méthode lire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
	public void lireFichier (String fich) throws IOException {
		BufferedReader lecture = null; 
		String ligne; 
 
		try {
			lecture = new BufferedReader (new FileReader(fich)); 
			while ((ligne = lecture.readLine()) != null)
				System.out.println(ligne);
		}
 
		catch (FileNotFoundException exc) {
			System.out.println("Fichier inexistant !!!");
		}
 
		finally {
			lecture.close();
		}
	}

Peut être que tu devrais quand même gérer les autres exception, ça ne coute rien ...

Code:

1
2
3
4
5
6
7
// ....
} catch (FileNotFoundException exc) {
	System.out.println("Fichier inexistant !!!");
} catch (Exception e) {
        System.out.println("Autre exception : "+e.getMessage());
        e.printStackTrace(); // la trace de l'exception est souvent la seule manière de trouver un bug ...
}

Citation:

Envoyé par in

Peut être que tu devrais quand même gérer les autres exception, ça ne coute rien ...

Ce qui est bizarre c'est qu'il en traite la moitié : tu traites le FileNotFound mais pas les autres IOException :koi:
:arrow: Tu as donc deux niveau de traitement des exceptions :?
Il est préférable soit de tout traiter dans la méthode, soit de tout traiter en dehors...

De plus tu utilises un try/catch/finally et si une exception survient lors de la création du fichier tu vas passer dans le catch ET dans le finally alors que le fichier n'aura pas été ouvert :arrow: NullPointerException

Perso je te conseillerai plutôt d'utiliser un try/finally seulement. Et si tu veux traiter les exception tu utilises un try/catch qui engloberait le tout.

Donc, soit tu ne traites pas les exceptions dans la méhode :
Code:

1 2 3 4 5 6 7 8 9 10 11 public void lireFichier(String fich) throws IOException, FileNotFoundException { BufferedReader lecture = new BufferedReader(new FileReader(fich)); // throw FileNotFoundException try { String ligne; while ((ligne = lecture.readLine()) != null) { // throw IOException System.out.println(ligne); } } finally { lecture.close(); } }
:arrow: Si le FileNotFoundException survient lors de l'ouverture, tu sortiras directement de la méthode sans passer par le finally (puisque tu n'es pas dans le try), et c'est parfait puisque le fichier ne doit pas être fermé puisqu'il n'a même pas pu être créé...
:arrow: Si l'ouverture du fichier se passe bien on rentre dans le try, et on est alors sûr de passer dans le finally dans tous les cas, et donc de fermer le fichier.

Maintenant si tu veux traiter les exceptions au sein de la méthode le plus simple est d'englober le tout dans un try/catch :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public void lireFichier(String fich) { try { BufferedReader lecture = new BufferedReader(new FileReader(fich)); // throw FileNotFoundException try { String ligne; while ((ligne = lecture.readLine()) != null) { // throw IOException System.out.println(ligne); } } finally { lecture.close(); } } catch (FileNotFoundException e) { System.err.println("Fichier inexistant : " + fich); } catch (IOException e) { System.err.println("Erreur de lecture : " + e.getMessage() ); e.printStackTrace(); } }
Sinon il est possible d'utiliser un try/catch/finally proprement mais il faut alors vérifier la nullité de la ressource et dupliquer le try/catch :
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 public void lireFichier(String fich) { BufferedReader lecture = null; try { lecture = new BufferedReader(new FileReader(fich)); // throw FileNotFoundException String ligne; while ((ligne = lecture.readLine()) != null) { // throw IOException System.out.println(ligne); } } catch (FileNotFoundException e) { System.err.println("Fichier inexistant : " + fich); } catch (IOException e) { System.err.println("Erreur de lecture : " + e.getMessage() ); e.printStackTrace(); } finally { if (lecture!=null) { try { lecture.close(); } catch (IOException e) { System.err.println("Erreur de lecture : " + e.getMessage() ); e.printStackTrace(); } } } }
a++

Bonjour,

@adiGuba : si je décide de ne pas traiter les exceptions dans la méthode, il faut les traiter dans la méthode appelante (main) ?

Voici mon nouveau code, je pense qu'il est nettement mieux grâce à vos remarques :D
- J'ai utilisé la classe FILE
- J'ai utilisé des méthodes statiques
- j'ai utilisé 2 cas de gestion des Exceptions
- J'ai utilisé un IF EXISTS pour vérifier si le fichier existe avant d'écrire dedans, mais j'aurais préféré le faire avec un try/catch

CLASSE FICHIER :

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
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class Fichier {
 
	// on ne traite pas les exceptions dans cette méthode...
	public static void lireFichier (File fich) throws IOException, FileNotFoundException {
		BufferedReader lecture = new BufferedReader (new FileReader(fich));
		try {
			String ligne;
			while ((ligne = lecture.readLine()) != null) {
				System.out.println(ligne);
			}
		}
 
		finally {
			lecture.close();
		}
	}
 
	// on traite les exceptions dans cette méthode...
	public static void ecrireFichier (File pmyfile, String pcommentaire, boolean ajout) {
		try {
			if (pmyfile.exists()) {
				FileWriter ecriture = new FileWriter(pmyfile, ajout);				
				try {
					ecriture.write(pcommentaire); // throw IOException
				} finally {
					ecriture.flush();
					ecriture.close();			
				}
			}
			else {
				System.out.println("fichier inexistant");
			}
		} catch (Exception e2) {
				System.out.println("Autre exception :"+e2.getMessage());
				e2.printStackTrace();
		}
	}
}

CLASSE PRINCIPALE

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
import java.io.File;
import java.io.IOException;
 
public class principale {
 
	public static void main(String[] args) throws IOException {		
		File myfile = new File("texte");
		Fichier.lireFichier(myfile);
		String commentaire = "Ceci est un nouveau commentaire";
		Fichier.ecrireFichier(myfile, commentaire, true);
	}
}