Discussion :

[kolodz]

Bonjour,

En utilisant la "nouvelle" API Stream de Java 8, je suis tombé sur un cas d'utilisation où je n'ai pas trouvé de documentation, mais qu'il me semble important de traiter correctement. A savoir la sauvegarde d'un Stream<String> dans un fichier.

J'ai bien une version fonctionnelle, mais celle-ci me semble être purement bancale dans la gestion des erreurs.

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
package org.k.developpez.forum;
 
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
 
public class Test {
 
	public static void main(String[] args) throws IOException {
		LineConsumer lineConsumer =  new LineConsumer("OutputFile.txt");
		// On filtre les lignes contenant le text qu'on veux depuis le fichier de base
		Files.lines(Paths.get("InputFile.txt"), Charset.defaultCharset())
				.filter(line -> line.contains("Enregistrement technique"))
				.forEach(lineConsumer);
		lineConsumer.close();
	}
}

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
28
29
30
31
32
33
34
35
36
37
package org.k.developpez.forum;
 
import java.io.FileWriter;
import java.io.IOException;
import java.util.function.Consumer;
 
public class LineConsumer implements Consumer<String> {
 
	private FileWriter writer;
 
	public LineConsumer(String file) throws IOException {
		writer = new FileWriter(file, true);			
 
	}
 
	@Override
	public void accept(String line) {
		//TODO Ici avoir un try catch me pose problème. Cependant, je ne sais pas comment gérer correctement celle-ci au niveau de la classe test.
		try {
			writer.write(line + "\r\n");
		} catch (IOException e) {
			e.printStackTrace();
		}
 
	}
 
	public void close(){
		try {
			writer.flush();
			writer.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
 
	}
 
}

Enregistrement technique Blabla
Enregistrement fonctionnelle dudule
Enregistrement technique Titi
une ligne bizarre

Si vous avez une idée sur la façon de procéder qui serai potentiellement plus propre, n'hésitez pas !

Cordialement,
Patrick Kolodziejczyk.

[eulbobo]

Déclare ta propre interface fonctionnelle qui peut renvoyer une exception et le tour est joué !

Ou une qui wrap le tout dans une RunTimeException, mais tu peux avoir envie d'avoir des exception checked

[joel.drigo]

Les streams orientent à faire du unchecked : mais on peut utiliser Files.write(), en collectant auparavant. Je pense que c'est mieux d'ouvrir l'IO stream après avoir fini le traitement du stream de toute manière.

[adiGuba]

Salut,


Dans ce cas précis il serait plus simple d'utiliser directement un PrintStream :

Code :

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

1
2
3
4
5
		try (PrintStream out = new PrintStream("OutputFile.txt")) {
			Files.lines(Paths.get("InputFile.txt"), Charset.defaultCharset())
					.filter(line -> line.contains("Enregistrement technique"))
					.forEach(out::println);
		}

Mais ton exemple montre l'un des gros problèmes que les checked-exceptions imposent aux lambdas.
En effet vu que le code des lambdas n'est pas exécuté au "même moment", il est impossible d'avoir un gestion "checked" des exceptions.

Du coup le code suivant ne fonctionne pas bien qu'équivalent :

Code :

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

1
2
3
4
5
6
		try (FileWriter out = new FileWriter("OutputFile.txt", true)) {
			Files.lines(Paths.get("InputFile.txt"), Charset.defaultCharset())
					.filter(line -> line.contains("Enregistrement technique"))
					.map(s -> s + "\r\n")
					.forEach(out::write);
		}

En effet la méthode write() de FileWriter déclare une IOException, ce qui est incompatible avec la déclaration du Consumer<T> attendu par forEach()...



Les checked-exceptions s'adapte mal aux expressions lambdas...
Enfin pas seulement le problème était déjà là avant avec les classes anonymes, mais c'était moins visible.


Bref il serait temps de remettre en cause ce principe...


a++

[kolodz]

Merci pour la réponse !
Et désolé pour le temps de réaction. (Vacances, reprise tout ça....)

C'est effectivement beaucoup plus propre d'utiliser un [c]PrintStream[\c] qui est beaucoup plus dans la logique des Stream
Ce qui fait 4 lignes sans besoin de définir un [c]Consumer[\c] maison. C'est à ce niveau que cela me semblait bizarre qu'il y ai pas quelque chose qui règle déjà cette problématique simple. Mais, c'est juste moi qui n'ai pas penser au [c]PrintStream[\c]!

Cordialement,
Patrick Kolodziejczyk.

[adiGuba]

C'est à ce niveau que cela me semblait bizarre qu'il y ai pas quelque chose qui règle déjà cette problématique simple.

Le PrintStream n'est qu'une solution spécifique.
Les checked-exceptions sont toujours problématique dans de nombreux cas...

Il y a eu des discussions sur ce problème, et plusieurs solutions ont été envisagés.
Mais à chaque fois cela aboutissait à de grosse complication, que ce soit dans l'implémentation des lambdas ou des APIs
Du coup ils en sont resté à conseiller l'utilisation d'unchecked-exception.


Le fait est que le problème ne vient pas des lambdas, mais du principe de checked-exception.
La meilleure solution serait de supprimer cette notion, qui pose plus de problème qu'autre chose...


a++