Discussion :

[leneuf]

Bonjour,
J'ai un problème que je n'arrive pas à résoudre. Ce programme me sert à chercher des adresses mails dans un document texte à partir des expressions régulières :

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 void search() throws IOException{ 	
	  	boolean b =true;
		String s ="[_a-zA-Z\\d\\-\\.]+@[_a-zA-Z\\d\\-\\.]+(\\.[_a-zA-Z\\d\\-]{2,4})";
		pattern = Pattern.compile(s);
	  	String line = a.readLine() ;
  	    while (line != null) {
  	    	m = pattern.matcher(line) ;
  	    	System.out.println(m.find());
  	    while(m.find()){
  	      	for(int i=0; i<=m.groupCount(); i++) {
		 	  if(counts.containsKey(m.group(i))){
  	          ((Counter)counts.get(m.group(i))).increment();}
  	        else{
  	          counts.put(m.group(i), new Counter());}			
  	      	}
  	      }
  	      line = a.readLine() ;
	 	}
	 }

Lorsque je rentre directement mon expression régulière dans le code (comme ci-dessus), le programme fonctionne correctement, il m'affiche bien des adresses mails.
Mais, je voulais pouvoir accéder à une sorte de dictionnaire d'expression régulière dans un fichier txt. J'ai donc créé une autre classe qui me permet de récupérer l'expression régulière dans ce fichier txt. Et là c'est le drame, l'affichage de l'expression régulière est correct dans la console. Par contre, je n'ai aucun résultat positif de mon expression régulière. Comme s'il y avait une différence entre l'affichage et le traitement de ma chaine de caractère.

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
 
private WordCount wc;
	private Object [][] data ;
	private DicPattern d;
	private Object [] t;
 
public Table(lister l, int j){
		this.wc=null;
		   try{
		d = new DicPattern("C:\\Documents and Settings\\Leneuf\\Bureau\\pattern\\pattern.txt");
		   t=d.getHashPattern().values().toArray();
		   int m = d.getNbPattern();
			try {
			  for (int n=0;n<m;n++){
			  wc=new WordCount(l.getVector().get(j).toString());
			  wc.search(t[n].toString());
...//je passe la suite
 
//j'ai donc modifier ma méthode search en conséquence
 
 public void search(String s) throws IOException{
	  	boolean b =true;
		System.out.println(s);
		pattern = Pattern.compile(s);
	  	String line = a.readLine() ;
  	    while (line != null) {
  	    	m = pattern.matcher(line) ;
  	    	System.out.println(m.find());
  	    while(m.find()){
  	      	for(int i=0; i<=m.groupCount(); i++) {
		 	  if(counts.containsKey(m.group(i))){
  	          ((Counter)counts.get(m.group(i))).increment();}
  	        else{
  	          counts.put(m.group(i), new Counter());}			
  	      	}
  	      }
  	      line = a.readLine() ;
	 	}
	 }

J'ai l'impression qu'il y a un problème d'encodage de ma chaine de caractère.
j'ai aussi essayé avec clavier.lireString(). J'ai le même problème.

[adiGuba]

Salut,


On pourrait voir à quoi ressemble ton fichier et comment tu le lis ???

a++

[leneuf]

Le fichier se compose ainsi :
ligne impair->type de l'expression régulière qui le suit
ligne pair -> expression régulière du type qui la précède.
Voici un exemple :

Code :

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

1
2
3
4
5
 
E-mail
"[_a-zA-Z\\d\\-\\.]+@[_a-zA-Z\\d\\-\\.]+(\\.[_a-zA-Z\\d\\-]{2,4})"
Word of 5 or 6 letters
"(?<=(?:\\s|\\G|\\A))\\w{5,6}(?=(?:\\s|\\Z|\\.|\\?|\\!))"

La classe DicPattern me permet de lire ce fichier de récupérer le type et l'expression régulière, de les stocker dans une HashMap :

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
 
public class DicPattern {
 
	  private FileReader file;
	  private BufferedReader a;
	  private HashMap h;
 
 
	  public DicPattern(String Filename) throws FileNotFoundException{
		  file = new FileReader(Filename);
	      a = new BufferedReader(file);
		  this.h=new HashMap();
	  }
 
	  public HashMap getHashPattern() throws IOException{
 
		  String line = a.readLine();
		  String pattern = null;
		  String type = null;
		  int i = 1;
		  String b = "";
		  while(line != null){
		  	if(i % 2==1){
				 type = line;
			  }
			  if(i%2 == 0){
			  	pattern = line;
			  	h.put(type,pattern);
			  }
			  i++;
			  line = a.readLine();
		  }
		  return this.h;
	  }

Je pense cette classe n'a pas de problème puisque lorsque je lui demande l'affichage des types et exp, tout est correct.J'ai testé avec et sans guillemet, ça ne change rien.

[adiGuba]

Justement : à l'intérieur de ton fichier tu ne dois pas doubler tes anti-slash : \\ devient \ !


En effet les \\ sont interprété par le compilateur afin de gérer les caractères spéciaux.

Ainsi si tu affiches ta regexp lorsqu'elle est en dur dans le code, tu verrais que tu n'as plus qu'un seul \ au lieu de 2. Il faut donc que ce soit le cas également par ton fichier (car tu n'interpètes pas les caractères spéciaux lorsque tu le lis).

Le fait de doubler les \ (FAQ : Pourquoi dois-je doubler/quadrupler le caractère anti-slash ('\') ?) ne concerne que les codes sources et non pas les fichiers que tu lis (a moins que cela ne soit interprété lors de la lecture).

a++

[leneuf]

Merci beaucoup, j'avais pas du tout pensé à cela.