Java Regex - Que sont les expressions régulières et comment l'utiliser?

Java Regex est une API utilisée pour définir un modèle de recherche ou de manipulation de chaînes. Cet article parlera également de différentes classes d'expressions régulières fournies par Java.

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:



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.

Expressions régulières - Java Regex - Edureka



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 personnageLa 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.

RegexLa 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.

RegexLa description
. Il peut s'agir de n'importe quel caractère (peut ou non correspondre au terminateur)
Représente tous les chiffres, à l'exception de [0-9]
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.