Java - Expressions Régulières
Bienvenue, aspirants programmeurs Java !aujourd'hui, nous plongeons dans le monde fascinant des Expressions Régulières (Regex) en Java. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; je vais vous guider à travers ce voyage étape par étape, tout comme j'ai fait pour d'innombrables étudiants au fil des années. Alors, prenez un café, et partons ensemble dans cette aventure passionnante !
Qu'est-ce qu'une Expression Régulière ?
Avant de nous plonger dans l'implémentation spécifique à Java, comprenons ce qu'ont sont les Expressions Régulières. Imaginez-vous en tant que détective essayant de trouver un motif spécifique dans un océan de texte. C'est exactement ce que fait Regex – c'est un outil puissant pour le matching de motifs et la manipulation de chaînes de caractères.
Classes d'Expressions Régulières Java
Java fournit un package appelé java.util.regex qui contient plusieurs classes pour travailler avec les expressions régulières. Les trois classes principales sur lesquelles nous allons nous concentrer sont :
- Pattern
- Matcher
- PatternSyntaxException
Voyons chacune de ces classes en détail.
Classe Pattern
La classe Pattern représente une représentation compilée d'une expression régulière. Pensez-y comme le plan pour votre travail de détective en matching de motifs.
import java.util.regex.Pattern;
public class ExemplePattern {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("Bonjour");
System.out.println("Pattern créé : " + pattern);
}
}Dans cet exemple, nous créons un motif simple qui correspond au mot "Bonjour". La méthode compile() prend l'expression régulière sous forme de chaîne et retourne un objet Pattern.
Classe Matcher
C'est dans la classe Matcher que se produit la véritable magie. Elle effectue des opérations de correspondance sur une séquence de caractères en fonction d'un Pattern.
import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class ExempleMatcher {
public static void main(String[] args) {
String texte = "Bonjour, Monde ! Bonjour, Java !";
Pattern pattern = Pattern.compile("Bonjour");
Matcher matcher = pattern.matcher(texte);
while (matcher.find()) {
System.out.println("Correspondance trouvée à l'index : " + matcher.start());
}
}
}Ce code recherche le motif "Bonjour" dans le texte donné et imprime l'index de départ de chaque correspondance. C'est comme si notre détective trouvait toutes les occurrences d'une piste dans un document !
Syntaxe des Expressions Régulières
Maintenant, apprenons une syntaxe de base pour créer des motifs plus complexes. Voici un tableau des métacaractères couramment utilisés :
| Métacaractère | Description |
|---|---|
| . | Correspond à n'importe quel caractère unique |
| ^ | Correspond au début de la ligne |
| $ | Correspond à la fin de la ligne |
| * | Correspond à zéro ou plusieurs occurrences |
| + | Correspond à une ou plusieurs occurrences |
| ? | Correspond à zéro ou une occurrence |
| \d | Correspond à un chiffre |
| \s | Correspond à un caractère d'espacement |
| \w | Correspond à un caractère de mot (lettre, chiffre ou tiret bas) |
Voyons certains de ces métacaractères en action :
public class ExempleSyntaxeRegex {
public static void main(String[] args) {
String texte = "Le rapide brown fox saute par-dessus le chien paresseux";
// Correspond aux mots commençant par 'q'
Pattern pattern1 = Pattern.compile("\\bq\\w+");
Matcher matcher1 = pattern1.matcher(texte);
if (matcher1.find()) {
System.out.println("Mot commençant par 'q' : " + matcher1.group());
}
// Correspond aux mots se terminant par 'g'
Pattern pattern2 = Pattern.compile("\\w+g\\b");
Matcher matcher2 = pattern2.matcher(texte);
if (matcher2.find()) {
System.out.println("Mot se terminant par 'g' : " + matcher2.group());
}
}
}Dans cet exemple, nous utilisons \b pour correspondre aux limites de mots, \w+ pour correspondre à un ou plusieurs caractères de mot, et les combinons avec 'q' et 'g' pour trouver des mots commençant par 'q' et se terminant par 'g' respectivement.
Groupes Capturants dans les Expressions Régulières
Les groupes capturants permettent de traiter plusieurs caractères comme une seule unité. Ils sont créés en plaçant les caractères à regrouper entre parenthèses.
public class ExempleGroupesCapturants {
public static void main(String[] args) {
String texte = "John Doe ([email protected])";
Pattern pattern = Pattern.compile("(\\w+)\\s(\\w+)\\s\\((\\w+@\\w+\\.\\w+)\\)");
Matcher matcher = pattern.matcher(texte);
if (matcher.find()) {
System.out.println("Prénom : " + matcher.group(1));
System.out.println("Nom : " + matcher.group(2));
System.out.println("Email : " + matcher.group(3));
}
}
}Dans cet exemple, nous extrayons le prénom, le nom et l'adresse email d'une personne d'une chaîne. Les parenthèses dans le motif créent des groupes capturants, que nous pouvons accéder à l'aide de matcher.group(n).
Méthodes de la Classe Matcher
La classe Matcher fournit plusieurs méthodes utiles. Voici algumas des plus couramment utilisées :
| Méthode | Description |
|---|---|
| find() | Trouve la prochaine correspondance pour le motif |
| group() | Retourne le sous-chaîne correspondant |
| start() | Retourne l'index de début de la correspondance |
| end() | Retourne l'index de fin de la correspondance |
| matches() | Vérifie si la chaîne entière correspond au motif |
Voyons ces méthodes en action :
public class ExempleMéthodesMatcher {
public static void main(String[] args) {
String texte = "La pluie en Espagne tombe principalement sur le plat";
Pattern pattern = Pattern.compile("\\b\\w+ain\\b");
Matcher matcher = pattern.matcher(texte);
while (matcher.find()) {
System.out.println("Trouvé : " + matcher.group());
System.out.println("Index de début : " + matcher.start());
System.out.println("Index de fin : " + matcher.end());
}
}
}Ce code trouve tous les mots se terminant par "ain" et imprime chaque correspondance ainsi que ses indices de début et de fin.
Méthodes de Remplacement des Expressions Régulières
Les expressions régulières ne sont pas seulement utiles pour trouver des motifs ; elles sont également excellentes pour remplacer du texte. La classe Matcher fournit des méthodes à cet effet :
public class ExempleRemplacement {
public static void main(String[] args) {
String texte = "Le rapide brown fox saute par-dessus le chien paresseux";
Pattern pattern = Pattern.compile("fox|chien");
Matcher matcher = pattern.matcher(texte);
String résultat = matcher.replaceAll("animal");
System.out.println("Après remplacement : " + résultat);
}
}Dans cet exemple, nous remplaçons à la fois "fox" et "chien" par "animal". La méthode replaceAll() fait tout le travail difficile pour nous !
Classe PatternSyntaxException
Parfois, nous pouvons faire des erreurs en écrivant nos expressions régulières. C'est là que la classe PatternSyntaxException devient pratique. Elle est lancée pour indiquer une erreur de syntaxe dans un motif d'expression régulière.
public class ExemplePatternSyntaxException {
public static void main(String[] args) {
try {
Pattern.compile("["); // Regex invalide
} catch (PatternSyntaxException e) {
System.out.println("Exception de syntaxe de motif : " + e.getMessage());
System.out.println("Index de l'erreur : " + e.getIndex());
}
}
}Ce code utilise délibérément une regex invalide pour démontrer comment PatternSyntaxException fonctionne. C'est comme avoir un correcteur intégré pour vos expressions régulières !
Et voilà, camarades ! Nous avons fait un tour dans le pays des Expressions Régulières Java, des motifs de base aux remplacements complexes. N'oubliez pas, comme tout outil puissant, regex devient plus utile à mesure que vous pratiquez. Alors, n'hésitez pas à expérimenter et à créer vos propres motifs. Qui sait ? Vous pourriez bien devenir le Sherlock Holmes du matching de motifs !
Bonne programmation, et que vos chaînes correspondent toujours à vos attentes !
Credits: Image by storyset