
Java fournit le paquetage java.util.regex pour la correspondance de modèles avec des expressions régulières. Les expressions régulières de Java sont très semblables au langage de programmation Perl et très facile à apprendre.
Une expression régulière est une séquence spéciale de caractères qui vous aide à faire correspondre ou à trouver d'autres chaînes ou ensembles de chaînes, en utilisant une syntaxe spécialisée détenue dans un motif. Ils peuvent être utilisés pour rechercher, éditer ou manipuler du texte et des données.
Le package java.util.regex se compose principalement des trois classes suivantes:
Les groupes de capture sont un moyen de traiter plusieurs caractères comme une seule unité. Ils sont créés en plaçant les caractères à regrouper dans un ensemble de parenthèses. Par exemple, l'expression régulière (dog) crée un seul groupe contenant les lettres "d", "o" et "g".
Les groupes de capture sont numérotés en comptant leurs parenthèses d'ouverture de gauche à droite. Dans l'expression ((A) (B (C))), par exemple, il existe quatre groupes de ce type:
Pour savoir combien de groupes sont présents dans l'expression, appelez la méthode groupCount sur un objet matché. La méthode groupCount renvoie un entier montrant le nombre de groupes de capture présents dans le modèle matché.
Il existe également un groupe spécial, le groupe 0, qui représente toujours l'expression entière. Ce groupe n'est pas inclus dans le nombre renvoyé par la méthode groupCount.
Exemple:
L'exemple suivant illustre comment trouver une chaîne de chiffres à partir de la chaîne alphanumérique donnée:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
public static void main( String args[] ){
// String to be scanned to find the pattern.
String line = "This order was placed for QT3000! OK?";
String pattern = "(.*)(\\d+)(.*)";
// Create a Pattern object
Pattern r = Pattern.compile(pattern);
// Now create matcher object.
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
System.out.println("Found value: " + m.group(2) );
} else {
System.out.println("NO MATCH");
}
}
}
Cela produirait le résultat suivant:
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0
Voici le tableau répertoriant la syntaxe métacaractrique d'expression régulière disponible en Java:
Sous-expression |
Matches |
^ |
Correspond au début de la ligne. |
$ |
Correspond à la fin de la ligne. |
. |
Correspond à un seul caractère, à l'exception de la nouvelle ligne. L'utilisation de l'option m permet de faire correspondre la nouvelle ligne. |
[...] |
Correspond à un seul caractère entre parenthèses. |
[^...] |
Correspond à un seul caractère qui n'est pas entre parenthèses |
\A |
Début de la chaîne entière |
\z |
Fin de chaîne entière |
\Z |
Fin de chaîne entière, sauf terminaison de ligne finale admissible. |
re* |
Correspond à 0 ou plus des occurrences de l'expression précédente. |
re+ |
Correspond à 1 ou plus occurrence de l'expression précédente |
re? |
Correspond à 0 ou 1 occurrence de l'expression précédente. |
re{n} |
Correspond exactement au n nombre d'occurrences de l'expression précédente. |
re{n,} |
Correspond à n ou plusieurs occurrences de l'expression précédente. |
re{n, m} |
Correspond à au moins n et au plus m occurrences de l'expression précédente. |
A | B |
Correspond à un A ou à un B. |
(re) |
Groupes d'expressions régulières et rappelle le texte apparié. |
(?:re) |
Groupes d’expressions régulières sans se souvenir du texte apparié. |
(?>re) |
Correspond à un schéma indépendant sans retour en arrière. |
\w |
Correspond à des mots. |
\W |
Correspond aux caractères non-mots. |
\s |
Correspond à l'espace blanc. Equivalent à [\ t \ n \ r \ f]. |
\S |
Correspond à l’espace non blanc . |
\d |
Correspond à des chiffres. Equivalent à [0-9]. |
\D |
Correspond à des non chiffres. |
\A |
Correspond au début de la chaîne. |
\Z |
Correspond à la fin de la chaîne. Si une nouvelle ligne existe, elle correspond juste avant la nouvelle ligne. |
\z |
Correspond à la fin de la chaîne. |
\G |
Les matchs indiquent le dernier match terminé. |
\n |
Renvoi vers le numéro de groupe de capture "n" |
\b |
Correspond aux limites des mots lorsque les parenthèses extérieures. Correspond à l'arrière (0x08) dans les parenthèses entre parenthèses. |
\B |
Correspond aux limites de non-mots. |
\n, \t, etc. |
Correspond aux nouvelles lignes, retours chariot, tabulation, etc. |
\Q |
Escape (quote) tous les caractères jusqu'à \E |
\E |
Fin de quote commençant par \Q |
Voici une liste de méthodes d'instance utiles:
Les méthodes d'index fournissent des valeurs d'index utiles qui montrent précisément l'endroit où la correspondance a été trouvée dans la chaîne d'entrée:
SN |
Méthodes avec description |
1 |
public int start() |
2 |
public int start(int group) |
3 |
public int end() |
4 |
public int end(int group) |
Les méthodes d'étude examinent la chaîne de saisie et renvoient un booléen indiquant si le motif est ou non trouvé:
SN |
Méthodes avec description |
1 |
public boolean lookingAt() |
2 |
public boolean find() |
3 |
public boolean find(int start) |
4 |
public boolean matches() |
Les méthodes de remplacement sont des méthodes utiles pour remplacer le texte dans une chaîne d'entrée:
SN |
Méthodes avec description |
1 |
public Matcher appendReplacement(StringBuffer sb, String replacement) |
2 |
public StringBuffer appendTail(StringBuffer sb) |
3 |
public String replaceAll(String replacement) |
4 |
public String replaceFirst(String replacement) |
5 |
public static String quoteReplacement(String s) Renvoie une chaîne de remplacement littérale pour la chaîne spécifiée. Cette méthode produit une chaîne qui fonctionnera comme un remplacement littéral dans la méthode AppendReplacement de la classe Matcher. |
Voici l'exemple qui compte le nombre de fois que le mot "cats" apparaît dans la chaîne d'entrée:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static final String REGEX = "\\bcat\\b";
private static final String INPUT = "cat cat cat cattie cat";
public static void main( String args[] ){
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // get a matcher object
int count = 0;
while(m.find()){
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}
Cela produirait le résultat suivant:
Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22
Vous pouvez voir que cet exemple utilise des limites de mots pour s'assurer que les lettres "c" "a" "t" ne sont pas seulement une sous-chaîne dans un mot plus long. Il fournit également des informations utiles sur l'endroit où la chaîne d'entrée a eu lieu.
La méthode start renvoie l'indice de début de la sous-séquence capturé par le groupe donné lors de l'opération de correspondance précédente, et la méthode end renvoie l'indice du dernier caractère apparié, plus un.
Les méthodes matches et lookingAt tentent toutes deux d'associer une séquence d'entrée à un modèle. La différence, cependant, est que les correspondances exigent que la séquence d'entrée entière soit adaptée, alors que lookingAt ne l'est pas.
Les deux méthodes commencent toujours au début de la chaîne de saisie. Voici l'exemple expliquant les fonctionnalités:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static final String REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
private static Pattern pattern;
private static Matcher matcher;
public static void main( String args[] ){
pattern = Pattern.compile(REGEX);
matcher = pattern.matcher(INPUT);
System.out.println("Current REGEX is: "+REGEX);
System.out.println("Current INPUT is: "+INPUT);
System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}
Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false
Les méthodes replaceFirst et replaceAll remplacent le texte qui correspond à une expression régulière donnée. Comme leur nom l'indique, replaceFirst remplace la première occurrence, et replaceAll remplace toutes les occurrences.
Voici l'exemple expliquant les fonctionnalités:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static String REGEX = "dog";
private static String INPUT = "The dog says meow. " +
"All dogs say meow.";
private static String REPLACE = "cat";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}
Cela produirait le résultat suivant:
The cat says meow. All cats say meow.
La classe Matcher fournit également des méthodes appendReplacement et appendTail pour le remplacement du texte.
Voici l'exemple expliquant les fonctionnalités:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoob";
private static String REPLACE = "-";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}
Cela produirait le résultat suivant:
-foo-foo-foo-
Une exception PatternSyntaxException est une exception non vérifiée qui indique une erreur de syntaxe dans un modèle d'expression régulière. La classe PatternSyntaxException fournit les méthodes suivantes pour vous aider à déterminer ce qui a mal tourné:
SN |
Méthodes avec description |
1 |
public String getDescription() |
2 |
public int getIndex() |
3 |
public String getPattern() |
4 |
public String getMessage() |