Discussion :

[jmini]

Bonjour,

Je me posais la question suivantes à propos des expressions régulière (regex) :
Est il possible de contrôler le nombre d'accolade ouverte et fermée { et } pour lors d'un match :

En fait je cherche à récupérer l'accolade fermante correspondante à une accolade ouvrante que je connais :

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
Ici {
   et au milieu { un certain nombre }
   d accolades {
       { inconue
             }
       et aussi imbriquées
   }
   avec un nombre inconu à l avance {
       pas facile { ? }
   }
}
 
Par contre {
   le schéma continue {
      de la meme {  }
      manière
   }
   en dessous
}

L'idée est de pouvoir détecter Ici { jusqu'à l'accolade correspondante : } (ligne 11)


Nb: cette question n'est pas vraiment purement Java... Mais je n'ai pas trouvé de Forum spécialisé regex...

.

[jmini]

Ce que j'ai réussi à faire :

Récupérer toute les structures qui ne contiennent pas d'autres accolades :

Code :

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

1
2
Pattern pattern;
pattern = Pattern.compile("\\{[^\\{\\}]*\\}");

Donne :

Code :

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

{ un certain nombre }

Code :

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

1
2
{ inconue
      }

Code :

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

{ ? }

Code :

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

{  }

Après j'ai fait pleins d'essais du genre chercher { ... } .. } ou { .. { .. }

[Uther]

C'est typiquement le genre de problème pour lesquels tu ne pourras pas t'en sortir avec les expression régulières car elle ne savent pas gérer les structures récursives.
Le mieux que tu puisse faire avec des regexp est de te limiter a n niveaux de profondeur. Par exemple :
2 niveaux:

Code :

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

1
2
3
4
(?s)
\{
	(\{.*?\}|.)
*?\}

3 niveaux:

Code :

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

1
2
3
4
5
6
(?s)
\{
	(\{
		(\{.*?\}|.)
	*?\}|.)
*?\}

4 niveaux:

Code :

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

1
2
3
4
5
6
7
8
9
(?s)
\{
	(\{
		(\{
 
			(\{.*?\}|.)
		*?\}|.)
	*?\}|.)
*?\}

Ces exemples sont indentés pour être lisible, mais il faut bien sur enlever l'indentation et doubler les '\' si tu les utilises dans une chaine de caractères.


Si tu veux faire ça proprement, il va te falloir parser le texte toi même ; c'est pas très complexe.
Il te faut lire la chaine caractère par caractère. Tu incrémentes un compteur quand tu rencontres '{' et décrémentes quand tu rencontres '}'. Quand le compteur reviens a 0 c'est que c'est trouvé.

[hibour]

Oui il n'y a aucune expression régulière qui détecte des expressions de la forme anbn (comme aaabbb), il faut utiliser une pile d'où le compteur comme l'a bien précisé Uther

[jmini]

Ok merci...

Voici pour ceux que cela intéresse une solution avec un compteur :
(j'utilise quand même les regex pour ne pas lire le String en entier, mais c'est la même idée)

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
/**
 * Look for the next closing curly brackets after a given position
 * Closing curly brackets coming after opening curly brackets are ignored
 * @param s source string
 * @param afterPos the starting position
 * @return the position of the char just after the } or -1 if not found
 */
public static int findClose(String s, int afterPos) {
	Pattern pOpen, pClose;
	Matcher mOpen, mClose;
	int res, posOpen, posClose, counter;
 
	res = -1;
	posClose = afterPos;
	posOpen = afterPos;
	counter = 0;
 
	pOpen = Pattern.compile("\\{");
	mOpen = pOpen.matcher(s);
	pClose = Pattern.compile("\\}");
	mClose = pClose.matcher(s);
 
	while(counter >= 0 && mClose.find(posClose)) {
		while(mOpen.find(posOpen) && mOpen.start() < mClose.start()) {
			posOpen = mOpen.end();
			counter = counter +1;
		}
 
		posClose = mClose.end();
		counter = counter -1;
	}
	if(counter < 0) {
		res = posClose;
	}
	return res;
}

Utilisation du code :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
String s;
int i;
//Avec s correspondant au string dans mon premier post
i = findClose(s, 5); //5 parce que c'est la position apres "Ici {"
if (i > 0) {
	System.out.println(s.substring(0, i)); // 0 parce que c'est la position de debut de "Ici {"
} else {
	System.out.println("Not found");
}

Pour 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
String s = "";
s += "Ici {\n";
s += "   et au milieu { un certain nombre }\n";
s += "   d accolades {\n";
s += "      { inconue\n";
s += "      }\n";
s += "   et aussi imbriquées\n";
s += "   }\n";
s += "   avec un nombre inconu à l avance {\n";
s += "      pas facile { ? }\n";
s += "   }\n";
s += "}\n";
s += "\n";
s += "Par contre {\n";
s += "   le schéma continue {\n";
s += "   de la meme {  }\n";
s += "      manière\n";
s += "   }\n";
s += "   en dessous\n";
s += "}\n";