Discussion :

[bapi777]

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

[joel.drigo]

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 :

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

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
 
}

[bapi777]

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

Code bsh :

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

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

[joel.drigo]

J'aurais fait (en Java) :

Code :

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

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 :

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

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 :

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

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 :

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

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"

[bapi777]

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 :

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
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 %

[joel.drigo]

Ok, alors on pourrait faire comme ça :

Code :

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

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 :

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

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 :

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
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();
       }
    }
}