Que sont les expressions régulières en Java?
En Java , Regex ou Regular Expression est une interface de programme d'application qui aide à définir un modèle afin de rechercher, manipuler et éditer des chaînes. Les expressions régulières Java sont largement utilisées dans la validation des mots de passe et des e-mails. Ces expressions sont fournies par le package java.util.regex et se composent d'une interface et de 3 classes.
Les trois classes sont:
- Motif: Aide à définir des motifs.
- Matcher: l' aide de modèles permet de réaliser des opérations de correspondance.
- PatternSyntaxException: aide à indiquer une erreur de syntaxe.
Java Regex possède une interface appelée MatchResultInterface qui aide à déterminer le résultat de l'opération de correspondance de l'expression régulière.
Syntaxe de l'expression régulière en Java
Voyons maintenant comment écrire une expression régulière en Java à l'aide d'un programme.
Code:
//Java program to demonstrate regular expressions
import java.util.regex.*;
public class RegExamples (
public static void main(String args())(
String A = " Happiness is " + " within yourself";
String B = ".*within.*";
// checks whether the string A contains the word 'within' and stores the result in matchcheck
boolean matchcheck = Pattern.matches(B, A);
//prints the result
System.out.println("Is there any string 'within' in the text ? \n " + matchcheck);
) )
Production:
Méthodes couramment utilisées dans les expressions régulières
Il existe 3 méthodes couramment utilisées dans les expressions régulières. Elles sont,
1. Méthodes d'indexation
Les méthodes d'index offrent des valeurs d'index qui aident à montrer précisément où la correspondance a été trouvée dans la chaîne donnée en entrée.
| Méthode | La description |
| début() | L'index de début de la correspondance précédente est renvoyé. |
| start (groupe int) | Étant donné la précédente opération de correspondance du groupe, la sous-séquence est capturée et renvoyée. |
| fin() | Le décalage après avoir fait correspondre le dernier caractère est renvoyé. |
| Fin (groupe int) | Étant donné la précédente opération de correspondance du groupe, la sous-séquence est capturée et décalée après la correspondance avec le dernier caractère renvoyé. |
2. Méthodes d'étude
Les méthodes d'étude vérifient la chaîne donnée en entrée et une valeur booléenne est retournée indiquant si le modèle est trouvé ou non.
| Méthode | La description |
| regarder() | Faites correspondre la séquence donnée en entrée avec le motif depuis le début de la région. |
| trouver() | Recherche la sous-séquence suivante de la séquence donnée en entrée par rapport au modèle depuis le début de la région. |
| trouver (int start) | Réinitialise le matcher puis trouve la sous-séquence suivante de la séquence donnée en entrée par rapport au modèle de l'index spécifié. |
| allumettes() | Associe le contenu au modèle. |
3. Méthodes de remplacement
Méthodes utilisées pour remplacer du texte dans une chaîne.
| Méthode | La description |
| appendReplacement (StringBuffer s, remplacement de chaîne) | Une étape d'ajout et de remplacement non terminal sera implémentée. |
| appendTail (StringBuffer s) | Une étape d'ajout et de remplacement du terminal sera mise en œuvre. |
| replaceAll (remplacement de chaîne) | Remplacez toutes les sous-séquences de la séquence donnée en entrée qui correspondent au modèle par une chaîne de remplacement. |
| quoteReplacement (String s) | Une chaîne de remplacement littérale sera retournée pour la chaîne mentionnée. |
| replaceFirst (remplacement de chaîne) | Remplacez la première sous-séquence de la séquence donnée en entrée qui correspond au modèle par une chaîne de remplacement. |
Comment définir une expression régulière en Java?
Il existe plusieurs façons de définir une expression régulière. Elles sont:
1. Littéraux
Supposons qu'une chaîne «hai» doit être recherchée dans un texte «hai». Cela peut être fait en utilisant la syntaxe.
Pattern.matches("hai", "hai")
2. Classes de personnages
Il fait correspondre chaque caractère du texte donné en entrée à plusieurs caractères autorisés dans la classe de caractères. Voici les différentes constructions de classe.
| Classe de personnage | Explication |
| (pqr) | Correspond au texte s'il contient p, q ou r et qu'il ne doit l'être qu'une seule fois. |
| (pqr) | désigne la négation et à cause de cela, ici, un seul caractère à l'exception de p, q ou r est pris. |
| (a-zA-Z) | a à z et A à Z sont considérés. |
| (annonce (ps)) | a à d ou p à s. |
| (a-dm-p) | Union des deux gammes. |
| (az && (pqr)) | a à z et (p, q ou r). |
| (az && (pq)) | a à z et aussi, p, q ne sont pas pris en compte. |
| (ad-z) | Effectue la soustraction. |
| (az && (mp)) | a à z et non m à p. |
3. Métacaractères
Les métacaractères agissent comme des shortcodes dans l'expression régulière. Voici quelques-uns des métacaractères couramment utilisés.
| Expression régulière | Explication |
| \ré | N'importe quel chiffre de 0 à 9. Il peut également s'écrire (0-9). |
| \RÉ | Tout non-chiffre de 0 à 9. Il peut également être écrit comme (0-9). |
| \ s | Caractère d'espacement ou (\ t \ n \ x0B \ f \ r). |
| \ S | Caractère non blanc ou (\ s). |
| \ w | Caractère de mot ou (a-zA-Z_0-9). |
| \ W | Caractère non mot ou (\ w). |
| \ b | Limite des mots. |
| \ B | Limite non mot. |
4. Quantificateurs
Les quantificateurs mentionnent le nombre d'occurrences de chaque caractère à comparer à la chaîne.
| Expression régulière | Explication |
| une? | Se produit une fois ou pas du tout. |
| UNE* | A se produit 0 fois ou plus. |
| A + | A se produit 1 fois ou plus. |
| Un) | A se produit exactement n fois. |
| Un, ) | A se produit n ou plus que cela. |
| A (n, m) | A se produit au moins n fois, mais il ne doit pas dépasser plus de m fois. |
Comment créer une expression régulière en Java?
Voyons maintenant un programme java avec les expressions régulières mentionnées ci-dessus.
Code:
//Java program to demonstrate regular expressions
import java.util.regex.*;
public class RegExamples (
public static void main(String args())(
String str="hai";
// Returns true if string 1 matches string 2
System.out.println("Returns true if 'hai' matches 'Hai' :"+
Pattern.matches(str, "Hai")); //False
//Returns true if Hai or hai matches parameter 2
System.out.println("Returns true if 'Hai' or 'hai' matches 'Hai' : "+
Pattern.matches("(Hh)ai", "Hai")); //True
// Returns true if the string matches exactly "ann" or "Ann" or "jak" or "Jak"
System.out.println("Returns true if the string matches exactly 'ann' or 'Ann' or 'jak' or 'Jak' with 'Ann' : "+
Pattern.matches("(aA)nn|(jJ)ak", "Ann"));//True
//returns true if the string contains "with" at any place in the string
System.out.println("returns true if the string contains 'with' in the string 'within' : " +
Pattern.matches(".*with.*", "within"));//True
// returns true if the '9448anna' does not have number in the beginning
System.out.println( "returns true if the '9448anna' does not have number in the beginning : "+
Pattern.matches("^(^\\d).*", "9448anna")); //False
System.out.println("returns true if the '9448anna' does not have number in the beginning : " +
Pattern.matches("^(^\\d).*", "anna9448")); //True
)
)
Production:
Conclusion
Les expressions régulières Java sont largement utilisées pour les applications en temps réel telles que la vérification des mots de passe et des e-mails. Ces expressions sont des API qui définissent des modèles et proposent la recherche, l'édition et plusieurs autres opérations dans la chaîne.
Articles recommandés
Ceci est un guide des expressions régulières en Java. Ici, nous discutons comment créer, comment définir et utiliser des méthodes d'expressions régulières en Java. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Top 3 des meilleurs compilateurs de Java
- Expressions régulières en JavaScript - Propriétés et méthodes
- Développement d'applications Java
- Méthodes de tableau en Java avec des exemples
- Fonctions Regex en Python (exemple)