java regex tutorial with regular expression examples
Ce tutoriel Java Regex explique ce qu'est une expression régulière en Java, pourquoi nous en avons besoin et comment l'utiliser à l'aide d'exemples d'expressions régulières:
À expression régulière en Java abrégé en ' regex »Est une expression utilisée pour définir un modèle de recherche pour les chaînes.
Le modèle de recherche peut être un simple caractère ou une sous-chaîne ou il peut s'agir d'une chaîne ou d'une expression complexe qui définit un modèle particulier à rechercher dans la chaîne.
En outre, le modèle peut devoir correspondre une ou plusieurs fois à la chaîne.
=> Visitez ici pour voir la série de formations Java pour tous.
Ce que vous apprendrez:
- Expression régulière: pourquoi nous en avons besoin
- Validation des e-mails à l'aide de Regex
- Conclusion
Expression régulière: pourquoi nous en avons besoin
Une expression régulière est principalement utilisée pour rechercher un modèle dans une chaîne. Pourquoi recherchons-nous un motif dans une chaîne? Nous pourrions vouloir trouver un modèle particulier dans une chaîne, puis le manipuler ou le modifier.
Ainsi, dans une application informatique, nous pouvons avoir un besoin continu de manipuler divers modèles. Par conséquent, nous avons toujours besoin de regex pour faciliter la recherche du modèle.
Maintenant donné un modèle à rechercher, comment fonctionne exactement l'expression régulière?
Lorsque nous analysons et modifions le texte à l’aide d’une expression régulière, nous disons que «nous avons appliqué une expression régulière à la chaîne ou au texte». Nous appliquons le modèle au texte dans une direction «de gauche à droite» et la chaîne source est mise en correspondance avec le modèle.
Par exemple, considérez une chaîne ' ababababab ». Supposons qu’une expression rationnelle «aba» soit définie. Alors maintenant, nous devons appliquer cette regex à la chaîne. En appliquant l'expression régulière de gauche à droite, l'expression régulière correspondra à la chaîne ' aba_aba___ », À deux endroits.
Ainsi, une fois qu'un caractère source est utilisé dans une correspondance, nous ne pouvons pas le réutiliser. Ainsi, après avoir trouvé la première correspondance aba, le troisième caractère «a» n’a pas été réutilisé.
meilleur programme pour cloner le disque dur
java.util.regex
Le langage Java ne fournit aucune classe intégrée pour l'expression régulière. Mais nous pouvons travailler avec des expressions régulières en important le ' java.util.regex ' paquet.
Le package java.util.regex fournit une interface et trois classes comme indiqué ci-dessous:
Classe de modèle: Une classe de modèle représente l'expression régulière compilée. La classe Pattern n'a pas de constructeur public mais elle fournit des méthodes statiques compile () qui renvoient des objets Pattern et peuvent être utilisées pour créer un modèle.
Classe Matcher: L'objet de classe Matcher fait correspondre le modèle d'expression régulière à la chaîne. Comme la classe Pattern, cette classe ne fournit pas non plus de constructeurs publics. Il fournit la méthode matcher () qui renvoie un objet Matcher.
PatternSyntaxException: Cette classe définit une exception non vérifiée. Un objet de type PatternSyntaxException renvoie une exception non vérifiée indiquant une erreur de syntaxe dans le modèle regex.
Interface MatchResult: L'interface MatchResult détermine le résultat de la correspondance de modèle d'expression régulière.
Exemple Java Regex
Implémentons un exemple simple de regex en Java. Dans le programme ci-dessous, nous avons une chaîne simple comme modèle, puis nous la comparons à une chaîne. La sortie imprime la position de début et de fin dans la chaîne où se trouve le motif.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String args()) { //define a pattern to be searched Pattern pattern = Pattern.compile('Help.'); // Search above pattern in 'softwareTestingHelp.com' Matcher m = pattern.matcher('softwareTestingHelp.com'); // print the start and end position of the pattern found while (m.find()) System.out.println('Pattern found from position ' + m.start() + ' to ' + (m.end()-1)); } } Production:
Motif trouvé de 15 à 19
Regex Matcher en Java
La classe matcher implémente l'interface MatchResult. Matcher agit comme un moteur d'expression régulière et est utilisé pour effectuer la correspondance exacte d'une séquence de caractères.
Vous trouverez ci-dessous les méthodes courantes de la classe Matcher. Il a plus de méthodes mais nous n'avons énuméré que les méthodes importantes ci-dessous.
| Ne pas | Méthode | Description |
|---|---|---|
| sept | int début () | Donne l'index de départ de la sous-séquence correspondante et le renvoie. |
| 1 | correspondances booléennes () | Vérifie si l'expression régulière correspond au modèle. |
| deux | Motif de motif () | Renvoie le modèle interprété par le matcher. |
| 3 | booléen find () | Cette méthode recherche l'expression suivante à mettre en correspondance avec le modèle. |
| 4 | recherche booléenne (début int) | Identique à find () mais trouve l'expression à rechercher à partir de la position de départ donnée. |
| 5 | Groupe de chaînes () | Renvoie la sous-séquence correspondant au modèle. |
| 6 | Groupe de chaînes (nom de chaîne) | Renvoie la sous-séquence d'entrée. Ceci est capturé dans l'opération de correspondance précédente en capturant le groupe avec le nom spécifié. |
| 8 | int fin () | Renvoie la position de fin / l'index de la sous-séquence correspondante. |
| 9 | int groupCount () | Renvoie le nombre total de sous-séquences correspondantes. |
| dix | String replaceAll (remplacement de chaîne) | Remplacez toutes les sous-séquences de la séquence d'entrée qui correspondent au modèle par une chaîne de remplacement donnée. |
| Onze | String replaceFirst (remplacement de chaîne) | Remplacez la première sous-séquence correspondante de la séquence d'entrée par la chaîne de remplacement spécifiée. |
| 12 | Chaîne toString () | Renvoie la représentation sous forme de chaîne du matcher actuel. |
Exemple d'implémentation d'expression régulière
Voyons un exemple de l’utilisation de certaines de ces méthodes.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherDemo { public static void main(String() args) { String inputString = 'She sells sea shells on the sea shore with shells'; //obtain a Pattern object Pattern pattern = Pattern.compile('shells'); // obtain a matcher object System.out.println('input string: ' + inputString); Matcher matcher = pattern.matcher(inputString); inputString = matcher.replaceFirst('pearls'); System.out.println('
replaceFirst method:' + inputString); //use replaceAll method to replace all occurrences of pattern inputString = matcher.replaceAll('pearls'); System.out.println('
replaceAll method:' + inputString); } } Production:
chaîne d'entrée: elle vend des coquillages au bord de la mer avec des coquillages
replacePremière méthode: elle vend des perles de mer au bord de la mer avec des coquillages
Méthode replaceAll: elle vend des perles de mer sur le bord de la mer avec des perles
Classe de modèle Regex en Java
La classe Pattern définit le modèle du moteur d'expression régulière qui peut ensuite être utilisé pour correspondre à la chaîne d'entrée.
Le tableau suivant présente les méthodes fournies par la classe Pattern qui est couramment utilisée.
| Ne pas | Méthode | Description |
|---|---|---|
| sept | String () split (entrée CharSequence, limite int) | La chaîne d'entrée est divisée autour des correspondances trouvées par un modèle donné. |
| 1 | Compilation de modèles statiques (String regex) | Renvoie une représentation compilée de l'expression régulière. |
| deux | Compilation de modèles statiques (String regex, int flags) | Compile l'expression régulière donnée en utilisant les indicateurs spécifiés et renvoie le modèle. |
| 3 | Correspondances (entrée CharSequence) | Renvoie une correspondance en faisant correspondre la séquence d'entrée avec le modèle. |
| 4 | correspondances booléennes statiques (String regex, entrée CharSequence) | Compile la regex donnée et fait correspondre le modèle avec une entrée donnée. |
| 5 | indicateurs int () | Renvoie les indicateurs du modèle avec lequel la correspondance est effectuée. |
| 6 | String () split (entrée CharSequence) | La chaîne d'entrée est divisée autour des correspondances trouvées par un modèle donné. |
| 8 | Modèle de chaîne () | Renvoie le modèle d'expression régulière. |
| 9 | guillemet de chaîne statique (chaîne s) | Renvoie une chaîne littérale (modèle) pour la chaîne donnée. |
| dix | Chaîne toString () | Obtenez une représentation sous forme de chaîne du modèle. |
L'exemple ci-dessous utilise certaines des méthodes ci-dessus de la classe Pattern.
import java.util.regex.*; public class Main { public static void main(String() args) { // define a REGEX String String REGEX = 'Test'; // string to be searched for given pattern String actualString = 'Welcome to SoftwareTestingHelp portal'; // generate a pattern for given regex using compile method Pattern pattern = Pattern.compile(REGEX); // set limit to 2 int limit = 2; // use split method to split the string String() array = pattern.split(actualString, limit); // print the generated array for (int i = 0; i Dans le programme ci-dessus, nous utilisons la méthode de compilation pour générer un modèle. Ensuite, nous divisons la chaîne d'entrée sur ce modèle et la lisons dans un tableau. Enfin, nous affichons le tableau qui a été généré à la suite du fractionnement de la chaîne d'entrée.
Méthode de correspondance de chaînes d'expression régulière
Nous avons vu la méthode String.Contains () dans nos didacticiels sur les chaînes. Cette méthode renvoie une valeur booléenne true ou false selon que la chaîne contient un caractère spécifié ou non.
De même, nous avons une méthode «matches ()» pour vérifier si la chaîne correspond à une expression régulière ou à une regex. Si la chaîne correspond à l'expression régulière spécifiée, alors une valeur vraie est retournée ou bien faux est retourné.
La syntaxe générale de la méthode matches ():
comment ouvrir les fichiers .apk
public boolean matches (String regex)Si l'expression régulière spécifiée n'est pas valide, alors «PatternSyntaxException» est lancée.
Implémentons un programme pour montrer l’utilisation de la méthode matches ().
public class MatchesExample{ public static void main(String args()){ String str = new String('Java Series Tutorials'); System.out.println('Input String: ' + str); //use matches () method to check if particular regex matches to the given input System.out.print('Regex: (.*)Java(.*) matches string? ' ); System.out.println(str.matches('(.*)Java(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)Series(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)String(.*)')); System.out.print('Regex: (.*)Tutorials matches string? ' ); System.out.println(str.matches('(.*)Tutorials')); } } Production:
Chaîne d'entrée: didacticiels de la série Java
Regex: (. *) Java (. *) Correspond à la chaîne? vrai
Regex: (. *) La série (. *) Correspond à la chaîne? vrai
Regex: (. *) La série (. *) Correspond à la chaîne? faux
Regex: (. *) Tutoriels correspond à la chaîne? vrai
Nous utilisons de nombreux caractères spéciaux et métacaractères avec des expressions régulières en Java. Nous utilisons également de nombreuses classes de caractères pour la correspondance de motifs. Dans cette section, nous fournirons les tableaux contenant les classes de caractères, les caractères Meta et les quantificateurs qui peuvent être utilisés avec regex.
Classes de caractères Regex
Ne pas Classe de caractère Description sept (a-z && (^ m-p)) Soustraction: a à z, et non m à p: (a-lq-z) 1 (pqr) p, q ou r deux (^pqr) Négation: tout caractère autre que p, q ou r 3 (a-zA-Z) Plage: de a à z ou de A à Z, inclus 4 (a-d (m-p)) Union: a à d, ou m à p: (a-dm-p) 5 (a-z && (def)) Intersection: d, e ou f 6 (a-z && (^ bc)) Soustraction: a à z, sauf pour b et c: (ad-z)
Quantificateurs Regex
Les quantificateurs sont utilisés pour spécifier le nombre de fois où le caractère apparaîtra dans l'expression régulière.
Le tableau suivant présente les quantificateurs d'expression régulière utilisés en Java.
Ne pas Quantificateur Regex Description sept DANS Tout caractère autre qu'un mot, (^ w) 1 X? x apparaît une fois ou pas du tout deux x + x apparaît une ou plusieurs fois 3 X * x survient zéro fois ou plus 4 x {n} x survient n fois 5 x {n,} x survient n fois ou plus 6 X y Z} x survient au moins y fois mais moins de z fois
Méta-caractères Regex
Les métacaractères dans regex fonctionnent comme des codes abrégés. Ces codes incluent des espaces et des caractères non blancs ainsi que d'autres codes courts.
Le tableau suivant répertorie les caractères Meta regex.
Ne pas Méta-caractères Description 1 . Tout caractère (peut ou non correspondre au terminateur) deux
é Tous les chiffres, (0-9) 3 RÉ Tout autre qu'un chiffre, (^ 0-9) 4 s Tout caractère d'espacement, ( t n x0B f r) 5 S Tout caractère non blanc, (^ s) 6 dans Tout caractère de mot, (a-zA-Z_0-9) 8 b Une limite de mot 9 B Une frontière sans mot
Ci-dessous est un programme Java qui utilise les caractères spéciaux ci-dessus dans le Regex.
import java.util.regex.*; public class RegexExample{ public static void main(String args()){ // returns true if string exactly matches 'Jim' System.out.print('Jim (jim):' + Pattern.matches('Jim', 'jim')); // Returns true if the input string is Peter or peter System.out.println('
(Pp)eter(Peter) :' + Pattern.matches('(Pp)eter', 'Peter')); //true if string = abc System.out.println('
.*abc.*(pqabcqp) :' + Pattern.matches('.*abc.*', 'pqabcqp')); // true if string doesn't start with a digit System.out.println('
^(^\d).*(abc123):' + Pattern.matches('^(^\d).*', 'abc123')); // returns true if the string contains exact three letters System.out.println('
(a-zA-Z)(a-zA-Z)(a-zA-Z) (aQz):' + Pattern.matches('(a-zA-Z)(a-zA-Z)(a-zA-Z)', 'aQz')); System.out.println('
(a-zA-Z)(a-zA-Z)(a-zA-Z), a10z' + Pattern.matches('(a-zA-Z)(a-zA-Z)(a-zA-Z), a10z', 'a10z')); //input string length = 4 // true if the string contains 0 or more non-digits System.out.println('
\D*, abcde:' + Pattern.matches('\D*', 'abcde')); //True // true of line contains only word this ^-start of the line, $ - end of the line System.out.println('
^This$, This is Java:' + Pattern.matches('^This$', 'This is Java')); System.out.println('
^This$, This:' + Pattern.matches('^This$, This', 'This')); System.out.println('
^This$, Is This Java?:' + Pattern.matches('^This$, Is This Java?', 'Is This Java?')); } } Production:
Jim (jim): faux
(Pp) eter (Peter): vrai
. * abc. * (pqabcqp): vrai
^ (^ d). * (abc123): vrai
(a-zA-Z) (a-zA-Z) (a-zA-Z) (aQz): vrai
(a-zA-Z) (a-zA-Z) (a-zA-Z), a10zfalse
D *, abcde: vrai
^ This $, Ceci est Java: false
^ This $, This: false
^ This $, Is This Java?: False
Dans le programme ci-dessus, nous avons fourni diverses expressions régulières qui correspondent à la chaîne d'entrée. Les lecteurs sont invités à lire les commentaires dans le programme pour chaque regex pour mieux comprendre le concept.
Opérateur logique ou (|) Regex
Nous pouvons utiliser l'opérateur logique ou (|) dans regex qui nous donne le choix de sélectionner l'un ou l'autre des opérandes de | opérateur. Nous pouvons utiliser cet opérateur dans une regex pour donner un choix de caractère ou de chaîne. Par exemple, si nous voulons faire correspondre les deux mots «test» et «Test», alors nous inclurons ces mots dans un opérateur logique ou comme Test | test.
Voyons l'exemple suivant pour comprendre cet opérateur.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexOR { public static void main(String() args) { // Regex string to search for patterns Test or test String regex = '(Test|test)'; // Compiles the pattern and obtains the matcher object from input string. Pattern pattern = Pattern.compile(regex); String input = 'Software Testing Help'; Matcher matcher = pattern.matcher(input); // print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } //define another input string and obtain the matcher object input = 'SoftwaretestingHelp'; matcher = pattern.matcher(input); // Print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } } } Production:
Texte «Test» aux pages 9 à 13.
Texte 'test' trouvé entre 8 et 12.
Dans ce programme, nous avons fourni l'expression rationnelle «(Test | test)». Ensuite, nous donnons d'abord la chaîne d'entrée comme «Aide aux tests de logiciels» et faisons correspondre le modèle. On voit que la correspondance est trouvée et la position est imprimée.
Ensuite, nous donnons la chaîne d'entrée comme «SoftwaretestingHelp». Cette fois également, la correspondance est trouvée. Cela est dû au fait que l'expression régulière a utilisé l'opérateur or et donc le modèle de chaque côté de | l'opérateur est mis en correspondance avec la chaîne.
Validation des e-mails à l'aide de Regex
Nous pouvons également valider l'adresse e-mail (adresse) avec regex en utilisant la méthode java.util.regex.Pattern.matches (). Il correspond à l'ID de messagerie donné avec l'expression régulière et renvoie true si l'e-mail est valide.
Le programme suivant montre la validation du courrier électronique à l'aide de regex.
public class EmailDemo { static boolean isValidemail(String email) { String regex = '^(\w-_\.+)*(\w-_\.)\@((\w)+\.)+(\w)+(\w)$'; //regex to validate email. return email.matches(regex); //match email id with regex and return the value } public static void main(String() args) { String email = 'ssthva@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); email = '@sth@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); } } Production:
L'identifiant de messagerie est: ssthva@gmail.com
Identifiant e-mail valide? vrai
L'identifiant de messagerie est: @ sth @ gmail.com
Identifiant e-mail valide? faux
Comme nous pouvons le voir dans la sortie ci-dessus, le premier identifiant de messagerie est valide. Le deuxième identifiant commence directement par @, et donc regex ne le valide pas. C'est donc un identifiant invalide.
combien d'argent pouvez-vous gagner en testant
Questions fréquemment posées
Q # 1) Qu'est-ce qu'une expression régulière?
Répondre: À Expression régulière communément appelé regex est un modèle ou une séquence de caractères (caractères normaux ou spéciaux ou méta) qui est utilisé pour valider une chaîne d'entrée.
Q # 2) Quelle est la signification de la classe Matcher pour une expression régulière en Java?
Répondre: La classe matcher (java.util.regex.Matcher) agit comme un moteur regex. Il effectue les opérations de mise en correspondance en interprétant le motif.
Q # 3) Quel est le modèle en Java?
Répondre: Le package java.util.regex fournit une classe Pattern qui est utilisée pour compiler une regex dans un modèle qui est la représentation standard pour regex. Ce modèle est ensuite utilisé pour valider les chaînes en le faisant correspondre avec le modèle.
Q # 4) Qu'est-ce que B dans une expression régulière?
Répondre: Le B dans regex est noté b et est un caractère d'ancrage qui est utilisé pour correspondre à une position appelée limite de mot. Le début de la ligne est indiqué par un signe curseur (^) et la fin de la ligne est indiquée par un signe dollar ($).
Q # 5) Le modèle Java est-il thread-safe?
Répondre: Oui. Les instances de la classe Pattern sont immuables et sûres pour une utilisation par plusieurs threads simultanés. Mais les instances de classe matcher ne sont pas thread-safe.
Conclusion
Dans ce didacticiel, nous avons discuté des expressions régulières en Java. L’expression régulière également appelée «regex» est utilisée pour valider la chaîne d’entrée en Java. Java fournit le « java.util.regex ' package qui fournit des classes comme Pattern, Matcher, etc. qui aident à définir et à faire correspondre le modèle avec la chaîne d'entrée.
Nous avons également vu diverses classes de caractères spéciaux et métacaractères que nous pouvons utiliser dans l'expression régulière qui donnent des codes abrégés pour la correspondance de motifs. Nous avons également exploré la validation des e-mails à l'aide de regex.
=> Découvrez la série de formations Java simples ici.
lecture recommandée