Recherche dans un fichier

**rosyfulla** · 10/02/2015, 19h32

Bonjour tout le monde ,

J'ai besoin d'un petit coup de main sur ce bout de code

, en effet j'utilise mon code pour generer des fichiers qui vont chercher dans un repertoire de fichiers.
par exemple sur l'un de mes fichiers(Logs) j'ai cette structure :

le hh:mm:ss est variant, le nombre de Start est variant entre les End mais pour chaque Start on a un End normalement. Le nombre de Start est supérieur au nombre de End

Start .....hh:mm:ss
ldfjdfklfkjf
ididfhdsfhsu
Start ...hh:mm:ss
Start ...hh:mm:ss
Start ...hh:mm:ss
End ..hh:mm:ss
Start hh:mm:ss
kqldjhjkdh
End...hh:mm:ss

Ce qui m'interesse c'est de récuperer les lignes qui commence par Start et End. Mon code le fait très bien , sauf que j'ai une autre contrainte , je veux récuperer la ligne qui contient Start et juste après la ligne suivante qui contient End puis le Start suivant puis le End suivat et ainsi de suite ....hh:mm:ss End hh:mm:ss Start hh:mm:ss End hh:mm:ss

Voici le code que j'utilise :

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
 
public class resumeLog{
 
	//attributs
	private static PrintWriter fluxSortie;
	private static HashMap<String,String> filesNamesPaths ;
	private static File folder;
	/*private static int rating;*/
 
	/**
         * @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()); 
            	  System.out.println(filesNamesPaths.put(file.getName(),file.getPath()));
            }
        }
 
      //Parcourir la HashMap et effectuer les traitements
        for(Entry<String, String> entry : filesNamesPaths.entrySet()) {
        fluxSortie = new PrintWriter(new FileOutputStream("output/Traces/trace"+entry.getKey()));
        	   File file = new File(entry.getValue());
               Scanner scanner = new Scanner(file,"ISO-8859-1");
               while (scanner.hasNextLine()) {
               String currentLine = (String) scanner.nextLine();
 
 
               if(currentLine.startsWith("   Start:") || currentLine.startsWith("Start:") || currentLine.startsWith("   End:") || currentLine.startsWith("End:")){
 
 
               fluxSortie.print(filesNamesPaths.put(file.getName(),"")+"  " +currentLine);
 
 
 
               }
 
               }
               fluxSortie.close();               
               scanner.close();
        }
 
 
 
 
 
        System.out.println("Fin d'éxecution");
 
 
 
 
	}
 
}

Ce code va me donner ça Start .....hh:mm:ss Start ...hh:mm:ss Start ...hh:mm:ss Start ...hh:mm:ss End ..hh:mm:ss Start hh:mm:ss End...hh:mm:ss

alors que je cherche ça Start .....hh:mm:ss End ..hh:mm:ss Start hh:mm:ss End...hh:mm:ss

Est ce qu'il y a un moyen de faire ça sur mes fichiers texte ??

Merci pour vos retours.

**joel.drigo** · 10/02/2015, 20h22

Salut,

Utilises une liste pour mémoriser les "starts", ne les ecrit pas au fur et à mesure, et dès que tu as un end, tu peux écrire tous les start/end correspondand.

Ce qui donnerait, avec un code plus simple que le tien (sans cette Mao qui ne sert à rien en particulier).

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
public class ResumeLog {
 
	private static final String INPUT_FOLDER = "input/traces";
	private static final String OUTPUT_FOLDER = "output/Traces";
	private static final String OUTPUT_PREFIX = "trace"; 
 
	/**
         * @param args
         * @throws FileNotFoundException 
         */
	public static void main(String[] args) throws IOException {
 
       Path folderInput = Paths.get(INPUT_FOLDER);
 
       try (DirectoryStream<Path> ds = Files.newDirectoryStream(folderInput, p-> !Files.isDirectory(p)) ) {
 
    	   for (Path file : ds ) {
 
    		   process(file);
 
    	   }
 
       } 
 
       System.out.println("Fin d'éxecution");
 
	}
 
	private static void process(Path file) throws IOException {
 
		try( BufferedReader reader = Files.newBufferedReader(file, Charset.forName("ISO-8859-1"));
			 BufferedWriter writer = Files.newBufferedWriter(Paths.get(OUTPUT_FOLDER, OUTPUT_PREFIX + file.getFileName()))) {
 
			// on écrit le nom du fichier au début
			writer.write(file.getFileName().toString()); 
 
			List<String> starts = new ArrayList<String>();
			for(String line = reader.readLine(); line!=null ; line=reader.readLine() ) {
 
				if ( line.trim().startsWith("Start:") ) {
					// chaque fois qu'on rencontre un start, on le mémorise
					starts.add(line); 
				}
				else if ( line.trim().startsWith("End:") ) {
 
					// chaque fois qu'on rencontre un end, on affiche tous les couples start/end à partir des derniers mémorisés
 
					for(String start : starts) {
						writer.write("  ");
						writer.write(start);
						writer.write(line);
					}
 
					// on efface les derniers starts mémorisé
					starts.clear();
 
				}
 
			}
 
		}
 
	}
 
}

Ou encore plus simple, si tes fichiers ne sont pas volumineux :

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
public class ResumeLog {
 
	private static final String INPUT_FOLDER = "input/traces";
	private static final String OUTPUT_FOLDER = "output/Traces";
	private static final String OUTPUT_PREFIX = "trace"; 
 
	/**
         * @param args
         * @throws FileNotFoundException 
         */
	public static void main(String[] args) throws IOException {
 
       Path folderInput = Paths.get(INPUT_FOLDER);
 
       try (DirectoryStream<Path> ds = Files.newDirectoryStream(folderInput, p-> !Files.isDirectory(p)) ) {
 
    	   for (Path file : ds ) {
 
    		   process(file);
 
    	   }
 
       } 
 
       System.out.println("Fin d'éxecution");
 
	}
 
	private static void process(Path file) throws IOException {
 
		try( BufferedWriter writer = Files.newBufferedWriter(Paths.get(OUTPUT_FOLDER, OUTPUT_PREFIX + file.getFileName()))) {
 
			// on écrit le nom du fichier au début
			writer.write(file.getFileName().toString()); 
 
			List<String> starts = new ArrayList<String>();
			//for(String line = reader.readLine(); line!=null ; line=reader.readLine() ) {
 
			for(String line : Files.readAllLines(file, Charset.forName("ISO-8859-1"))) {
 
				if ( line.trim().startsWith("Start:") ) {
					// chaque fois qu'on rencontre un start, on le mémorise
					starts.add(line); 
				}
				else if ( line.trim().startsWith("End:") ) {
 
					// chaque fois qu'on rencontre un end, on affiche tous les couples start/end à partir des derniers mémorisés
 
					for(String start : starts) {
						writer.write("  ");
						writer.write(start);
						writer.write(line);
					}
 
					// on efface les derniers starts mémorisé
					starts.clear();
 
				}
 
			}
 
		}
 
	}
 
}

**Népomucène** · 10/02/2015, 20h22

Bonsoir.

avec le code :

Code :

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

if(currentLine.startsWith("   Start:") || currentLine.startsWith("Start:") || currentLine.startsWith("   End:") || currentLine.startsWith("End:")){

Tu cherches à avoir ce qui se trouve immédiatement après le signe ":"
Tu peux donc faire :

Code :

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

1
2
3
4
 
        int pos = currentLine.indexOf(":"); // te donnes la position du premier ":"
        currentLine = currentLine.substring(pos + 1);    // fait sauter le début
        System.out.println(currentLine );  // pour voir

**rosyfulla** · 10/02/2015, 20h47

En effet il se peut qu'il y ait des lignes vides dans le fichier entre les starts et ends . Peut on mettre la fin du fichier à la place de line!=null ??

Pour Népomucène j'ai besoin de connaitre si c'est un Start ou un début ...

Merci beaucoup pour votre aide .

**joel.drigo** · 10/02/2015, 21h55

line est null quand on arrive à la fin du fichier. C'est pour ça que je fais justement un for avec condition line!=null : ça sort de la boucle quand line est null, c'est-à-dire à la fin du fichier.

Une ligne vide, c'est line qui contient chaine vide, soit "", ou, à la rigueur, que des espaces. Mais ces lignes n'ont aucune importance, puisqu'on ne traite que celles qui commencent par start ou end (en enlevant les espaces devant par l'appel de trim()).

**rosyfulla** · 11/02/2015, 13h19

Bonjour Joel,

J'ai modifié un peu ton code à cause des erreurs que j'ai eu , j'ai une exception au niveau de la ligne en lançant , je n'ai pas bien compris comment fonctionnent les arguments de cette classe :

try( BufferedWriter writer = Files.newBufferedWriter(Paths.get(OUTPUT_FOLDER, OUTPUT_PREFIX + file.getFileName()),StandardCharsets.UTF_8, StandardOpenOption.WRITE))

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
78
79
80
81
 
import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;
import java.io.BufferedWriter;
import java.io.IOException;
 
public class concat {
 
	private static final String INPUT_FOLDER = "input";
	private static final String OUTPUT_FOLDER = "output";
	private static final String OUTPUT_PREFIX = "trace"; 
 
	/**
         * @param args
         * @throws FileNotFoundException 
         */
	public static void main(String[] args) throws IOException {
 
       Path folderInput = Paths.get(INPUT_FOLDER);
 
       try (DirectoryStream<Path> ds = Files.newDirectoryStream(folderInput) ) {
 
    	   for (Path file : ds ) {
 
    		   System.out.println(file.getFileName());
    		   process(file);
 
    	   }
 
       } 
 
       System.out.println("Fin d'éxecution");
 
	}
 
	private static void process(Path file) throws IOException {
 
		try( BufferedWriter writer = Files.newBufferedWriter(Paths.get(OUTPUT_FOLDER, OUTPUT_PREFIX + file.getFileName()),StandardCharsets.UTF_8, StandardOpenOption.WRITE)) {
 
			// on écrit le nom du fichier au début
			writer.write(file.getFileName().toString()); 
 
			List<String> starts = new ArrayList<String>();
			//for(String line = reader.readLine(); line!=null ; line=reader.readLine() ) {
 
			for(String line : Files.readAllLines(file, Charset.forName("ISO-8859-1"))) {
 
				if ( line.trim().startsWith("Start:") ) {
					// chaque fois qu'on rencontre un start, on le mémorise
					starts.add(line); 
				}
				else if ( line.trim().startsWith("End:") ) {
 
					// chaque fois qu'on rencontre un end, on affiche tous les couples start/end à partir des derniers mémorisés
 
					for(String start : starts) {
						writer.write("  ");
						writer.write(start);
						writer.write(line);
					}
 
					// on efface les derniers starts mémorisé
					starts.clear();
 
				}
 
			}
 
		}
 
	}
 
}

Une autre question , en ce qui concerne la liste que tu as mis dans la boucle , je peux bien afficher que le premier Start avant de trouver le End c'est ça ?

Merci d'avance pour ta réponse

**joel.drigo** · 11/02/2015, 14h27

Salut

Envoyé par rosyfulla

J'ai modifié un peu ton code à cause des erreurs que j'ai eu ,

Quelles erreurs ? Tu dois être en Java 7 et pas en Java 8... d'ailleurs, je vois que tu as retiré le filtre qui permettait de ne prendre que les fichiers, surement à cause de l'expression lambda, qui ne peut être utilisée qu'en Java 8 :

Code :

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

Files.newDirectoryStream(folderInput, p-> !Files.isDirectory(p)) ) {

Pour faire fonctionner ça en Java 7 :

Code :

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

1
2
3
4
5
6
Files.newDirectoryStream(folderInput, new DirectoryStream.Filter() {
           public boolean accept(Path p) throws IOException {
                return !Files.isDirectory(p);
           }       
   }
) {

Envoyé par rosyfulla

j'ai une exception au niveau de la ligne en lançant , try( BufferedWriter writer = Files.newBufferedWriter(Paths.get(OUTPUT_FOLDER, OUTPUT_PREFIX + file.getFileName()),StandardCharsets.UTF_8, StandardOpenOption.WRITE))

Quelle exception ?

Envoyé par rosyfulla

je n'ai pas bien compris comment fonctionnent les arguments de cette classe :

Paths.get( String, String...) : le premier argument c'est le début du path, et les suivants les parties suivantes. Ça fait comme une concaténation et ça retourne un Path (un équivalent de File, à sauve Java 7)

Files.newBufferedWriter( path, charset, ...openOptions...))" le premier c'est le Path du fichier qu'on veut ouvrir en écriture, le deuxième c'est le charset (dans ton code, tu as mis UTF-8) et à la suite il y a les options d'ouverture, facultatives.

En Java8, il y a une version sans le paramètre charset (utilise le charset par défaut)

Envoyé par rosyfulla

Une autre question , en ce qui concerne la liste que tu as mis dans la boucle , je peux bien afficher que le premier Start avant de trouver le End c'est ça ?

Oui. Tu sais que c'est le premier start si starts est vide :

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
if ( line.trim().startsWith("Start:") ) {
    if ( starts.isEmpty() {
           writer.write("  ");
           writer.write("  ");
          writer.write( line ); // écrire que le premier start, dès qu'il est trouvé
    }
    // chaque fois qu'on rencontre un start, on le mémorise
    starts.add(line); 
}
else if ( line.trim().startsWith("End:") ) {
 
    // chaque fois qu'on rencontre un end, on affiche tous les couples start/end à partir des derniers mémorisés
    if ( starts.size()>1 ) {
       starts.remove(0); // on enlève le premier, sinon il va être écrit 2 fois
       for(String start : starts) {
           writer.write("  ");
    	   writer.write(start);
           writer.write("  ");
	   writer.write(line);
       }
    }
 
    // on efface les derniers starts mémorisé
    starts.clear();
 
}

Evidemment, ici, ça ne change rien au résultat, puisqu'on écrire que des "start" et des "end"...

**rosyfulla** · 11/02/2015, 19h26

Rebonjour,

J'essaye d'ajouter la variable p mais j'ai toujours une erreur. Savez vous pourquoi ?
( J'ai le Java 7 )

Nom : variable p.jpg
Affichages : 117
Taille : 95,6 Ko

Nom : variable p.jpg
Affichages : 117
Taille : 95,6 Ko

Merci d'avance

**joel.drigo** · 11/02/2015, 19h32

C'est parce que l'expression p-> !Files.isDirectory(p) n'existe pas en Java 7. Elle ne veut rien dire et Eclipse essaye de proposer des solutions de correction, mais tu ne pourras de toute façon rien faire de correct avec les conseils qu'il te donne (p n'est pas une variable en l'occurence, donc Eclipse ne sait pas te proposer de "bon" choix). Il faut la (toute l'expression) remplacer par ce que j'ai dit qu'il fallait mettre à la place dans mon dernier message, c'est-à-dire par ça :

Code :

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

1
2
3
4
5
new DirectoryStream.Filter() {
           public boolean accept(Path p) throws IOException {
                return !Files.isDirectory(p);
           }       
   }

**rosyfulla** · 11/02/2015, 20h41

Joel,

J'ai ajouté la méthode avant le try, et pourtant il ne reconnaît pas le p ...

Merci

**joel.drigo** · 11/02/2015, 21h28

Tu dois simplement remplacer tout ça :

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
/**
 * @param args
 * @throws FileNotFoundException 
 */
public static void main(String[] args) throws IOException {
 
       Path folderInput = Paths.get(INPUT_FOLDER);
 
       try (DirectoryStream<Path> ds = Files.newDirectoryStream(folderInput, 
                  p-> !Files.isDirectory(p) 
            )) {
 
    	   for (Path file : ds ) {
 
    		   process(file);
 
    	   }
 
       } 
 
       System.out.println("Fin d'éxecution");
}

Par

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
/**
 * @param args
 * @throws FileNotFoundException 
 */
public static void main(String[] args) throws IOException {
 
       Path folderInput = Paths.get(INPUT_FOLDER);
 
       try (DirectoryStream<Path> ds = Files.newDirectoryStream(folderInput, 
                new DirectoryStream.Filter() {
                    public boolean accept(Path p) throws IOException {
                           return !Files.isDirectory(p);
                    }       
                } 
            )) {
 
    	   for (Path file : ds ) {
 
    		   process(file);
 
    	   }
 
       } 
 
       System.out.println("Fin d'éxecution");
}

Recherche dans un fichier

Langage Java

Discussions similaires

Partager

Partager