En Java, les expressions régulières ou Regex (en abrégé) en Java sont une API permettant de définir des modèles de chaîne qui peuvent être utilisés pour rechercher, manipuler et modifier une chaîne en Java. La validation des e-mails et les mots de passe sont quelques domaines de chaînes où Regex est largement utilisé pour définir les contraintes. Les expressions régulières en Java sont fournies sous java.util.regex emballer. Ceci consiste à 3 classes et 1 interface . Le java.util.regex Le package se compose principalement des trois classes suivantes, illustrées ci-dessous sous forme de tableau comme suit :
Classes et interfaces Regex
Regex en Java fournit 3 classes et 1 interface qui sont les suivantes :
- Classe de modèle
- Classe de correspondance
- Classe PatternSyntaxException
- Interface de résultat de correspondance
Une meilleure compréhension peut être interprétée à partir de l’image fournie ci-dessous comme suit :
| Oui Non. | Classe/Interface | Description |
|---|---|---|
| 1. | Classe de modèle | Utilisé pour définir des modèles |
| 2. | Classe de correspondance | Utilisé pour effectuer des opérations de correspondance sur du texte à l'aide de modèles |
| 3. | Classe PatternSyntaxException | Utilisé pour indiquer une erreur de syntaxe dans un modèle d'expression régulière |
| 4. | Interface de résultat de correspondance | Utilisé pour représenter le résultat d'une opération de correspondance |
Classe de modèle
Cette classe est une compilation d'expressions régulières qui peuvent être utilisées pour définir différents types de modèles, sans fournir de constructeurs publics. Cela peut être créé en appelant la méthode compile() qui accepte une expression régulière comme premier argument, renvoyant ainsi un modèle après l'exécution.
| Oui Non. | Méthode | Description |
|---|---|---|
| 1. | compiler (expression régulière de chaîne) | Il est utilisé pour compiler l'expression régulière donnée dans un modèle. |
| 2. | compiler (expression régulière de chaîne, indicateurs int) | Il est utilisé pour compiler l'expression régulière donnée dans un modèle avec les indicateurs donnés. |
| 3. | drapeaux() | Il est utilisé pour renvoyer les indicateurs de correspondance de ce modèle. |
| 4. | matcher (entrée CharSequence) | Il est utilisé pour créer un matcher qui fera correspondre l'entrée donnée à ce modèle. |
| 5. | correspondances (expression régulière de chaîne, entrée CharSequence) | Il est utilisé pour compiler l'expression régulière donnée et tente de faire correspondre l'entrée donnée à celle-ci. |
| 6. | modèle() | Il est utilisé pour renvoyer l'expression régulière à partir de laquelle ce modèle a été compilé. |
| 7. | citation(Chaîne s) | Il est utilisé pour renvoyer une chaîne de modèle littéral pour la chaîne spécifiée. |
| 8. | split (entrée CharSequence) | Il est utilisé pour diviser la séquence d'entrée donnée autour des correspondances de ce modèle. |
| 9. | split (entrée CharSequence, limite int) | Il est utilisé pour diviser la séquence d'entrée donnée autour des correspondances de ce modèle. Le paramètre limit contrôle le nombre de fois que le motif est appliqué. |
| dix. | àChaîne() | Il est utilisé pour renvoyer la représentation sous forme de chaîne de ce modèle. |
Exemple: Classe de modèle
Java
// Java Program Demonstrating Working of matches() Method> // Pattern class> // Importing Pattern class from java.util.regex package> import> java.util.regex.Pattern;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Following line prints 'true' because the whole> >// text 'geeksforgeeks' matches pattern> >// 'geeksforge*ks'> >System.out.println(Pattern.matches(> >'geeksforge*ks'>,>'geeksforgeeks'>));> >// Following line prints 'false' because the whole> >// text 'geeksfor' doesn't match pattern 'g*geeks*'> >System.out.println(> >Pattern.matches(>'g*geeks*'>,>'geeksfor'>));> >}> }> |
outil de capture dans Ubuntu
>
>Sortir
true false>
Classe de correspondance
Cet objet est utilisé pour effectuer des opérations de correspondance pour une chaîne d'entrée en Java, interprétant ainsi les modèles expliqués précédemment. Cela aussi ne définit aucun constructeur public. Cela peut être implémenté en appelant un matcher() sur n'importe quel objet de modèle.
| Oui Non. | Méthode | Description |
|---|---|---|
| 1. | trouver() | Il est principalement utilisé pour rechercher plusieurs occurrences d’expressions régulières dans le texte. |
| 2. | trouver (int début) | Il est utilisé pour rechercher des occurrences d'expressions régulières dans le texte à partir de l'index donné. |
| 3. | commencer() | Il est utilisé pour obtenir l’index de début d’une correspondance trouvée à l’aide de la méthode find(). |
| 4. | fin() | Il est utilisé pour obtenir l’index de fin d’une correspondance trouvée à l’aide de la méthode find(). Il renvoie l'index du caractère à côté du dernier caractère correspondant. |
| 5. | groupeCount() | Il est utilisé pour trouver le nombre total de la sous-séquence correspondante. |
| 6. | groupe() | Il est utilisé pour trouver la sous-séquence correspondante. |
| 7. | allumettes() | Il est utilisé pour tester si l'expression régulière correspond au modèle. |
Note: T Pattern.matches() vérifie si tout le texte correspond ou non à un modèle. D'autres méthodes (démontrées ci-dessous) sont principalement utilisées pour trouver plusieurs occurrences de modèles dans le texte.
Discutons de quelques exemples de programmes comme nous l'avons fait pour la classe Pattern. Ici, nous discuterons de quelques programmes Java qui démontrent le fonctionnement de compile(), find(), start(), end() et split() afin de mieux comprendre la classe Matcher.
Exemple 1: Recherche de modèles
Java
// Java program to demonstrate working of> // String matching in Java> // Importing Matcher and Pattern class> import> java.util.regex.Matcher;> import> java.util.regex.Pattern;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Create a pattern to be searched> >// Custom pattern> >Pattern pattern = Pattern.compile(>'geeks'>);> >// Search above pattern in 'techcodeview.com> | Description |
|---|---|
| [xyz] | x, y ou z |
| [^xyz] | Tous les caractères autres que x, y ou z |
| [a-zA-Z] | caractères compris entre a et z ou entre A et Z. |
| [a-f[m-t]] | Union de a à f et de m à t. |
| [a-z && p-y] | Toute la gamme d'éléments intersection entre deux plages |
| [a-z && [^bc]] | union de a à z avec sauf b et c |
| [a-z && [^m-p]] | union de a à z avec une plage sauf m à p |
Vous trouverez ci-dessous la mise en œuvre du sujet ci-dessus :
Java
// Java Program to check on Regex> import> java.io.*;> import> java.util.regex.*;> // Driver class> class> GFG {> >// Main function> >public> static> void> main(String[] args)> >{> >// Checks if the string matches with the regex> >// Should be single character a to z> >System.out.println(Pattern.matches(>'[a-z]'>,>'g'>));> >// Check if the element is range a to z or A to Z> >System.out.println(> >Pattern.matches(>'[a-zA-Z]'>,>'Gfg'>));> >}> }> |
>
>Sortir
true false>
Métacaractères Regex
| Expression régulière | Description |
|---|---|
| X? | X apparaît une fois ou pas |
| X+ | X apparaît une ou plusieurs fois |
| X* | X apparaît zéro ou pas une fois |
| X{n} | X apparaît n fois |
| X{n,} dateformat.format java | X apparaît n fois ou plus de n |
| X{n,m} | X apparaît supérieur à égal à n fois et inférieur à m fois. |
Vous trouverez ci-dessous l'implémentation des métacaractères Regex :
Java
// Java Program to check on regex> import> java.io.*;> import> java.util.regex.*;> // Driver class> class> GFG {> >// Main function> >public> static> void> main(String[] args)> >{> >// Checking all the strings using regex> >System.out.println(Pattern.matches(>'[b-z]?'>,>'a'>));> >// Check if all the elements are in range a to z> >// or A to Z> >System.out.println(> >Pattern.matches(>'[a-zA-Z]+'>,>'GfgTestCase'>));> >// Check if elements is not in range a to z> >System.out.println(Pattern.matches(>'[^a-z]?'>,>'g'>));> >// Check if all the elements are either g,e,k or s> >System.out.println(> >Pattern.matches(>'[geks]*'>,>'geeksgeeks'>));> >}> }> |
>
>Sortir
false true false true>
Exemple de recherche d'expressions régulières Java
| Expression régulière | Description |
|---|---|
| . | N'importe quel caractère |
| d | Tous les chiffres, [0-9] |
| D | N'importe quel autre chiffre, [^0-9] |
| s | Caractère d'espacement, [ x0Bf ] |
| S | Caractère autre qu'un espace, [^s] |
| Dans | Caractère de mot, [a-zA-Z_0-9] |
| DANS | Caractère autre qu'un mot, [^w] |
|
| Limite de mots |
| B | Limite non-mot |
Vous trouverez ci-dessous l'implémentation de Java Regex Finder :
Java
// Java Program to implement regex> import> java.io.*;> import> java.util.regex.*;> // Driver Class> class> GFG {> >// Main Function> >public> static> void> main(String[] args)> >{> >// Check if all elements are numbers> >System.out.println(Pattern.matches(>'d+'>,>'1234'>));> >// Check if all elements are non-numbers> >System.out.println(Pattern.matches(>'D+'>,>'1234'>));> >// Check if all the elements are non-numbers> >System.out.println(Pattern.matches(>'D+'>,>'Gfg'>));> >// Check if all the elements are non-spaces> >System.out.println(Pattern.matches(>'S+'>,>'gfg'>));> >}> }> |
>
>Sortir
true false true true>
Conclusion
Enfin, discutons de certaines des observations importantes extraites de l'article ci-dessus.
- Nous créons un objet pattern en appelant Pattern.compile(), il n'y a pas de constructeur. compile() est une méthode statique de la classe Pattern.
- Comme ci-dessus, nous créons un objet Matcher en utilisant matcher() sur les objets de la classe Pattern.
- Pattern.matches() est également une méthode statique utilisée pour vérifier si un texte donné dans son ensemble correspond ou non au modèle.
- find() est utilisé pour rechercher plusieurs occurrences de modèles dans le texte.
- Nous pouvons diviser un texte en fonction d'un modèle de délimiteur en utilisant la méthode split()
FAQ sur Java Regex
T1. Que sont les expressions régulières en Java ?
Ans:
Les expressions régulières en Java sont utilisées pour les modèles de chaînes qui peuvent être utilisés pour rechercher, manipuler et modifier une chaîne en Java.
Q2. Qu'est-ce qu'un exemple simple d'expression régulière en Java ?
Ans:
chaîne de concaténation Java
Un exemple simple d’expression régulière en Java est mentionné ci-dessous :
Java
// Java Program to check on Regex>import>java.io.*;>import>java.util.regex.*;>// Driver class>class>GFG {>>// Main function>>public>static>void>main(String[] args)>>{>>// Checks if the string matches with the regex>>// Should be single character a to z>>System.out.println(Pattern.matches(>'[a-z]'>,>'g'>));>>// Check if all the elements are non-numbers>>System.out.println(Pattern.matches(>'D+'>,>'Gfg'>));>>// Check if all the elements are non-spaces>>System.out.println(Pattern.matches(>'S+'>,>'gfg'>));>>}>}>>>Sortirtrue true true>