Discussion :

[khalous91]

Yoh
alors j'ai un petit problème avec le motif de mon pattern.
En faite, j'ai deux fichiers avec deux morceaux de texte deffirents:

1 txt :

!? DEBUT
a= "^^VBB**_^^DDD**_sylda_^^FFF**"
b = "^^userPath**/^^VBB**/script/^^VBB**_^^DDD**_sylda_^^FFF**/^^RRR**/^^POLI**/^^BATMAN**/sting"
c = "^^userPath**/^^VBB**/script/^^VBB**_^^DDD**_sylda_^^FFF**/^^RRR**/^^POLI**/^^BATMAN**/temoin"
d = "^^userPath**/^^VBB**/script/^^VBB**_^^DDD**_sylda_^^FFF**/^^RRR**/^^POLI**/^^BATMAN**/results"
e = "^^userPath**/^^VBB**/script/^^VBB**_^^DDD**_sylda_^^FFF**/^^RRR**/^^POLI**/^^BATMAN**/cree"
?! FIN

2° txt :

#> DEBUT
b = "{userPath}/{VBB}/script/{VBB}_{DD}_sylda_{FFF}/{RRR}/{POLI}/{BATMAN}/sting"
c = "{userPath}/{VBB}/script/{VBB}_{DDD}_sylda_{FFF}/{RRR}/{POLI}/{BATMAN}/temoin"
d = "{userPath}/{VBB}/script/{VBB}_{DDD}_sylda_{FFF}/{RRR}/{POLI}/{BATMAN}/results"
e = "{userPath}/{VBB}/script/{VBB}_{DDD}_sylda_{FFF}/{RRR}/{POLI}/{BATMAN}/cree"
#< FIN

et en faite j'ai un code qui permet d'afficher les différents clé c'est a dire VBB ,POLI, etc tout ce qui a l'interieur de {...} et ^^..** :

Sauf que le motif de mon pattern : "\\{([\\w]*)\\}" ne me permet pas de traiter n'importe quel fichier. Avez vous une petite astuce ??


code :

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
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
public class ChercheKeysTest2 {
 
	public static void main(String[] args) {
 
		String ZONE_B = "#>";
		String ZONE_E = "#<";	
		String filename = ("C:\\Users\\ksmaili\\workspace\\fichierCSH.txt");
 
		Finally fp = new Finally();
		String texte = fp.extract(filename, ZONE_B, ZONE_E); // Je fais appel au texte qu'on veut traiter!
 
		ArrayList<String> arrList = new ArrayList<String>() ;
 
 
		Pattern p = Pattern.compile("\\{([\\w]*)\\}"); 
		Matcher m = p.matcher(texte);
		while (m.find()) {
 
		   arrList.add((m.group(1))); // on prend le groupe 1
 
		}
			//System.out.println(arrList);
 
		// Etape pour supprimer les doublons : 
 
			//  1er etp: Créer une liste de contenu unique basée sur les éléments de ArrayList
		    Set<String> mySet = new HashSet<String>(arrList);
 
		    // 2eme etp : Créer une Nouvelle ArrayList à partir de Set
	 	    ArrayList<String> arrList2 = new ArrayList<String>(mySet);
 
		    // 3eme etp : Afficher le contenu de ArrayList
		    System.out.println("Contenu sans doublon: "+arrList2);
 
	}
}

[joel.drigo]

Salut,

Il n'y a aucune astuce dans la programmation : il faut écrire un code précis et l'ordinateur fera ce que le code indique. Ni plus, ni moins.

Un motif (pattern) d'expression régulière n'est pas une suite de caractères sans logique ni sens qui lit dans tes pensées ce que tu voudrais trouver dans une chaîne quelconque. Il correspond à des règles de syntaxe.

Si tu demandes de chercher quelque chose qui correspond à un motif qui indique qu'on cherche des mots entre accolades, ça ne risque pas de trouver quoique ce soit dans un texte qui ne comporte aucune accolade, mais des ^^ et des ** à la place Le motif doit être modifié pour chercher des mots entre ^^ et **.

Si tu avais consulté les liens qu'on t'a indiqué dans les autres discussions que tu as ouvertes à ce sujet, tu n'aurais pas eu ce problème. Si certaines formules d'expression régulière peuvent être complexe, celle que tu cites est relativement simple. On cherche un truc entre { } qui correspond à une suite de lettres parmi les lettres non accentuées minuscules et majuscules, les chiffres de 0 à 9, et l'underscore (_) (voir le sens de \w dans la javadoc de la classe Pattern). Et on capture ce truc (les parenthèses), pour pouvoir l'extraire de ce qui a été trouvé (qui contiendra les accolades). Donc maintenant tu dois pouvoir déduire le motif pour chercher un truc entre ^^ et **, au lieu de { et }. Toutefois, tu dois faire attention à l'échappement (l'anti-slash \), mais ça c'est, d'une part la base pour les chaines de caractères en Java, et d'autre part la base quand on ne veut pas que des caractères spéciaux soit traités comme tels. Pour savoir quels sont les caractères spéciaux dans le contexte d'une expression régulière, lire la javadoc de la classe Pattern.

Ensuite, si tu veux faire une méthode qui cherche un truc entre une suite de caractères et une autre suite de caractères, passés en paramètres, genre :

Code :

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

1
2
3
public String[] chercher(String input, String debut, String fin) {
   /* ... */
}

De manière à construire dynamiquement le motif à partir des paramètres debut et fin, il sera difficile d'échapper avec des \, parce que ça t'obligerait à tester tous les caractères pour savoir si c'est un caractère spécial d'expression régulière. Pour faire ça, tu peux t'aider de la méthode quote() de la classe Pattern, qui va échapper toute la chaîne. Il ne reste plus qu'à concaténer les différentes parties pour obtenir un motif adéquat.

[tchize_]

Code :

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

1
2
3
Pattern p = Pattern.compile("\\{(.*?)\\}"); 
 
Pattern.compile("\\^\\^(.*?)\\*\\*");

[khalous91]

Joel drigo j'ai vu ce que vous m'aviez envoyer mais je n'ai pas reussi à appliquer par moi même ...
euh en faite je veux créer un motif qui traite chaque fichiers différents . tu vois en faite je ne veux un motif qui "detecte" en gros { } , ^^ .. ** mais sa auraît pu être ==... !!
Je sais pas si tu me comprends ?

[khalous91]

Code :

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

1
2
3
Pattern p = Pattern.compile("\\{(.*?)\\}"); 
 
Pattern.compile("\\^\\^(.*?)\\*\\*");

merci tchize_, mais j'aimerai comprendre comment tu as fait !
et si jamais ^^ == %% et ** = ))
je n'ai pas envi de revenir a chaque fois modifier ses signes là !! comment pourrais - je faire ? je dois créer une méthode comme m'as dit Joel?

[joel.drigo]

Le mot important dans ce j'ai écrit, c'est "concaténation". Si tu as lu la documentation, tu sais au moins qu'une expression régulière est composée de caractères qui ont une signification : certains ont une signification spéciale (comme {, }, [, ], \W, ], *, +...) et les autres signifient ce qu'ils sont (a veut dire a). Donc tu sais au moins qu'une expression est constituée de sous-expressions.

Si on peut écrire :

Code :

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

Pattern p = Pattern.compile("\\{([\\w]*)\\}");

On peut écrire :

Code :

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

Pattern p = Pattern.compile("\\{" + "([\\w]*)" + "\\}");

N'est-ce pas ?

Donc on peut écrire :

Code :

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

1
2
3
4
 
String avant = "\\{";
String apres = "\\}";
Pattern p = Pattern.compile(debut + "([\\w]*)" + apres);

Tu vois où je veux en venir : avant et après sont devenues variables. Le seul problème qui reste, comme je le disais, c'est l'échappement. Si avant est "{", comme ce caractère a un sens spécial dans une expression (voir documentation), on ne peut pas l'utiliser tel quel. D'où la nécessité de l'échapper, par \, qu'on double comme chaque fois qu'on met un \ dans une chaîne, parce que lui aussi il faut l'échapper, parce que c'est justement le caractère d'échappement (s'il était seul, non doublé, il signifierait "échapper le caractère suivant", et non \).

Le problème c'est que si tu veux que ça fonctionne pour n'importe quoi dans avant et dans après, tu ne peux pas gérer l'échappement, en ajoutant \, parce qu'il faudrait le faire avec des if, qu'il faudrait faire plein de if (vu qu'il y a plein de caractères qui ont un sens spécial dans les expressions régulières (voir documentation)). Pour se sortir de ce problème, on peut échapper automatiquement toute chaîne :

Code :

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

Pattern p = Pattern.compile(Pattern.quote(debut) + "([\\w]*)" + Pattern.quote(apres));

[khalous91]

D'accord ! je comprends mieux là
déjà tu viens de m'apprendre que le \\{ = { et \\} = }
donc le code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
String VALUE_B = "{"; // caractère début 
String VALUE_E = "}"; // caractère de fin 
 
 
		Pattern p = Pattern.compile(Pattern.quote(VALUE_B) + "([\\w]*)" + Pattern.quote(VALUE_E));
 
		Matcher m = p.matcher(texte);
 
		while (m.find()) {
 
		   arrList.add((m.group(1))); // on prend le groupe 1
 
		}

marche bien
Le problème maintenant c'est que si demain j'ai un fichier ( comme le deuxième ) avec un nombre de caractère différents par exemple
String VALUE_B = "^^";
String VALUE_B = "**";
là le motif => "([\\w]*)" ne fonctionne pas ...
après peut être c'est une histoire de antislach à rajouter nan ??

[khalous91]

Ah naan j'ai rien dit ! avec ce code :

Code :

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

Pattern p = Pattern.compile(Pattern.quote(avant ) + "([\\w]*)" + Pattern.quote(après ));

peut importe la valeur des variables avant et après et bah sa fonctionne !!

merci je vais créer un autre fichier là, faire le test et je confirme dans 5min.

[khalous91]

Je confirme ça marche très bien !
merci beaucoup Joel drigo !

[joel.drigo]

Ah naan j'ai rien dit ! avec ce code :

Code :

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

Pattern p = Pattern.compile(Pattern.quote(avant ) + "([\\w]*)" + Pattern.quote(après ));

peut importe la valeur des variables avant et après et bah sa fonctionne !!

merci je vais créer un autre fichier là, faire le test et je confirme dans 5min.

Attention, cette solution a des limites. Attention, par exemple, à la signification de \w, qui correspond à :

• les lettres de a à z
• les lettres de A à Z
• les chiffres
• l'underscore _

Ou, par exemple, si tu veux chercher les trucs compris entre a et b dans "abonjourbatoib", tu vas obtenir en l’occurrence "bonjourbatoi", et non pas "bonjour" et "toi". En modifiant un peu, on pourrait obtenir facilement "" et "toi", aussi, donc pas ce qu'on veut.

[tchize_]

mouais si tes délimiteurs sont dynamiques, je ne passerais même pas par une expression régulière, c'est de l'overkill. J'utiliserais simplement String.indexOf(int,String), qui permet de trouver le délimiteur suivant. Au moins, si ton délimiteur est __ ou AZZAZAAZ ça marche toujours.