Utiliser une regex en Java

Version imprimable

23/09/2016, 17h15
bapi777

Utiliser une regex en Java

bonjour
j'ai un texte qui se tient en 1 ligne que je peux decouper avec cette regex
/Chapitre\s+?(\d+).+?participant \s+"(\w+).+?(?=Chapitre)/g

Mais je ne sais pas comment sortir les infos

chapitre 1 : nestor
chapitre 2 : robert
chapitre 3 : arthur
etc...

Ma problematique je l'ai expose la
http://www.developpez.net/forums/d16...x/#post8750296

j'ai reuni mon texte dans une ligne en supprimant les sauts de ligne, mais maintenant je ne sais pas exploiter la regex dans le programme java.
pourriez vous m'aider?

Cdt

Salut,

La base du traitement d'expressions régulières en Java se fait par la classe Pattern. Il y a une méthode de simplification qui permet de découper une chaîne sur une expression régulière qui représente un séparateur (String.split()), mais ça ne semble pas être le cas au vu de ton expression régulière.

Ensuite le principe est simple pour parcourir les éléments qui correspondent au motif :
Code:

1 2 3 4 5 6 7 Matcher matcher = Pattern.compile(regex).matcher(texte); while( matcher.find() ) { System.out.println(matcher.group()); // affiche l'élément principal qui correspond (s'il y a d'autres groupes de capture, on peut les afficher séparément }

bonjour
j'utilise beanshell pour faire le test et ca me donne rien alors que la regex trouve bien 2 occurences sur notepad++

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
2.0b4 - by Pat Niemeyer (pat@pat.net)
bsh % import java.util.regex.*;
bsh % import java.util.regex.Matcher;
bsh % import java.util.regex.Pattern;
bsh % str="chapitre 1 \nd\n bcd\nefg\ntoto participant \"arthur\"\nchapitre 2  \nd\n bcd\nefg\ntoto participant \"nestor\"\nchapitre 3";
bsh % Matcher matcher = Pattern.compile("chapitre\\s+?(\\d+)[\\s\\S]+?participant\\s+\"(\\S+)\".+?(?=chapitre)").matcher(str); 
bsh % while( matcher.find() ) {
 
   System.out.println(matcher.group()); // affiche l'élément principal qui correspond (s'il y a d'autres groupes de capture, on peut les afficher séparément
 
};
bsh % bsh % 
bsh %

auriez vous une idee?
Cdt

J'aurais fait (en Java) :

Code:

1
2
3
4
5
6
7
8
9
10
11
Matcher matcher = Pattern.compile("(chapitre\\s+\\d+\\s?)(?:[^\"]*)(\"\\S+\")?").matcher(str);
while (matcher.find()) {
 
    for(int i=1; i<=matcher.groupCount();i++) {
        if ( matcher.group(i)!=null ) {
             System.out.print(matcher.group(i)); 
        }
    }
    System.out.println(); 
 
}

Ce qui donne :

chapitre 1 "arthur"
chapitre 2 "nestor"
chapitre 3

Si on fait :

Code:

1
2
3
4
5
6
Matcher matcher = Pattern.compile("(chapitre\\s+\\d+\\s?)(?:[^\"]*)(\"\\S+\")?").matcher(str);
while (matcher.find()) {
 
   System.out.println(matcher.group()); 
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
chapitre 1 
d
 bcd
efg
toto participant "arthur"
chapitre 2 
d
 bcd
efg
toto participant "nestor"
chapitre 3

Et oui : on affiche tout ce qui matche (donc ce qui se trouve entre chapitre et participant (peu importe que le groupe soit capturant ou pas).

Maintenant si le (?=chapitre) que tu as mis à la fin de l'expression à pour but de ne pas sélectionner les chapitres sans auteur, on peut faire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
Matcher matcher = Pattern.compile("(chapitre\\s+\\d+\\s)[\\s\\S]+?participant\\s+(\"\\S+\")")
		.matcher(str);
 
 
		while (matcher.find()) {
 
		    for(int i=1; i<=matcher.groupCount();i++) {
		        if ( matcher.group(i)!=null ) {
		             System.out.print(matcher.group(i)); 
		        }
		    }
		    System.out.println(); 
		}

Donnant :

chapitre 1 "arthur"
chapitre 2 "nestor"

desolé mais peut-etre sur l'environnement beanshell, il y a des choses a retoucher, car ca ne marche pas. Je ne sais pas si les erreurs vont vous parler?
sinon dans votre expression ([^\"]*) vous excluez les guillemets jusqu'au participant, mais il peut y avoir des guillemets, il peut meme y avoir des "/" dans les autres lignes donc ca ne peut pas le faire dans tous les cas.

En tout cas, merci de votre grande aide. Moi et les expressions regulieres ca fait 2.

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
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
bsh % bsh % 
bsh % 
bsh % Matcher matcher = Pattern.compile("(chapitre\\s+\\d+\\s?)(?:[^\"]*)(\"\\S+\")?").matcher(str);
bsh % 
bsh % 
bsh % while (matcher.find()) {
 
    for(int i=1; i<=matcher.groupCount();i++) {
        if ( matcher.group(i)!=null ) {
             System.out.print(matcher.group(i)); 
        }
    }
    System.out.println(); 
 
}
bsh % 
bsh % 
bsh % 
bsh % printBannerint
 
bsh % 
bsh % 
bsh % print
 
bsh % 
bsh % print *
 
// Error: Parser Error: Parse error at line 1, column 8713.  Encountered: ;
bsh % print str
;
// Error: EvalError: Typed variable declaration : Class: print not found in namespace : at Line: 1 : in file: <unknown file> : print 
 
bsh % print;
bsh % 
bsh % while (matcher.find()) {
 
    for(int i=1; i<=matcher.groupCount();i++) {
        if ( matcher.group(i)!=null ) {
             System.out.print(matcher.group(i)); 
        }
    }
    System.out.println(); 
 
}
bsh % 
bsh % while (matcher.find()) {
 
    for(int i=1; i<=matcher.groupCount();i++) {
        if ( matcher.group(i)!=null ) {
             print(matcher.group(i)); 
        }
    }
 
 
}
bsh % 
bsh % 
bsh % 
bsh % 
bsh % while (matcher.find()) {
 
    for(int i=1; i<=matcher.groupCount();i++) {
        if ( matcher.group(i)!=null ) {
             print(matcher.group(i)); 
        }
    }
 
 
};
bsh % bsh % 
bsh % 
bsh % 
bsh % 
bsh % 
bsh % print (µ
matcher.group(i^C
matcher.group(i^C
// Error: Parser Error: Parse error at line 1, column 3661.  Encountered: (
bsh % print (matcher.group(1));
// Error: // Uncaught Exception: Method Invocation matcher.group : at Line: 1 : in file: <unknown file> : matcher .group ( 1 ) 
 
Target exception: java.lang.IllegalStateException: No match found
 
bsh % java.lang.IllegalStateException: No match found
	at java.util.regex.Matcher.group(Unknown Source)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at bsh.Reflect.invokeMethod(Unknown Source)
	at bsh.Reflect.invokeObjectMethod(Unknown Source)
	at bsh.Name.invokeMethod(Unknown Source)
	at bsh.BSHMethodInvocation.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHArguments.getArguments(Unknown Source)
	at bsh.BSHMethodInvocation.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.Interpreter.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)
 
bsh % print (matcher.group(2));
// Error: // Uncaught Exception: Method Invocation matcher.group : at Line: 1 : in file: <unknown file> : matcher .group ( 2 ) 
 
Target exception: java.lang.IllegalStateException: No match found
 
bsh % java.lang.IllegalStateException: No match found
	at java.util.regex.Matcher.group(Unknown Source)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at bsh.Reflect.invokeMethod(Unknown Source)
	at bsh.Reflect.invokeObjectMethod(Unknown Source)
	at bsh.Name.invokeMethod(Unknown Source)
	at bsh.BSHMethodInvocation.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHArguments.getArguments(Unknown Source)
	at bsh.BSHMethodInvocation.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.Interpreter.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)
 
bsh % 
bsh % 
bsh % Matcher matcher = Pattern.compile("(chapitre\\s+\\d+\\s?)(?:[^\"]*)(\"\\S+\")?").matcher(str);
bsh % print (matcher.group(2));
// Error: // Uncaught Exception: Method Invocation matcher.group : at Line: 1 : in file: <unknown file> : matcher .group ( 2 ) 
 
Target exception: java.lang.IllegalStateException: No match found
 
bsh % java.lang.IllegalStateException: No match found
	at java.util.regex.Matcher.group(Unknown Source)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at bsh.Reflect.invokeMethod(Unknown Source)
	at bsh.Reflect.invokeObjectMethod(Unknown Source)
	at bsh.Name.invokeMethod(Unknown Source)
	at bsh.BSHMethodInvocation.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHArguments.getArguments(Unknown Source)
	at bsh.BSHMethodInvocation.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.Interpreter.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)
 
bsh % print (matcher.group(0));
// Error: // Uncaught Exception: Method Invocation matcher.group : at Line: 1 : in file: <unknown file> : matcher .group ( 0 ) 
 
Target exception: java.lang.IllegalStateException: No match found
 
bsh % java.lang.IllegalStateException: No match found
	at java.util.regex.Matcher.group(Unknown Source)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at bsh.Reflect.invokeMethod(Unknown Source)
	at bsh.Reflect.invokeObjectMethod(Unknown Source)
	at bsh.Name.invokeMethod(Unknown Source)
	at bsh.BSHMethodInvocation.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHArguments.getArguments(Unknown Source)
	at bsh.BSHMethodInvocation.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.BSHPrimaryExpression.eval(Unknown Source)
	at bsh.Interpreter.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)
 
bsh % print str;
// Error: EvalError: Typed variable declaration : Class: print not found in namespace : at Line: 1 : in file: <unknown file> : print 
 
bsh % print (str);
chapitre 1 d  bcd efg toto participant "arthur" chapitre 2   d  bcd
efg toto participant "nestor" chapitre 3
bsh %

Ok, alors on pourrait faire comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
Matcher matcher = Pattern.compile("(chapitre\\s+\\d+?\\s?)((?:[\\s\\S]*?)(?:participant\\s*)(\".+\"))?").matcher(str);
while (matcher.find()) {
 
   for(int i=1; i<=matcher.groupCount();i+=2) {
      if ( matcher.group(i)!=null ) {
	 System.out.print(matcher.group(i)); 
      }
   }
   System.out.println(); 
 
}

Mais ça commence à faire bidouille... Les expressions régulières, ce n'est pas la panacée, et lorsque la syntaxe à parser devient complexe, on passe par un parser, ou alors on utilise un parcourt par rechercher/manipulation d'index (ou encore un automate à état). Quelque chose comme ça, par exemple, en se simplifiant le parsing avec un Scanner :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Scanner scanner = new Scanner(new StringReader(str));
while( scanner.hasNext()) {
   String next = scanner.next();
   if ( "chapitre".equals(next) ) {
      if ( scanner.hasNextInt() ) {
	  int chapitre = scanner.nextInt();
	  System.out.print("chapitre "+chapitre);
	  while( scanner.hasNext() && !"participant".equals(scanner.next()));
	  if ( scanner.hasNext() ) {
	     System.out.print(" "+scanner.next());
	 }
	 System.out.println();
     } 
  }
}

Ou si ton motif se répète encore après :

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
Pattern chapPattern = Pattern.compile("chapitre");
Pattern partPattern = Pattern.compile("participant");
Scanner scanner = new Scanner(new StringReader(str));
while( scanner.hasNext()) {
   String next = scanner.next();
   if ( "chapitre".equals(next) ) {
       if ( scanner.hasNextInt() ) {
	   int chapitre = scanner.nextInt();
	   System.out.print("chapitre "+chapitre);
	   while( scanner.hasNext() && !scanner.hasNext(partPattern) ) {
	       if ( scanner.hasNext(chapPattern) ) {
	          break;
	       }
	       scanner.next();
           }
           if ( scanner.hasNext(partPattern) ) {
	       scanner.next();
	       if ( scanner.hasNext() ) {
	           System.out.print(" "+scanner.next());
               }
           }
           System.out.println();
       }
    }
}

29/09/2016, 01h49
CosmoKnacki

Est-ce que dans la vrai vie "chapitre" est toujours en début de ligne, et est-ce que chaque chapitre a toujours un participant?

Car dans ce cas, moi j'écrirai plutôt:

Code:

Matcher m = Pattern.compile("(?m)^chapitre\\s+(\\d+)\\W+(?>\\w+\\W+)*?participant\\s+\"([^\"]+)\".*\\n(?>.*\\n?)*?(?=^chapitre\\s|\\z)").matcher(str);

Au lieu de supporter un quantificateur non-gourmand pour chaque caractère avec [\\s\\S]*?, en utilisant (?>\\w+\\W+)*?, je saute de mot en mot, et avec (?>.*\\n?)*? de ligne en ligne, ce qui est déjà plus rapide (vue qu'on évite bon nombre de tests.)

À noter au passage qu'un word-boundary n'est pas nécessaire avant "participant" vu qu'il ne peut être précédé que par un caractère de la classe \W.
30/09/2016, 01h57
bapi777

bonsoir
La vous m'avez tué!
trop beau cette expression. je m'arrete a ca ... participant\\s+\"([^\"]+)\" car je n'ai pas besoin des infos qui suivent. Mais ca a l'air de parfaitement repondre au besoin, je confirmerai. faut que je la decortique car la je comprends pas tout :)
mais pour ma culture que dit la suite?
.*\\n(?>.*\\n?)*?(?=^chapitre\\s|\\z)

Merci a tous pour votre aide.

sinon chapitre est bien en premiere colonne mais pas participant. Mais bon le plus compliqué etait de gerer les sauts de mot en mot et eviter de s'arreter a d'autres guillemet que ceux du participant.

La partie .*\\n(?>.*\\n?)*?(?=^chapitre\\s|\\z) sert juste à aller jusqu'à la fin du chapitre.
Code:

1 2 3 .*\\n # finit la ligne "participant" (?>.*\\n?)*? # ajoute des lignes jusqu à ce que le test avant soit vérifié (?=^chapitre\\s|\\z) # test avant: suivi de "chapitre " en début de ligne ou suivi par la fin de la chaîne (\z)
D'ailleurs à mieux y réfléchir autant remplacer ce passage par (?>.*\\n?)+?(?=chapitre\\s|\\z) ce qui est plus court, plus efficace et produit le même résultat. Donc:

Code:

Matcher m = Pattern.compile("(?m)^chapitre\\s+(\\d+)\\W+(?>\\w+\\W+)*?participant\\s+\"([^\"]+)\"(?>.*\\n?)+?(?=chapitre\\s|\\z)").matcher(str);

ou si tu n'as pas besoin du contenu du chapitre:

Code:

Matcher m = Pattern.compile("(?m)^chapitre\\s+(\\d+)\\W+(?>\\w+\\W+)*?participant\\s+\"([^\"]+)\"").matcher(str);

30/09/2016, 18h12
bapi777

re,
j'ai oublie de préciser qu'avec la fin de la regex ca ne marchait pas. donc quelque chose clochait a la fin de la regex. et par ailleurs, si au lieu de mettre [^"] je mets le nom du participant, la regex ne fait plus ce qu'il faut a savoir me prendre chaque chapitre. Elle prend du premier chapitre trouvé jusqu'au nom de participant saisi dans la regex.
Dernier point : si un champ participant est manquant dans un chapitre, ca foire aussi, il passe à travers ce chapitre sans s’arrêter, mais comme c'est c'est la fin de la regex qui est supposée gérer la fin du chapitre c'est donc la fin de la regex qui est à revoir.
J'imagine que si les groupes "capturés" par la regex se croisent, ca va pas le faire non plus?
En tout cas, merci de votre aide, ca me couvre déjà presque tout, et j'étais en train de faire autrement.
Cdt
30/09/2016, 21h07
CosmoKnacki
Citation:

Envoyé par bapi777

j'ai oublie de préciser qu'avec la fin de la regex ca ne marchait pas. donc quelque chose clochait a la fin de la regex.

Je l'ai testé sur l'exemple que tu as donné dans l'autre topic, avec l'outil que tu utilises (bsh) et ça fonctionne. Si de ton coté ça ne fonctionne pas c'est que l'exemple que tu as donnée n'est pas représentatif de tes données réelles.

Citation:

Envoyé par bapi777

et par ailleurs, si au lieu de mettre [^"] je mets le nom du participant, la regex ne fait plus ce qu'il faut

Évidemment si tu modifies un élément de la pattern au petit bonheur la chance, faut pas s'attendre à un miracle.

Citation:

Envoyé par bapi777

si un champ participant est manquant dans un chapitre, ca foire aussi

C'était le sens de ma question dans mon post précédant à laquelle tu n'as pas répondu:

Citation:

Envoyé par CosmocKnacki

...et est-ce que chaque chapitre a toujours un participant?

Pardonne moi si je semble un peu âpre, mais je trouve hallucinant qu'au bout de 8 jours, 2 topics et 22 messages, absolument personne n'ait une idée précise de ce à quoi ressemblent vraiment tes données, et, à lire ton dernier message, je dois avouer que la compréhension que j'avais de ta question initiale et de ton objectif commence à vaciller.

Donc j'espère que, pour fêter le 24e message tu fourniras:
- un extrait significatif de tes données réelles (où on voit bien leur aspect général mais aussi les cas particuliers qui pourrait-être problématiques)
- ce que tu veux en extraire et sous quel forme précise en conformité avec l'extrait que tu as donné.
- une confirmation quant au langage que tu veux utiliser pour y parvenir.
Le tout en utilisant les moyens de formatage révolutionnaires mis à ta disposition par ce forum.

(Accessoirement, ajouter un retour sur l'approche qu'a proposée joel drigo pourrait sauver une âme égarée sur ce topic des griffes du Diable.)

Merci d'avance.
01/10/2016, 13h08
bapi777

bonjour
un peu rude en effet.
Je vous remercie et je vais m'arreter la, j'aime pas me prendre la tete pour des broutilles.
Je n'ai pas le droit de communiquer les donnees reelles.
J'ai essaye de donner le plus de precisions possibles pour que vous ne perdiez pas votre temps. Je ne crois pas que l'agression soit constructive.
Bonne journee