Discussion :

[cheyma]

Bonjour tout le monde

Ma question est mentionnée dans le titre. Je voudrais éliminer les lignes entières qui contiennent le caractère #
j'ai essayé avec cette classe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class SuppLignVide {
    public static void deleteLine(String f1, String f2) throws IOException {
 
 
            BufferedReader input = new BufferedReader(new FileReader(f1));
            BufferedWriter output = new BufferedWriter(new FileWriter(f2));
            String line = "";
            while ((line = input.readLine()) != null) {
                if (line.compareTo("#")<0) {
                    output.write(line);
                    output.newLine();
                    output.close();
 
                }
 
            }
 
        }
 
 
    public static void main(String[] args) throws IOException {
        String f1 = "mon_chemin1.txt";
        String f2 = "mon_chemin2.txt";
        deleteLine(f1, f2);
    }
 
}

[Drowan]

Utilise la fonction contains sur ta ligne plutôt que compareTo

[cheyma]

Merci Drowan,

mais il m'affiche seulement la première ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
  public static void deleteLine(String f1, String f2) throws IOException {
 
        try{
            BufferedReader input = new BufferedReader(new FileReader(f1));
            BufferedWriter output = new BufferedWriter(new FileWriter(f2));
            String line = "";
            while ((line = input.readLine()) != null) {
                if (line.contains("#")==false) {
                    output.write(line);
                    output.newLine();
                    output.close();
 
                }
                input.close();
            }
            } catch (Exception e) {
 
        }
 
        }

[joel.drigo]

Salut,

Immédiatement après avoir écrit une ligne, tu fermes le flux. Ensuite tu essayes d'écrire dans un flux fermé, donc ça cause des exceptions, que tu ne vois pas parce que ton block catch ne contient aucune instruction. Ne jamais faire un bloc catch vide... et fermer le flux quand on a fini d'écrire dedans...

[cheyma]

Merci ,

Sauf que même si je met l'excéption , un warning m'indique que printStackTrace should be removed

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 public static void deleteLine(String f1, String f2) throws IOException {
 
        try {
            BufferedReader input = new BufferedReader(new FileReader(f1));
            BufferedWriter output = new BufferedWriter(new FileWriter(f2));
            String line = "";
            while ((line = input.readLine()) != null) {
                if (line.contains("#") == false) {
                    output.write(line);
                    output.newLine();
                }
 
            }
            input.close();
            output.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
 
    }

Merci pour vos réponses rapides

[joel.drigo]

un warning m'indique que printStackTrace should be removed

Vraiment ? Tu es sûre ? C'est quoi ton EDI ?

Ton code présente bien des problèmes au niveau de la gestion des exceptions et des fermetures de flux, mais pas sur l'affichage de la stacktrace...
Le principal problème est qu'en cas d'exception, les flux ne seront pas fermés. De plus, pense toujours à faire des catchs dédiés aux seules exceptions qui sont soulevées dans le bloc, et non pas en catchant tout. Si tu utilises un try-with-resource, ça te simplfiera la tâche (tu n'auras justement plus à te soucier de la fermeture.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 public static void deleteLine(String f1, String f2) throws IOException {
 
        try ( BufferedReader input = new BufferedReader(new FileReader(f1));
            BufferedWriter output = new BufferedWriter(new FileWriter(f2));) {
            String line = "";
            while ((line = input.readLine()) != null) {
                if (line.contains("#") == false) {
                    output.write(line);
                    output.newLine();
                }
 
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

Ta méthode n'a pas besoin de faire throws IOException.

[julien-blaise]

Hello,

Idéalement, la gestion de tes clôtures de flux devrait se faire dans un bloc finally, de cette manière quoi qu'il arrive tu fermeras les canaux proprement et tu pourrais même ajouter un flush pour être sur d'avoir tout écrit dans le fichier avant de le fermer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public void deleteLine(String f1, String f2) throws IOException {
        BufferedReader input = new BufferedReader(new FileReader(f1));
        BufferedWriter output = new BufferedWriter(new FileWriter(f2));
 
        try {
            String line = "";
            while ((line = input.readLine()) != null) {
                if (line.contains("#") == false) {
                    output.write(line);
                    output.newLine();
                }
            }
        } catch (Exception e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
        } finally {
            output.flush();
            input.close();
            output.close();
        }
 
    }

A+

[adiGuba]

Salut,

Idéalement, la gestion de tes clôtures de flux devrait se faire dans un bloc finally,

A partir de Java 7 il est préférable d'utiliser le try-with-ressource comme dans l'exemple de joel.drigo

Avant il fallait bien utiliser des try/finally, mais l'utilisation que tu en fait est incorrecte car il y a plusieurs cas où les ressources risquent de ne pas être libéré correctement :

• Si le fichier "f2" ne peut pas être ouvert, cela remonte une exception et "f1" n'est pas fermé.
• Si output.flush() remonte une exception, rien n'est fermé.
• Si input.close() remonte une exception, output n'est pas fermé.

Sans parler de ta gestion des exceptions à deux niveaux (certaines passent dans le catch, d'autre non).

il faut utiliser un try/finally par ressources, et le bloc finally ne doit rien contenir d'autre que le close().

Ce qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void deleteLine(String f1, String f2) throws IOException {
	BufferedReader input = new BufferedReader(new FileReader(f1));
	try {
		BufferedWriter output = new BufferedWriter(new FileWriter(f2));
		try {
			String line = "";
			while ((line = input.readLine()) != null) {
				if (line.contains("#") == false) {
					output.write(line);
					output.newLine();
				}
			}
			output.flush();
                } finally {
			output.close();
		}
	} finally {
		input.close();
	}
}

Et si on doit traiter les exceptions, il faut rajouter un bloc try/catch supplémentaire qui engloberait le tout.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
void deleteLine(String f1, String f2) {
	try {
		BufferedReader input = new BufferedReader(new FileReader(f1));
		try {
			BufferedWriter output = new BufferedWriter(new FileWriter(f2));
			try {
				String line = "";
				while ((line = input.readLine()) != null) {
					if (line.contains("#") == false) {
						output.write(line);
						output.newLine();
					}
				}
				output.flush();
        	        } finally {
				output.close();
			}
		} finally {
			input.close();
		}
	} catch (IOException e) {
		e.printStackTrace();
		// ...
	}
}

Le try-with-ressource de Java 7 génère d'ailleurs en fait un code très similaire à cela, mais en restant beaucoup plus lisible :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void deleteLine(String f1, String f2) {
	try (BufferedReader input = new BufferedReader(new FileReader(f1));
	  BufferedWriter output = new BufferedWriter(new FileWriter(f2))) {
		String line = "";
		while ((line = input.readLine()) != null) {
			if (line.contains("#") == false) {
				output.write(line);
				output.newLine();
			}
		}
		output.flush();
	} catch (IOException e) {
		e.printStackTrace();
		// ...
	}
}

a++