Le Java Regex ou Regular Expression est une API pour définir un modèle pour rechercher ou manipuler des chaînes .
Il est largement utilisé pour définir la contrainte sur des chaînes telles que le mot de passe et la validation de l'e-mail. Après avoir appris le didacticiel Java regex, vous pourrez tester vos expressions régulières à l'aide de l'outil Java Regex Tester.
L'API Java Regex fournit 1 interface et 3 classes dans java.util.regex emballer.
paquet java.util.regex
Les classes Matcher et Pattern offrent la fonctionnalité d'expression régulière Java. Le package java.util.regex fournit les classes et interfaces suivantes pour les expressions régulières.
- Interface MatchResult
- Classe de correspondance
- Classe de modèle
- Classe PatternSyntaxException
Classe de correspondance
Il met en œuvre le Résultat de correspondance interface. C'est un moteur d'expression régulière qui est utilisé pour effectuer des opérations de correspondance sur une séquence de caractères.
| Non. | Méthode | Description |
|---|---|---|
| 1 | correspondances booléennes() | tester si l'expression régulière correspond au modèle. |
| 2 | recherche booléenne() | trouve l'expression suivante qui correspond au modèle. |
| 3 | recherche booléenne (int start) | trouve l'expression suivante qui correspond au modèle à partir du numéro de départ donné. |
| 4 | Groupe de chaînes() | renvoie la sous-séquence correspondante. |
| 5 | int début() | renvoie l'index de départ de la sous-séquence correspondante. |
| 6 | avoir l'intention() | renvoie l'index de fin de la sous-séquence correspondante. |
| 7 | int groupCount() | renvoie le nombre total de la sous-séquence correspondante. |
Classe de modèle
C'est le version compilée d'une expression régulière . Il est utilisé pour définir un modèle pour le moteur d'expression régulière.
| Non. | Méthode | Description |
|---|---|---|
| 1 | Compilation de modèles statiques (regex de chaîne) | compile l'expression régulière donnée et renvoie l'instance du modèle. |
| 2 | Matcher matcher (entrée CharSequence) | crée un matcher qui fait correspondre l'entrée donnée avec le modèle. |
| 3 | correspondances booléennes statiques (expression régulière de chaîne, entrée CharSequence) | Cela fonctionne comme une combinaison de méthodes de compilation et de matcher. Il compile l'expression régulière et fait correspondre l'entrée donnée avec le modèle. |
| 4 | String[] split (entrée CharSequence) | divise la chaîne d'entrée donnée autour des correspondances d'un modèle donné. |
| 5 | Modèle de chaîne() | renvoie le modèle regex. |
Exemple d'expressions régulières Java
Il existe trois façons d’écrire l’exemple d’expression régulière en Java.
import java.util.regex.*; public class RegexExample1{ public static void main(String args[]){ //1st way Pattern p = Pattern.compile('.s');//. represents single character Matcher m = p.matcher('as'); boolean b = m.matches(); //2nd way boolean b2=Pattern.compile('.s').matcher('as').matches(); //3rd way boolean b3 = Pattern.matches('.s', 'as'); System.out.println(b+' '+b2+' '+b3); }} Testez-le maintenant Sortir
true true true
Expression régulière . Exemple
Le . (point) représente un seul caractère.
import java.util.regex.*; class RegexExample2{ public static void main(String args[]){ System.out.println(Pattern.matches('.s', 'as'));//true (2nd char is s) System.out.println(Pattern.matches('.s', 'mk'));//false (2nd char is not s) System.out.println(Pattern.matches('.s', 'mst'));//false (has more than 2 char) System.out.println(Pattern.matches('.s', 'amms'));//false (has more than 2 char) System.out.println(Pattern.matches('..s', 'mas'));//true (3rd char is s) }} Testez-le maintenant Classes de caractères Regex
| Non. | Classe de personnage | Description |
|---|---|---|
| 1 | [abc] | a, b ou c (classe simple) |
| 2 | [^abc] | N'importe quel caractère sauf a, b ou c (négation) |
| 3 | [a-zA-Z] | a à z ou A à Z, inclus (plage) |
| 4 | [a-d[m-p]] | a à d, ou m à p : [a-dm-p] (union) |
| 5 | [a-z&&[déf]] | d, e ou f (intersection) |
| 6 | [a-z&&[^bc]] | a à z, sauf b et c : [ad-z] (soustraction) |
| 7 | [a-z&&[^m-p]] | a à z, et non m à p : [a-lq-z](soustraction) |
Classes de caractères d'expression régulière Exemple
import java.util.regex.*; class RegexExample3{ public static void main(String args[]){ System.out.println(Pattern.matches('[amn]', 'abcd'));//false (not a or m or n) System.out.println(Pattern.matches('[amn]', 'a'));//true (among a or m or n) System.out.println(Pattern.matches('[amn]', 'ammmna'));//false (m and a comes more than once) }} Testez-le maintenant Quantificateurs Regex
Les quantificateurs précisent le nombre d'occurrences d'un caractère.
| Expression régulière | Description |
|---|---|
| X? | X se produit une fois ou pas du tout |
| X+ | X apparaît une ou plusieurs fois |
| X* | X apparaît zéro ou plusieurs fois |
| X{n} | X apparaît n fois seulement |
| X{n,} | X apparaît n fois ou plus |
| X{y,z} | X apparaît au moins y fois mais moins de z fois |
Classes de caractères d'expression régulière et exemple de quantificateurs
import java.util.regex.*; class RegexExample4{ public static void main(String args[]){ System.out.println('? quantifier ....'); System.out.println(Pattern.matches('[amn]?', 'a'));//true (a or m or n comes one time) System.out.println(Pattern.matches('[amn]?', 'aaa'));//false (a comes more than one time) System.out.println(Pattern.matches('[amn]?', 'aammmnn'));//false (a m and n comes more than one time) System.out.println(Pattern.matches('[amn]?', 'aazzta'));//false (a comes more than one time) System.out.println(Pattern.matches('[amn]?', 'am'));//false (a or m or n must come one time) System.out.println('+ quantifier ....'); System.out.println(Pattern.matches('[amn]+', 'a'));//true (a or m or n once or more times) System.out.println(Pattern.matches('[amn]+', 'aaa'));//true (a comes more than one time) System.out.println(Pattern.matches('[amn]+', 'aammmnn'));//true (a or m or n comes more than once) System.out.println(Pattern.matches('[amn]+', 'aazzta'));//false (z and t are not matching pattern) System.out.println('* quantifier ....'); System.out.println(Pattern.matches('[amn]*', 'ammmna'));//true (a or m or n may come zero or more times) }} Testez-le maintenant Métacaractères Regex
Les métacaractères des expressions régulières fonctionnent comme des codes courts.
| Expression régulière | Description |
|---|---|
| . | N'importe quel caractère (peut ou non correspondre au terminateur) |
| d | Tous les chiffres, en deçà de [0-9] |
| D | N'importe quel autre chiffre, abréviation de [^0-9] |
| s | Tout caractère d'espacement, abréviation de [ x0Bf ] |
| S | Tout caractère autre qu'un espace, abréviation de [^s] |
| Dans | N'importe quel caractère de mot, abréviation de [a-zA-Z_0-9] |
| DANS | Tout caractère autre qu'un mot, abréviation de [^w] |
| Une limite de mots | |
| B | Une limite sans mot |
Exemple de métacaractères d'expression régulière
import java.util.regex.*; class RegexExample5{ public static void main(String args[]){ System.out.println('metacharacters d....');\d means digit System.out.println(Pattern.matches('\d', 'abc'));//false (non-digit) System.out.println(Pattern.matches('\d', '1'));//true (digit and comes once) System.out.println(Pattern.matches('\d', '4443'));//false (digit but comes more than once) System.out.println(Pattern.matches('\d', '323abc'));//false (digit and char) System.out.println('metacharacters D....');\D means non-digit System.out.println(Pattern.matches('\D', 'abc'));//false (non-digit but comes more than once) System.out.println(Pattern.matches('\D', '1'));//false (digit) System.out.println(Pattern.matches('\D', '4443'));//false (digit) System.out.println(Pattern.matches('\D', '323abc'));//false (digit and char) System.out.println(Pattern.matches('\D', 'm'));//true (non-digit and comes once) System.out.println('metacharacters D with quantifier....'); System.out.println(Pattern.matches('\D*', 'mak'));//true (non-digit and may come 0 or more times) }} Testez-le maintenant Question d'expression régulière 1
/*Create a regular expression that accepts alphanumeric characters only. Its length must be six characters long only.*/ import java.util.regex.*; class RegexExample6{ public static void main(String args[]){ System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'arun32'));//true System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'kkvarun32'));//false (more than 6 char) System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'JA2Uk2'));//true System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'arun$2'));//false ($ is not matched) }} Testez-le maintenant
Question d'expression régulière 2
/*Create a regular expression that accepts 10 digit numeric characters starting with 7, 8 or 9 only.*/ import java.util.regex.*; class RegexExample7{ public static void main(String args[]){ System.out.println('by character classes and quantifiers ...'); System.out.println(Pattern.matches('[789]{1}[0-9]{9}', '9953038949'));//true System.out.println(Pattern.matches('[789][0-9]{9}', '9953038949'));//true System.out.println(Pattern.matches('[789][0-9]{9}', '99530389490'));//false (11 characters) System.out.println(Pattern.matches('[789][0-9]{9}', '6953038949'));//false (starts from 6) System.out.println(Pattern.matches('[789][0-9]{9}', '8853038949'));//true System.out.println('by metacharacters ...'); System.out.println(Pattern.matches('[789]{1}\d{9}', '8853038949'));//true System.out.println(Pattern.matches('[789]{1}\d{9}', '3853038949'));//false (starts from 3) }} Testez-le maintenant Exemple de recherche d'expressions régulières Java
import java.util.regex.Pattern; import java.util.Scanner; import java.util.regex.Matcher; public class RegexExample8{ public static void main(String[] args){ Scanner sc=new Scanner(System.in); while (true) { System.out.println('Enter regex pattern:'); Pattern pattern = Pattern.compile(sc.nextLine()); System.out.println('Enter text:'); Matcher matcher = pattern.matcher(sc.nextLine()); boolean found = false; while (matcher.find()) { System.out.println('I found the text '+matcher.group()+' starting at index '+ matcher.start()+' and ending at index '+matcher.end()); found = true; } if(!found){ System.out.println('No match found.'); } } } } Sortir:
Enter regex pattern: java Enter text: this is java, do you know java I found the text java starting at index 8 and ending at index 12 I found the text java starting at index 26 and ending at index 30