Discussion :

[shirya]

bonjour, j'Essaie de savoir si un string que je lis correspond à une méthode et je veux le faire avec les expression régulière(même si je n'y connais rien).
Exemple la ligne public String Méhode()..j'ai essayé ça [^private|public|protected\s][w*\s][\w*][\(]...mais ça ne marche pas
quelqu'u pourrait-il m'aider..ou me donner un tutoriel qui donnerais des exemples
merci
shirya

[shirya]

rebonjour
voici ce que j'ai trouvé
public|private|protected\s+[\w]*\s*[\w]+\s*[\(]+

seulement, il accepte les ligne du genre:

public type nomMethode

pourtant je voudrais que ça n'accepte pas les ligne qui ne contiennent pas de "("....à la fin de ma regex, je fais \(+...mais il accepte quand même les ligne sans parenthèse...pouvez vous m'aider
merci

[CyberChouan]

Tu es sûr que tu parles d'une expression régulière java?

Normalement, celle ques tu nous donnes dans tes deux posts précédents n'ont pas dû être acceptées par le compilateur (il faut doubler les '\')

[le y@m's]

Si tu veux faire une une expression régulière représentant la signature d'une méthode elle ne sera pas aussi simple.
En effet il faut penser qu'un type peut être indiqué avec son package (cf "java.lang.String"), il peut y avoir des tableaux dans les paramètres
(ou même une ellipse), les noms doivent commencer par une lettre mais peuvent contenir des chiffres ou des '_', etc

Par exemple voici une telle expression régulière (attention, elle pique les yeux ) :

\s*(((static)|(synchronized)|(native))\s+)*\s*(((public)|(protected)|(private))\s+)?(((static)|(synchronized)|(native))\s+)*\s*(\p{Alpha}(_|\p{Alnum})*(\.\p{Alpha}(_|\p{Alnum})*)*)?\s+\p{Alpha}(_|\p{Alnum})*\s*\(\s*((\p{Alpha}(_|\p{Alnum})*(\.\p{Alpha}(_|\p{Alnum})*)*((\s*(\[\])\s*)|(\s+))\p{Alpha}(_|\p{Alnum})*\s*(,\s*\p{Alpha}(_|\p{Alnum})*(\.\p{Alpha}(_|\p{Alnum})*)*((\s*(\[\])\s*)|(\s+))\p{Alpha}(_|\p{Alnum})*)*(\s*,\s*\p{Alpha}(_|\p{Alnum})*(\.\p{Alpha}(_|\p{Alnum})*)*((\s*((\.\.\.)|(\[\]))\s*)|(\s+))\p{Alpha}(_|\p{Alnum})*\s*)?)|(\p{Alpha}(_|\p{Alnum})*(\.\p{Alpha}(_|\p{Alnum})*)*((\s*((\.\.\.)|(\[\]))\s*)|(\s+))\p{Alpha}(_|\p{Alnum})*))?\s*\)\s*

Pour faire un peu moins bourrin, voici un code construisant cette expression régulière en découpant les différentes partie la composant.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
String name = "\\p{Alpha}(_|\\p{Alnum})*";
String fullname = name + "(\\." + name + ")*";
String visibilityRegex = "(public)|(protected)|(private)";
String modifiersRegex = "(static)|(synchronized)|(native)";
String returnTypeRegex = "(" + fullname + ")?";
String argRegex = fullname + "((\\s*(\\[\\])\\s*)|(\\s+))" + name;
String varArgRegex = fullname + "((\\s*((\\.\\.\\.)|(\\[\\]))\\s*)|(\\s+))" + name;
String argsRegex = "(" + argRegex + "\\s*(,\\s*" + argRegex + ")*(\\s*,\\s*" + 
                varArgRegex + "\\s*)?)|(" + varArgRegex + ")";
 
String methodRegex = "\\s*((" + modifiersRegex + ")\\s+)*\\s*((" + visibilityRegex + 
                ")\\s+)?((" + modifiersRegex + ")\\s+)*\\s*" + returnTypeRegex +
                "\\s+" + name + "\\s*\\(\\s*(" + argsRegex + ")?\\s*\\)\\s*";

Cette expression régulière reste cependant imparfaite, notamment au niveau des "modifieurs" (static, native, synchronized) qui,
contrairement à ce que permet cette expression, ne peuvent être présent qu'une seule fois chacun et sont interdit pour les constructeurs.

PS : désolé pour la déformation du forum

[shirya]

merci pour la réponse
au fait le y@m's , tu m'as arraché 4.29 kg de chair.
bye