Rechercher un string entre des guillemets (Expression régulière)

Bonjour,

Je voudrais créer une expression régulière qui rechercherait un String entre deux guillemets par exemple:

Code:

---

1 2	String string = "Trouve moi \"ça\"";

---

je veux que l'expression régulière me renvoie la chaine "ça" tout en sachant qu'il peut y avoir plusieurs guillemets dans ma chaine par exemple:

Code:

---

1 2	String string = "Trouve moi \"ça\" et \"ça aussi\" ainsi que \"ça\""; :ccool:

---

et du coup elle me les récupère dans un tableau ou un a un ? comment? je n'ai pas de réponse :roll:

Je vous remercie d'avance pour votre aide.

Bonjour

Est ce bien ce que tu veux ?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

import java.util.ArrayList; import java.util.Scanner;     public class Requetes{   public static void main(String[] args) {   ArrayList<String> array= new ArrayList<String>(); String regex= "\"[^\"]*\""; String expr= "Trouve moi \"ça\" et \"ça aussi\" ainsi que \"ça\"";   Scanner scan= new Scanner(expr); String find= scan.findInLine(regex);   while(find != null) { System.out.println("Element: " + find); array.add(find); find= scan.findInLine(regex); } } }

---

EDIT: oups avait pas vu pour l'ajout dans un tableau

Bonjour,

Je vous remercie pour votre réponse mais moi je ne veux pas qu'il m'affiche les guillemets car c'est des délimiteurs c'est tout.

Merci d'avance.

Bonjour,

il te faudra en plus utiliser la méthode substring() pour enlever les "".

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

import java.util.*;   public class Requetes{   public static void main(String[] args) {   ArrayList<String> array= new ArrayList<String>(); String regex= "\"[^\"]*\""; String expr= "Trouve moi \"ça\" et \"ça aussi\" ainsi que \"ça\"";   Scanner scan= new Scanner(expr); String find= scan.findInLine(regex);   while(find != null) { find = find.substring(1,find.length()-1); System.out.println("Element: " + find); array.add(find); find= scan.findInLine(regex); } } }

---

Merci beaucoup à vous deux pour votre aide 8-)

Auriez vous un cours qui explique comment créer des expressions régulières ?. Comme ça je ne vous dérangerai plus avec mes questions basiques.

Merci d'avance

Une petite idée me vient à l'esprit :

Code:

---

1 2 3 4

String valeurInitiale = "Je voudrais trouver\"ceci\" ainsi que \"cela\" et aussi \"ça\" pourquoi pas"; String[] decoupe = valeurInitiale.split("\""); System.out.println("Résultat :"); for (int i = 1 ; i < decoupe.length ; i+=2) System.out.println(decoupe[i]);

---

Ca me semble beaucoup plus simple comme solution...8O

Ah, j'oubliais ! Vous pouvez consulter ce lien, c'est lui qui m'a tout appris sur les expressions régulières :
http://imss-www.upmf-grenoble.fr/pre...egulieres.html

Merci pour ton aide.

Si je voulais par exemple la chaîne qui est entre un ( et un ) que peut on mettre ?

Merci

Et non, il faut chercher un peu.
Le paramètre a fournir à la méthode java.lang.String.split(String regex) n'est autre qu'une expression régulière.
Donc la réponse à votre question tient dans l'écriture d'une expression régulière permettant de trouver le caractère "(" ou le caractère ")". Une fois l'expression régulière au point, il suffit de la mettre en lieu et place des caractères rouges de la ligne suivante :

Code:

---

String[] decoupe = valeurInitiale.split("\"");

---

Mon problème est que je n'arrive pas à faire la bonne expression régulière

Bonjour

Attention, la solution avec le split ne fonctionne pas.

La chaine :

Code:

---

String chaine="un seul\"guillemet"

---

"guillemet" n'est pas entre guillemets mais sera traitée comme telle avec la solution split.

Pour les éléments entre parenthèses, il faut être plus précis. Que doit-on trouver dans la chaine : "j'ai (plein (de (parenthèses) par) exemple)" ?

Yann

Entre les parenthèses on pourrait trouver du XML ou des guillemets ça dépend du paramètre reçu.

Mais quand je reçois du XML il n y aura pas de guillemets.

PS: Il se pourrait qu'il y est des parenthèse dans le XML ça ne gène pas ?

Merci pour votre aide.

Je me permettrai simplement d'ajouter que je me suis contenté de répondre à la question initiale qui sous-entend qu'il y a toujours deux termes, guillemets ou parenthèse. Sans quoi, je n'aurai pas proposé cette solution, il es évident qu'elle est très spécifique. Mais si la condition initiale est respectée, à savoir, il y a toujours au moins deux termes ou 2xn termes, alors ça fonctionne très bien, et c'est deux cents fois plus simple.
Mais je ne suis pas assez calé en expression régulière, et de toute évidence, vos besoins vont au-delà que de retrouver des mots entre guillemets ou parenthèses.
Bon courage..:ccool:

En fait j'ai trouvé d'ou vient mon problème avec les parenthèses, c'est parce que c'est des caractère spéciaux pour les expressions régulières, comment les despécialiser dans mon code ? par exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

String regex = "([^\"]*)"; String expr = "insert(<ma balise> <secondeone> </secondeone></mabalise>)";   </mabalise>)";   Scanner scan= new Scanner(expr); String find= scan.findInLine(regex);   while(find != null) { find = find.substring(1,find.length()-1); System.out.println("Element: " + find); array.add(find); find= scan.findInLine(regex); }

---

Dans le code ci-dessus je voudrais récupérer le contenu de la parenthèse précédé d'un insert. Comment pourrais je faire SVP ?

Bonjour,

essayer cela :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

import java.util.*;   public class Requetes{   public static void main(String[] args) {   ArrayList<String> array= new ArrayList<String>(); String regex= "[(][^)(]*[)]"; String expr= "Trouve (moi (ça) et (ça aussi)) ainsi que (ça)";   Scanner scan= new Scanner(expr); String find= scan.findInLine(regex);   while(find != null) { find = find.substring(1,find.length()-1); System.out.println("Element: " + find); array.add(find); find= scan.findInLine(regex); } } }

---

Encore mieux :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

import java.util.*;   public class Requetes{   public static void main(String[] args) {   ArrayList<String> array= new ArrayList<String>(); String regex= "[insert(][^)(]*[)]"; String expr= "insert(<ma balise> <secondeone> </secondeone></mabalise>)";   Scanner scan= new Scanner(expr); String find= scan.findInLine(regex);   while(find != null) { find = find.substring(7,find.length()-1); System.out.println("Element: " + find); array.add(find); find= scan.findInLine(regex); } } }

---

Merci beaucoup pour ce retour mais si j'ai une parenthèse par exemple à l’intérieur de ce que je cherche il me la ramène elle et il ne me ramène pas la chaine que je cherche:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

import java.util.*;   public class Requetes{   public static void main(String[] args) {   ArrayList<String> array= new ArrayList<String>(); String regex= "[(][^)(]*[)]"; String expr= "insert(<ma balise> <secondeone>(Je ne veux pas de ça) </secondeone></mabalise>)";   Scanner scan= new Scanner(expr); String find= scan.findInLine(regex);   while(find != null) { find = find.substring(1,find.length()-1); System.out.println("Element: " + find); array.add(find); find= scan.findInLine(regex); } } }

---

dans ce cas il va me ramener "Je ne veux pas de ça" alors que moi je voudrais qu'il ramène "<ma balise> <secondeone>(Je ne veux pas de ça) </secondeone></mabalise>"

Merci d'avance pour votre aide

Re,

Partant du principe que nous n'arrivons pas à créer cette expression régulière, il faut trouver une astuce. Je propose :

-1- est ce que dans

insert(<ma balise> <secondeone>(Je ne veux pas de ça) </secondeone></mabalise>)

la dernière paranthèse ne sera-t-elle pas toujours précédée de >???? Ou au moins quand la ligne commence par insert????

si c'est le cas je propose :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

import java.util.*;   public class Requetes{   public static void main(String[] args) {   ArrayList<String> array= new ArrayList<String>(); //String regex= "[insert(][^)(]*[)]"; String regex= "[insert(].*[>)]"; String expr= "insert(<ma balise> <secondeone>(coucou) </secondeone></mabalise>)";   Scanner scan= new Scanner(expr); String find= scan.findInLine(regex);   while(find != null) { find = find.substring(7,find.length()-1); System.out.println("Element: " + find); array.add(find); find= scan.findInLine(regex); } } }

---

Votre réponse est bonne ;) mais en testant avec cet exemple

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

import java.util.*;   public class Requetes{   public static void main(String[] args) {   ArrayList<String> array= new ArrayList<String>(); String regex= "[insert(].*[>)]"; String expr= "test(\"1234\").insert(<ma balise> <secondeone>(coucou) </secondeone></mabalise>)";   Scanner scan= new Scanner(expr); String find= scan.findInLine(regex);   while(find != null) { find = find.substring(7,find.length()-1); System.out.println("Element: " + find); array.add(find); find= scan.findInLine(regex); } } }

---

le résultat obtenu est le suivant:

Code:

---

est("1234").insert(<ma balise> <secondeone>(coucou) </secondeone></mabalise>

---

et non pas:

Code:

---

<ma balise> <secondeone>(coucou) </secondeone></mabalise>

---

Re

et pourquoi vouloir à tout prix utiliser une expression régulière ???

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

import java.util.*;   public class Requetes{   public static void main(String[] args) {   ArrayList<String> array= new ArrayList<String>(); String expr= "test(\"1234\").insert(<ma balise> <secondeone>(coucou) </secondeone></mabalise>)"; int debut = expr.indexOf("insert") +7; int fin = expr.length()-1;     String find= expr.substring(debut,fin); System.out.println(find);   } }

---

Je voudrais utiliser les expressions régulières car j'ai plusieurs cas à tester pas que l'insert :cry: ...

du coup mon idée était de chercher par exemple tout ce qu'il y a entre parenthèse après le mot insert ou après un quelconque mot.

PS: Je n'ai pas forcément le:

Code:

---

int fin = expr.length()-1;

---

si par exemple je cherche ce qu'il y a à l'intérieur de test:

Code:

---

String expr= "test(\"1234\").insert(<ma balise> <secondeone>(coucou) </secondeone></mabalise>)";

---

Bonsoir

Pour les mots entre parenthèses celle regex peut faire l'affaire !

Code:

---

String regex= "\\([^\\)\\(]+\\)";

---

et pour récupérer le mot c'est comme ludomacho a fait tout a l'heure

Code:

---

1 2	String find= scan.findInLine(regex); find = find.substring(1,find.length()-1);

---

Merci beaucoup pour votre aide.

J'ai eu pleins de surprises en testant si vous relisez l'ensemble du post vous allez mieux comprendre mon problème.

Merci pour votre aide.

Oui désolé j'ai pas vu tout le post :oops:
c'est ce que tu veux obtenir ?

Code:

---

"<ma balise> <secondeone>(Je ne veux pas de ça) </secondeone></mabalise>"

---

oui svp tout en sachant que je pourrait avoir des expression comme celle ci:

Code:

---

String expr= "test(\"1234\").insert(<ma balise> <secondeone>(coucou) </secondeone></mabalise>)";

---

du coup dans ce cas je veux qu'il me retourne que ce qu'il y entre les parenthèses qui sont juste après l'insert.

D'accord je planche dessus, je fais des tests :)
.....
....
quelque neurones brûlés plus tard............

et avec ça ?

Code:

---

String regex= "\\(<.*>\\)|\\([^\\)\\(]+\\)";

---

Bonjour,

AU risque d'être lourd j'insiste en proposant une solution qui fonctionne sans expression régulière :

L'idée est de chercher le dernier ( et le premier ) qui suit le dernier (.

On trouve alors un resultat. On remplace les () de ce résultat par autrechose dans une chaine intermediaire et on recommence.

On obtient alors toute les souschaines entourées par des ().

Mais on ne veut pas celles qui sont comprises dans d'autres () donc on fait un test pour les enlever.

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

import java.util.*; import java.awt.*;   public class Requetes{   public static void main(String[] args) {   ArrayList<String> array = new ArrayList<String>(); ArrayList<Point> indices = new ArrayList<Point>(); String expr = "test(\"1234\").insert(<ma balise> <secondeone>(coucou) </secondeone></mabalise>)"; String exprTemp = expr; //debut de la méthode int temp1 = exprTemp.lastIndexOf("("); int temp2; while(temp1>0) { System.out.println(temp1); temp2 = exprTemp.indexOf(")",temp1); if (indices.size()>0) { for (int j=0; j< indices.size();j++) { if ( temp1 < indices.get(j).x && temp2 > indices.get(j).y ) { indices.remove(j); array.remove(j); } } } array.add(expr.substring(temp1+1,temp2)); indices.add(new Point(temp1,temp2)); exprTemp = exprTemp.substring(0,temp1) + " " + exprTemp.substring(temp1+1,temp2) + " " + exprTemp.substring(temp2+1,expr.length()); temp1 = exprTemp.lastIndexOf("("); } //fin de la methode for (int i=0;i<array.size();i++) { System.out.println(array.get(i)); } } }

---

Pour votre gouverne, pour déspécialiser le caractère "(" dans votre expression régulière, il faut le faire précéder de 2 caractères "\" !

Ce qui pour votre expression citée plus haut donnerait :

Code:

---

String expr= "test\\(\"1234\"\\).insert(<ma balise> <secondeone>\\(coucou\\) </secondeone></mabalise>)";

---

Pour les expressions régulières, c'est aussi le caractère "\" qui permet d'échapper l'interprétation des caractères spécialisés.;)