L'extraction ou la validation des données est un aspect important de chaque langage de programmation. L'un des moyens les plus courants de validation des données consiste à utiliser des expressions régulières. utilise cesexpressions régulières pour décrire un modèle de caractères. Cet article sur Java Regex listera les différentes méthodes d'utilisation des expressions dans l'ordre suivant:
- Que sont les expressions régulières?
- Qu'est-ce que Java Regex?
- Classe Matcher
- Classe de modèle
- Classe de personnage Regex
- Quantificateurs Regex
- Métacaractères Regex
Commençons!
Que sont les expressions régulières?
À Expression régulière est une séquence de caractères qui construit un modèle de recherche. Lorsque vous recherchez des données dans un texte, vous pouvez utiliser ce modèle de recherche pour décrire ce que vous recherchez.
Une expression régulière peut être un caractère unique ou un motif plus compliqué. Il peut être utilisé pour tout type d'opérations de recherche de texte et de remplacement de texte. Un modèle Regex se compose de caractères simples, tels que / abc / , ou une combinaison de caractères simples et spéciaux, tels que /abc/ ou /example(d+).d*/ .
Qu'est-ce que Java Regex?
La Java Regex est une API qui sert à définir un modèle de recherche ou de manipulation . Il est largement utilisé pour définir la contrainte sur les chaînes telles que le mot de passe et la validation des e-mails.
Il existe différentes méthodes d'utilisation de Java Regex. Alors allons-y et jetons un œil aux différentes expressions.
comment installer php sur la fenêtre
Classe Matcher
Cette classe est utilisée pour effectuer des opérations de correspondance sur une séquence de caractères. Le tableau ci-dessous représente différentes méthodes de la classe Matcher.
| Méthode | La description |
|---|---|
| correspondances booléennes () | Teste si l'expression régulière donnée correspond au modèle |
| booléen find () | Utilisé pour trouver l'expression suivante qui correspond au modèle |
| recherche booléenne (début int) | Recherche l'expression suivante qui correspond au modèle à partir du numéro de départ donné |
| Groupe de chaînes () | Utilisé pour renvoyer la sous-séquence correspondante |
| int début () | Renvoie l'index de départ de la sous-séquence correspondante |
| int fin () | Renvoie l'index de fin de la sous-séquence correspondante |
| int groupCount () | Renvoie le nombre total de la sous-séquence correspondante |
Classe de modèle
Pattern Class est une version compilée de l'expression régulière qui est utilisée pour définir le modèle du moteur regex.
| Méthode | La description |
|---|---|
| Compilation de modèles statiques (String regex) | Il compile l'expression rationnelle donnée et retourne l'instance du motif |
| Correspondances (entrée CharSequence) | Il est utilisé pour créer un matcher qui correspond à l'entrée donnée avec le modèle |
| correspondances booléennes statiques (String regex, entrée CharSequence) | Il fonctionne comme une combinaison de méthodes de compilation et de mise en correspondance. Il compile l'expression régulière et fait correspondre l'entrée donnée avec le modèle |
| String [] split (entrée CharSequence) | Utilisé pour diviser la chaîne d'entrée donnée autour des correspondances d'un modèle donné |
| Modèle de chaîne () | Aide à retourner le modèle de regex |
Prenons maintenant un petit exemple pour comprendre comment écrire une expression régulière.
import java.util.regex. * classe publique RegexExample {public static void main (String [] args) {Pattern pattern = Pattern.compile ('. xx.') Matcher matcher = pattern.matcher ('AxxB') System.out .println ('La chaîne correspond au Regex donné - + matcher.matches ())}}Dans ce cas, il utilise en interne Pattern et Matcher classes regex pour faire le traitement mais évidemment,il réduit les lignes de code. La classe Pattern contient également la méthode matches qui prend regex et String d'entrée comme argument et retourne un résultat booléen après leur correspondance. Donc, le code fonctionne bien pour correspondre à l'entrée avec une expression régulière en Java. Par conséquent, la sortie sera vraie comme indiqué ci-dessous.
Production:
vrai
Voyons maintenant quelques autres catégories d'expressions régulières Java.
Classe de personnage Regex
Le tableau ci-dessous représente les différentes combinaisons de classes de caractères.
| Classe de personnage | La description |
|---|---|
| [abc] | a, b ou c (classe simple) |
| [^ abc] | Tout caractère sauf a, b ou c (négation) |
| [a-zA-Z] | de a à z ou de A à Z, inclus (plage) |
| [a-d [m-p]] | a à d, ou m à p: [a-dm-p] (union) |
| [a-z && [def]] | d, e ou f (intersection) |
| [a-z && [^ bc]] | a à z, sauf pour b et c: [ad-z] (soustraction) |
| [a-z && [^ m-p]] | a à z, et non m à p: [a-lq-z] (soustraction) |
Exemple:
import java.util.regex. * public class CharacterExample {public static void main (String args []) {// false (pas x ou y ou z) System.out.println (Pattern.matches ('[xyz]', 'wbcd')) // true (parmi x ou y ou z) System.out.println (Pattern.matches ('[xyz]', 'x')) // false (x et y viennent plusieurs fois) Système .out.println (Pattern.matches ('[xyz]', 'xxyyyyyz'))}}Quantificateurs Regex
Les quantificateurs spécifient le nombre d'occurrences d'un caractère. Le tableau ci-dessous représente divers quantificateurs.
| Regex | La description |
|---|---|
| X? | X survient une fois ou pas du tout |
| X + | X se produit une ou plusieurs fois |
| X * | X se produit zéro ou plusieurs fois |
| X {n} | X se produit n fois seulement |
| X {n,} | X survient n fois ou plus |
| X y Z} | X se produit au moins y fois mais moins de z fois |
Exemple:
import java.util.regex. * classe publique Exemple {public static void main (String args []) {System.out.println ('? quantifier ....') // (a ou y ou z vient une fois) System.out.println (Pattern.matches ('[ayz]?', 'A')) // sortie: true System.out.println (Pattern.matches ('[ayz]?', 'Aaa')) / / (ay et z viennent plus d'une fois) System.out.println (Pattern.matches ('[ayz]?', 'ayyyyzz')) // sortie: false // (a vient plus d'une fois) System. out.println (Pattern.matches ('[ayz]?', 'amnta')) // sortie: false // (a ou y ou z doit venir une fois) System.out.println (Pattern.matches ('[ ayz]? ',' ay ')) // sortie: false System.out.println (' + quantifier .... ') // (a ou y ou z une ou plusieurs fois) System.out.println (Pattern .matches ('[ayz] +', 'a')) // sortie: true // (a vient plus d'une fois) System.out.println (Pattern.matches ('[ayz] +', 'aaa' )) // outpu: true // (a ou y ou z vient plus d'une fois) System.out.println (Pattern.matches ([amn] + ',' aayyyzz ')) // output: true // (z et t ne correspondent pas au modèle) System.out.println (Pat tern.matches ('[ayz] +', 'aammta')) // sortie: false System.out.println ('* quantifier ....') // (a ou y ou z peut venir zéro ou plusieurs fois ) System.out.println (Pattern.matches ('[ayz] *', 'ayyyza')) // sortie: true}}Fondamentalement, il recherchera le quantificateur correspondant et correspondra au résultat de la recherche.
Métacaractères Regex
Les métacaractères d'expression régulière fonctionnent comme des codes courts. Jetons un œil au tableau ci-dessous pour comprendre les différents types de métacaractères.
| Regex | La description |
|---|---|
| . | Il peut s'agir de n'importe quel caractère (peut ou non correspondre au terminateur) |
| ré | Représente tous les chiffres, à l'exception de [0-9] |
| ré | Représente tout non-chiffre, abréviation de [^ 0-9] |
| s | Représente n'importe quel caractère d'espacement, abréviation de [tnx0Bfr] |
| S | Il peut s'agir d'un caractère non blanc, abréviation de [^ s] |
| dans | Il peut s'agir d'un mot, abréviation de [a-zA-Z_0-9] |
| DANS | Représente tout caractère autre qu'un mot, abréviation de [^ w] |
| b | Représente une limite de mot |
| B | C'est une frontière sans mot |
Exemple:
import java.util.regex. * public class MetacharExample {public static void main (String args []) {// d signifie chiffre System.out.println ('metacharacters d ....') // (non-digit) System.out.println (Pattern.matches ('d', 'abc')) // Sortie: false // (chiffre et vient une fois) System.out.println (Pattern.matches ('d', '1') ) // Sortie: true // (chiffre mais vient plus d'une fois) System.out.println (Pattern.matches ('d', '4443')) // Sortie: false // (chiffre et caractère) System.out .println (Pattern.matches ('d', '323abc')) // Sortie: false // D signifie non-chiffre System.out.println ('metacharacters D ....') // (non-digit mais vient plus d'une fois) System.out.println (Pattern.matches ('D', 'abc')) // Output: false // C'est un Digit System.out.println (Pattern.matches ('D', '1 ')) // Sortie: false System.out.println (Pattern.matches (' D ',' 4443 ')) // Sortie: false // (chiffre et caractère) System.out.println (Pattern.matches (' D ',' 323abc ')) // Sortie: false // (sans chiffre et vient une fois) System.out.println (Pattern.matches (' D ',' m ')) // Sortie: true System.out .pr intln ('métacaractères D avec quantificateur ....') // (non numérique et peut venir 0 fois ou plus) System.out.println (Pattern.matches ('D *', 'abc')) // Sortie : vrai } }Basé sur les conditions mentionnées ci-dessus, il affichera la sortie. C’est ainsi que cela fonctionne. Donc, il s'agissait de divers types de Regex. Avec cela, nous arrivons à la fin de cet article. jej'espère que vous l'avez trouvé informatif. Si vous souhaitez en savoir plus, vous pouvez consulter notre ainsi que.
Vérifiez par Edureka, une entreprise d'apprentissage en ligne de confiance avec un réseau de plus de 250 000 apprenants satisfaits répartis dans le monde entier. Nous sommes là pour vous aider à chaque étape de votre voyage, pour devenir une autre question d'entrevue java, nous proposons un programme conçu pour les étudiants et les professionnels qui souhaitent devenir développeur Java.
Vous avez une question pour nous? Veuillez le mentionner dans la section commentaires de cet article «Java Regex» et nous vous répondrons dans les plus brefs délais.