Problème avec regexp

Version imprimable

Voir 40 message(s) de cette discussion en une page

Salut alors voila , je veux extraire une partie de mon texte en utilisant l'API regex mais j'ai un petit peu de mal!
texte à traiter :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#bzert
#polipolipoli 
#sdfgldhfsg_85465ffdgdfgf
#sdfsdf-988898_iuujsdf
 
bnv 111
 
#----------------------------------------------------------------------
#
# Variables
#----------------------------------------------------------------------
#> hfghjhgjgh
Non ! Ne pars pas je t'en prie. Reste s'il te plait. Je me suis comporté comme une idiote, pardonne moi. Non laisse-moi finir s'il te plait. Hier quand tu m'as avoué tes sentiments j'ai pris peur, non parce que je ne ressentais pas la même chose mais parce que j'avais peur de souffrir. J'ai peur de laisser mon bonheur être tes mains. Tu serais le seul responsable de sa destruction si un jour tu décides de t'en aller et je ne veux pas devenir dépendante de quelqu'un.
#>dfgdfgdfgdfgdf
#----------------------------------------------------------------------
# Variables
#----------------------------------------------------------------------
tyjtyjy
 
#----------------------------------------------------------------------
# Repertoires
#----------------------------------------------------------------------
*  
endif

en faite je veux recuperer ce qu'il y a avant #< et ce qu'il y a après #>

j'ai penser a utiliser sa :

Code:

1
2
3
4
5
 String texte="fichierCSH.txt";
		 Pattern p=Pattern.compile("");
		 Matcher m=p.matcher(texte);
		 while(m.find()) 
		    System.out.println(m.group(1));

mais je ne sais pas quoi mettre dans le pattern p au niveau du motif

help me please :)

18/05/2015, 11h06
khalous91
J'ai pensé à mettre ça pour commencer :
Code:

1 2 3 4 5 String texte="fichierCSH.txt"; Pattern p=Pattern.compile("^#bzert, #>$"); Matcher m=p.matcher(texte); while(m.find()) System.out.println(m.group(1));
^#!/bin/csh -xv, #>$ => ma chaîne commence par #bzert avec le (^) et se termine par #> avec le (&)

ça pourraît être bon nan?
18/05/2015, 11h21
eulbobo

Comme on dit, "j'avais un problème, et j'ai essayé de le résoudre avec une expression régulière... Maintenant j'ai deux problèmes..."

Essayes avec ça :
"#<(.*)#>"

Sachant que ça ne marchera pas avec ton test actuel vu qu'il n'y a PAS de #<

Et non, ton exemple ne marchera pas et fera une erreur à l'exécution : quand tu appelles m.group(x), il faut que tu aies défini un "groupe de capture" : ce que tu mets en parenthèses (sachant que quand tu ne mets rien, ça fait le groupe 0)

Salut eulbobo

peut tu m'expliquer le ""#<(.*)#>" stp ?

Code:

Sachant que ça ne marchera pas avec ton test actuel vu qu'il n'y a PAS de #<

Oups ! désolè j'avais même pas fais gaff

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#bzert
#polipolipoli 
#sdfgldhfsg_85465ffdgdfgf
#sdfsdf-988898_iuujsdf
 
bnv 111
 
#----------------------------------------------------------------------
#
# Variables
#----------------------------------------------------------------------
#< hfghjhgjgh
Non ! Ne pars pas je t'en prie. Reste s'il te plait. Je me suis comporté comme une idiote, pardonne moi. Non laisse-moi finir s'il te plait. Hier quand tu m'as avoué tes sentiments j'ai pris peur, non parce que je ne ressentais pas la même chose mais parce que j'avais peur de souffrir. J'ai peur de laisser mon bonheur être tes mains. Tu serais le seul responsable de sa destruction si un jour tu décides de t'en aller et je ne veux pas devenir dépendante de quelqu'un.
#>dfgdfgdfgdfgdf
#----------------------------------------------------------------------
# Variables
#----------------------------------------------------------------------
tyjtyjy
 
#----------------------------------------------------------------------
# Repertoires
#----------------------------------------------------------------------
*  
endif

Là c'est mieux

18/05/2015, 11h31
eulbobo

#<(.*)#>

Ca se lit "tu cherches la suite de caractères "#<"n ensuite il y a (dans un groupe de capture) : .*, à savoir n'importe quel caractère 0 à n fois, jusqu'à ce qu'on tombe sur la suite de caractères "#>"

Et ensuite, tu lis ce qu'il y a dans les parenthèses (le groupe de capture 1)

Et du coup je me rends compte que tu veux ce qu'il y a AVANT #< et apres #>, et pas ce qu'il y a entre les deux...
Du coup ça répond pas à ta question

Essayes avec : "^(.*)#<.*#>(.*)$"
Puis fais un m.group(1) pour récupérer le début, et m.group(2) pour récupérer la fin
18/05/2015, 11h33
khalous91

Citation:

"#<(.*)#>"

en faite là ce motif récupère ce qu'il y a entre #< et #> ( je viens de faire le text )

moi je veux le contraire je veux récuperer ce qu'il y a avant le #< et ce qu'il y a après le #> .
pour ensuite concatener mon nouveau texte que je placerai a place de ce qu'il y a entre le #< et #>.
18/05/2015, 11h35
khalous91

Citation:

Et du coup je me rends compte que tu veux ce qu'il y a AVANT #< et apres #>, et pas ce qu'il y a entre les deux...
Du coup ça répond pas à ta question

oui lol mais pas grave c'est bon à savoir ! j'en aurai surement besoin un jour...
18/05/2015, 11h37
eulbobo

J'étais en train d'éditer quand je m'en suis rendu compte ^^

Essayes avec : "^(.*)#<.*#>(.*)$"
Puis fais un m.group(1) pour récupérer le début, et m.group(2) pour récupérer la fin

D'accord ! merci eulbobo

juste deux question :
tu peux me réexpliquer le : ^(.*)#<.*#>(.*)$

2eme question :
mon code affiche pas le groupe 2 :

code :

Code:

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
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
public class ClasseTest {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
		 String texte=
							"#polipolipoli" +
							"#sdfgldhfsg_85465ffdgdfgf"+
							"#sdfsdf-988898_iuujsdf"+
 
							"bnv 111"+
 
							"#----------------------------------------------------------------------"+
							"#"+
							"# Variables"+
							"#----------------------------------------------------------------------"+
							"#< hfghjhgjgh"+
							"Non ! Ne pars pas je t'en prie. Reste s'il te plait. Je me suis comporté comme une idiote, pardonne moi. Non laisse-moi finir s'il te plait. Hier quand tu m'as avoué tes sentiments j'ai pris peur, non parce que je ne ressentais pas la même chose mais parce que j'avais peur de souffrir. J'ai peur de laisser mon bonheur être tes mains. Tu serais le seul responsable de sa destruction si un jour tu décides de t'en aller et je ne veux pas devenir dépendante de quelqu'un."+
							"#>dfgdfgdfgdfgdf"+
							"#----------------------------------------------------------------------"+
							"# Variables"+
							"#----------------------------------------------------------------------"+
							"tyjtyjy"+
 
							"#----------------------------------------------------------------------"+
							"# Repertoires"+
							"#----------------------------------------------------------------------"+
							"*  "+
							"endif;";
 
 
 
		 Pattern p=Pattern.compile("^(.*)#<.*#>(.*)$");
		 Matcher m=p.matcher(texte);
		 while(m.find()) 
		    System.out.println(m.group(1));
		 	System.out.println(m.group(2));
 
	}
 
}

pourtant j'ai fais comme tu m'as dit, j'ai mis un group 2

J'ai le même code chez moi, sauf dans la boucle :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
Pattern pat = Pattern.compile( "^(.*)#<.*#>(.*)$");
		Matcher m = pat.matcher(texte);
 
		while (m.find()){
			System.out.println("DEBUT");
			System.out.println(m.group(1));
			System.out.println("MID");
			System.out.println(m.group(2));
 
		}

Ca m'affiche ça :

Code:

1
2
3
4
5
 
DEBUT
#polipolipoli#sdfgldhfsg_85465ffdgdfgf#sdfsdf-988898_iuujsdfbnv 111#----------------------------------------------------------------------## Variables#----------------------------------------------------------------------
MID
dfgdfgdfgdfgdf#----------------------------------------------------------------------# Variables#----------------------------------------------------------------------tyjtyjy#----------------------------------------------------------------------# Repertoires#----------------------------------------------------------------------*  endif;

Donc je pense que ça marche ^^

Ok, j'ai vu le problème dans ton code : il manque des parenthèses !
Mets TOUJOURS des parenthèses !

18/05/2015, 11h56
khalous91

Parfait !!

merci beaucoup eulbobo ;) c'est gentil !

dis moi juste! si je veux couper ce que j'ai entre #< et #> et remplacer tout cette chaine de caractère par : " salut je m'appelle richard et j'aile le foot " comment puis-je faire tu as une idée ?

De la manière la plus simple possible : prendre le début, ajouter ce que tu veux ajouter, ajouter la fin !
Code:

1 2 3 4 5 6 7 8 9 10 Pattern pat = Pattern.compile( "^(.*)#<.*#>(.*)$"); Matcher m = pat.matcher(texte); StringBuilder sb = new StringBuilder(); while (m.find()){ sb.append(m.group(1)); sb.append(" salut je m'appelle richard et j'aile le foot "); sb.append(m.group(2)); }
Sinon, ça doit être faisable autrement, mais je pense pour le coup que la concaténation de chaîne ira plus vite (et sera plus lisible et facile à comprendre)

18/05/2015, 12h11
khalous91

Citation:

Sinon, ça doit être faisable autrement, mais je pense pour le coup que la concaténation de chaîne ira plus vite (et sera plus lisible et facile à comprendre)

Oui j'ai pensé à faire sa c'est plus simple tu as raison :)

merci beaucoup eulbobo tu m'as bien aidé
thinks ;)
18/05/2015, 14h40
CosmoKnacki

Pour séparer une chaîne en deux parties (ou plusieurs) la méthode à utiliser n'est pas find mais split. split permet de décrire la sous-chaîne qui sert de séparateur entre les sous-chaînes qui t'intéressent, ce qui dans les cas où le délimiteur est facilement descriptible (comme le tien) simplifie grandement le problème et la pattern à utiliser (celà dit dans certain cas c'est le contraire et utiliser find s'avère dés fois bien plus pratique).

Code:

String[] parts = texte.split("(?s)#<.*?#>", 2)

Si on se retrouve à décrire une chaîne du début à la fin dans ce cas la méthode appropriée n'est pas find mais matches qui ne réussie que quand l'intégralité de la chaîne est décrite par la pattern (il est d'ailleurs inutile avec cette méthode d'ajouter des ancres ^ et $ (ou \\A et \\z) à la pattern car celles-ci sont implicites.

Maintenant puisque ton but est d'effectuer un remplacement dans une chaîne, et en partant du principe qu'il n'y a qu'une seule occurrence à remplacer, la méthode à utiliser est replaceFirst:

Code:

texte = texte.replaceFirst("(?s)#<.*?#>", " salut je m'appelle Richard et j'aime le foot ");

Le point par défaut correspond à n'importe quel caractère sauf le caractère \n (line feed), (?s) permet de lever cette restriction.

*? est un quantificateur non-gourmand, c'est à dire qu'il s'arrêtera à la première occurrence de #> car pour chaque caractère ajouté, il teste s'il est suivi de #>. Par défaut * est quant à lui gourmand, ce qui fait qu'il va prendre tout ce qui est possible et ensuite il devra reculer caractère par caractère, jusqu'à ce qu'il soit suivi de #>. Dans le cas de ton texte d'exemple, le quantificateur non-gourmand semble plus approprié (car moins de trajet à faire). Cela dit, si la partie que tu souhaites remplacer ne contient pas d'autres #, la pattern #<[^#]*#> est un bonne alternative ([^#] = tout caractère sauf #) car elle évite bon nombre de tests inutiles.

Salut CosmoKnacki

Merci pour ton aide et tes renseignements.
J'ai essayer ta méthode mais sa ne marche pas ...

code :

Code:

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
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
public class ClasseTest {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
		String texte = 	
				"#bzert"+
				"#polipolipoli"+ 
				"#sdfgldhfsg_85465ffdgdfgf"+
				"#sdfsdf-988898_iuujsdf"+
 
				"bnv 111"+
 
				"#----------------------------------------------------------------------"+
				"#"+
				"# Variables"+
				"#----------------------------------------------------------------------"+
				"#> hfghjhgjgh"+
				"Non ! Ne pars pas je t'en prie. Reste s'il te plait. Je me suis comporté comme une idiote, pardonne moi. Non laisse-moi finir s'il te plait. Hier quand tu m'as avoué tes sentiments j'ai pris peur, non parce que je ne ressentais pas la même chose mais parce que j'avais peur de souffrir. J'ai peur de laisser mon bonheur être tes mains. Tu serais le seul responsable de sa destruction si un jour tu décides de t'en aller et je ne veux pas devenir dépendante de quelqu'un."+
				"#<dfgdfgdfgdfgdf"+
				"#----------------------------------------------------------------------"+
				"# Variables"+
				"#----------------------------------------------------------------------"+
				"yjtyjy"+
 
				"#----------------------------------------------------------------------"+
				"# Repertoires"+
				"#----------------------------------------------------------------------"+
				"*  "+
				"endif";
 
 
		String[] parts = texte.split("(?s)#>.*?#<", 2);
		texte = texte.replaceFirst("(?s)#<.*?#>", " NONONONONONONON ");
 
		System.out.println(texte);
 
 
	}
}

le but c'est de remplacer la chaîne de caractère qu'il y a entre entre #> et #< par une autre chaine de caractère.
tout en garde ce qu'il y a avant #> et après #<...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
		String rpl = " salut je m'appelle Richard et j'aime le foot ";
 
		Pattern pat = Pattern.compile( "^(.*)#<.*#>(.*)$");
		Matcher m = pat.matcher(texte);
		while (m.find()){
			System.out.println(m.group(1) + rpl + m.group(2));
		}
 
		System.out.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
		String[] parts = texte.split("(?s)#<.*?#>", 2);
		System.out.println(parts[0] + rpl + parts[1]);
 
		System.out.println("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
		texte = texte.replaceFirst("(?s)#<.*?#>", rpl);
		System.out.println(texte);

Chez moi les trois méthodes donnent le même résultat.
Ce que j'aime avec les expressions régulières, c'est qu'il n'y a jamais une seule bonne réponse :p

eulbobo
si jamais je veux faire appel au texte mais depuis le fichier windows, comment dois je faire comme ceci ?

code :

Code:

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
 
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
public class ClasseTest {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
		try{
		InputStream flux=new FileInputStream("fichierX.txt"); 
		InputStreamReader lecture=new InputStreamReader(flux);
		BufferedReader buff=new BufferedReader(lecture);
		String ligne;
		while ((ligne=buff.readLine())!=null){
			System.out.println(ligne);
		}
		buff.close(); 
		}		
		catch (Exception e){
		System.out.println(e.toString());
		}	
 
 
 
		Pattern pat = Pattern.compile( "^(.*)#<.*#>(.*)$");
				Matcher m = pat.matcher(flux);
 
				while (m.find()){
					System.out.println("DEBUT");
					System.out.println(m.group(1));
					System.out.println("MID");
					System.out.println(m.group(2));
 
				}
 
 
	}
}

en gros mon String texte se trouve dans mon fichier fichierXtxt.

18/05/2015, 15h15
khalous91

J'ai un probleme au niveau de mon matcher m !
la variable flux ne veut pas être lu... pourtant ça correspond au fichier que l'on veut traiter ..
18/05/2015, 15h28
CosmoKnacki

Soit tu utilises la méthode split et tu fais une concaténation avec un stringBuilder, soit tu utilises replaceFirst mais pas les deux à la fois!

En faite le problème c'est au niveau de la lecture du fichier d'origine !

1er cas :

code :

Code:

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
 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
public class ClasseTest {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
		String texte = 	"#bzert"+
				"#polipolipoli"+ 
				"#sdfgldhfsg_85465ffdgdfgf"+
				"#sdfsdf-988898_iuujsdf"+
 
				"bnv 111"+
 
				"#----------------------------------------------------------------------"+
				"#"+
				"# Variables"+
				"#----------------------------------------------------------------------"+
				"#> hfghjhgjgh"+
				"Non ! Ne pars pas je t'en prie. Reste s'il te plait. Je me suis comporté comme une idiote, pardonne moi. Non laisse-moi finir s'il te plait. Hier quand tu m'as avoué tes sentiments j'ai pris peur, non parce que je ne ressentais pas la même chose mais parce que j'avais peur de souffrir. J'ai peur de laisser mon bonheur être tes mains. Tu serais le seul responsable de sa destruction si un jour tu décides de t'en aller et je ne veux pas devenir dépendante de quelqu'un."+
				"#<dfgdfgdfgdfgdf"+
				"#----------------------------------------------------------------------"+
				"# Variables"+
				"#----------------------------------------------------------------------"+
				"yjtyjy"+
 
				"#----------------------------------------------------------------------"+
				"# Repertoires"+
				"#----------------------------------------------------------------------"+
				"*  "+
				"endif";
		Pattern pat = Pattern.compile( "^(.*)#<.*#>(.*)$");
			Matcher m = pat.matcher(texte);
				while (m.find()){
					System.out.println("DEBUT");
					System.out.println(m.group(1));
					System.out.println("MID");
					System.out.println(m.group(2));
 
				}
 
 
	}
}

=> celui là il marche

par contre dans le 2eme cas :

code :

Code:

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
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
public class ClasseTest {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 // lecture du fichierCSH
		String texte = "fichierCSH.txt";
 
		try{
		// Création du flux bufférisé sur un FileReader, immédiatement suivi par un 
		// try/finally, ce qui permet de ne fermer le flux QUE s'il le reader
		// est correctement instancié (évite les NullPointerException)
		BufferedReader buff = new BufferedReader(new FileReader(texte));
 
		try {
		String line;
		// Lecture du fichier ligne par ligne. Cette boucle se termine
		// quand la méthode retourne la valeur null.
		while ((line = buff.readLine()) != null) {
		System.out.println(line);
		}
		} finally {
		// dans tous les cas, on ferme nos flux
		buff.close();
		}
		} catch (IOException ioe) {
		// erreur de fermeture des flux
		System.out.println("Erreur --" + ioe.toString());
		}
 
 
		Pattern pat = Pattern.compile( "^(.*)#<.*#>(.*)$");
			Matcher m = pat.matcher(texte);
				while (m.find()){
					System.out.println("DEBUT");
					System.out.println(m.group(1));
					System.out.println("MID");
					System.out.println(m.group(2));
 
				}
 
 
	}
}

=> Ca ne marche pas, le pattern ne fnctionne pas :/

Voir 40 message(s) de cette discussion en une page