Discussion :

[rosyfulla]

Bonjour tout le monde !

Depuis hier j'essaie de faire un programme qui permet de concaténer des fichiers sur un dossier local que j'ai crée dans le projet.

Les fichiers ne contiennent qu'une seule ligne chacun , et j'aimerai que le fichier résultat contient la concaténation de ces fichiers avec les lignes de chaque fichier séparées par un saut ligne pour qu'elles ne soient pas collées .

Voici le bout de code que j'ai utilisé avec une hashmap , il me renvoit tout le temps une erreur , je ne sais pas pourquoi ! Pourriez vous m'aider à trouver l'erreur et de corriger mon code s'il vous plaît ??

PS: j'ai ajouté le "ISO-8859-1" puisque mes fichiers sont encodés sur ce format. Ils ont l'extention *.trc mais ils sont tous des textes

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Map.Entry;
 
public class Concatenation {
 
	//attributs
	private static PrintWriter fluxSortie;
	private static HashMap<String,String> filesNamesPaths ;
	private static HashMap<String,String> resultat ;
	private static File folder;
 
	/**
         * @param args
         * @throws FileNotFoundException 
         */
	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
 
		//récupérer la liste des path des fichiers textes dans une HashMap
        folder = new File("input/Traces");
        File[] listOfFiles = folder.listFiles();
        filesNamesPaths = new HashMap<String,String>();
        for (File file : listOfFiles) {
            if (file.isFile()) {
 
            	filesNamesPaths.put(file.getName(),file.getPath());     
            }
        }
 
 
        File fileTwo=new File("resultatfile.trc");
        FileOutputStream fos=new FileOutputStream(fileTwo);
        fluxSortie = new PrintWriter(fos);
        resultat = new HashMap<String,String>();
 	    resultat.putAll(filesNamesPaths);
 
 
 	   for(Entry<String, String> entry : resultat.entrySet()) {
 	       // fluxSortie = new PrintWriter(new FileOutputStream("output/Traces/trace"));
 	        	   File file = new File(entry.getValue());
 	               Scanner scanner = new Scanner(file,"ISO-8859-1");
 	               while (scanner.hasNextLine()) {
 	               String currentLine = (String) scanner.nextLine();
 
 
 	               fluxSortie.print(resultat.put(file.getName(),"")+"  " +currentLine + "/r");
 
 
 
/*
 
      //Parcourir la HashMap et effectuer les traitements
       for(Entry<String, String> entry : resultat.entrySet()) {
        	//  File file = new File(entry.getValue());
            //  Scanner scanner = new Scanner(file);
    	   
    	   File file = new File(entry.getValue());
           Scanner scanner = new Scanner(file,"ISO-8859-1");
           while (scanner.hasNextLine()) {
        	   fluxSortie.print(resultat.put(file.getName(),"")+"/r");
           }
    	   fluxSortie.println(resultat);
        	   
           scanner.close();
*/
	}                             
 	              fluxSortie.println(resultat);
 
 	             scanner.close(); 
 	   }
	}
}

Merci par avance de vos retours.

[joel.drigo]

Salut,

Quelle erreur ? Une ConcurrentModificationException peut-être ?

Tu te compliques bien la vie : tu as seulement besoin de concaténer les lignes de chaque fichier dans un seul ? Parce que ce n'est pas ce que fait ton programme...

Que fait ça, par exemple, à ton avis :

Code :

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

fluxSortie.print(resultat.put(file.getName(),"")+"  " +currentLine + "/r");

Au premier appel pour un nom de fichier donné, ça renvoit le path de ce fichier, ça le concatène à une espace suivi de la ligne courante, ça met un \r (pas forcément un passage à ligne selon l'os), et ça remplace le path du fichier par une chaine vide. Les appels suivants ça concatène une espace plus la ligne courante puis un \r. Dans la map, on se retrouve donc à la fin avec clef=nom de fichier, valeur associée = ligne 1 une espace ligne 2 une espace...

Ensuite, entre chaque fichier, tu remets la map actuelle conplète à la suite du fichier de sortie.

Pour concaténer plusieurs fichiers dans un seul, il suffit de

Code :

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

1
2
3
4
5
6
7
8
9
Ouvrir le fichier de sortie
pour chaque fichier f en entrée
   ouvrir f
   pour chaque ligne de f en entrée, 
      ecrire la ligne de f dans le fichier de sortie avec un newline à la fin
   fin pour
   fermer f
fin pour
fermer le fichier de sortie

Pas besoin de map.

En plus t'embête pas avec \r, fait un println() pour chaque ligne, et tu auras un newline standard pour l'os sur lequel ton programme tourne. Tu peux également utiliser un BufferedWriter au lieu d'un PrintWriter, et utiliser write(String) et newLine().

Pense à fermer fluxSortie aussi.

Si tu as besoin ne pas avoir de newline à la fin du fichier de sortie :

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
 
premiereligne = vrai
Ouvrir le fichier de sortie
pour chaque fichier f en entrée
   ouvrir f
   pour chaque ligne de f, 
      si premiereligne est vrai
         premiere ligne = faux
      sinon 
         ecrire newline à la fin (println())
      fin si
      ecrire la ligne de f dans le fichier de sortie
   fin pour
   fermer f
fin pour
fermer le fichier de sortie

Pour ouvrir un fichier texte en entrée, le plus simple :

Code :

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

1
2
3
try( BufferedReader reader = Files.newBufferedReader(file.toPath(), Charset.forName("ISO-8859-1")) ) {
  // ici le code de lecture du fichier (par reader)			
}

Mais puisque tes fichiers en entrée ne font qu'une seule ligne, autant utiliser, encore plus simple :

Code :

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

1
2
for(String line : Files.readAllLines(file.toPath(), Charset.forName("ISO-8859-1")) {
}

Pour ton fichier en sortie :

Code :

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

1
2
3
4
5
6
try (BufferedWriter writer = Files.newBufferedWriter(fileOutput.toPath())) {
    // code d'écriture dans le fichier
    // writer.write(string);
    // pour le passage à la ligne
    // writer.newLine()
}

[rosyfulla]

Bonjour Joel,

Merci beaucoup pour votre réponse , je pense que je vais suivre votre démarche pour comparer.

En effet je viens de réussir à avoir le fichier voulu avec mes hashmap avec le code ci dessous , par contre je ne trouve pas d'explication au nombre de lignes que j'ai eu , j'ai 815 lignes alors que j'ai 825 fichiers :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Map.Entry;
 
public class Concatenation {
 
	//attributs
	private static PrintWriter fluxSortie;
	private static HashMap<String,String> filesNamesPaths ;
	private static File folder;
 
	/**
         * @param args
         * @throws IOException 
         */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
 
		//récupérer la liste des path des fichiers textes dans une HashMap
        folder = new File("input");
        File[] listOfFiles = folder.listFiles();
        filesNamesPaths = new HashMap<String,String>();
        for (File file : listOfFiles) {
            if (file.isFile()) {
 
            	filesNamesPaths.put(file.getName(),file.getPath()); 
            	System.out.println(filesNamesPaths.put(file.getName(),file.getPath()));
            }
        }
 
 
        File fileTwo=new File("resultatfile.trc");
        FileOutputStream fos=new FileOutputStream(fileTwo);
        fluxSortie = new PrintWriter(fos);
      //  resultat = new HashMap<String,String>();
 	   // resultat.putAll(filesNamesPaths);
 
 
 	   for(Entry<String, String> entry : filesNamesPaths.entrySet()) {
 	       // fluxSortie = new PrintWriter(new FileOutputStream("output/Traces/trace"));
 	        	   File file = new File(entry.getValue());
 	               Scanner scanner = new Scanner(file,"ISO-8859-1");
 	               while (scanner.hasNextLine()) {
 	               String currentLine = (String) scanner.nextLine();
 
 	            //  BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(fileTwo.getName(), true)); 	               
 	               fluxSortie.print(currentLine + "\r\n");
 
 
 	       	}                             
 	            //  fluxSortie.println(filesNamesPaths); 	        	   
 	             scanner.close(); 
 	   }
 
       System.out.println("Fin d'éxecution");
 
	}
}

[joel.drigo]

Si tu n'as pas l'ensemble de tes lignes, c'est probablement parce que le buffer du writer n'est pas complètement vidé dans le fichier.

Ferme fluxSortie à la fin !