Travailler avec des expressions régulières en Java

Dans les systèmes d'information d'aujourd'hui, il est normal de voir des fonctions de recherche, ces fonctions doivent à chaque fois traiter motifs de bien d'autres complexes. Pour pouvoir considérer chaque cas en particulier, il faudrait quelques milliers d'années, c'est pourquoi des mécanismes ont été développés qui permettent d'établir une représentation formulée des recherches.
Ces formules se trouvent dans le expressions régulières, qui nous permettent d'établir des modèles d'évaluation des chaînes de texte et de renvoyer une valeur positive ou négative si ladite chaîne correspond ou non à la formule exprimée.
Dans Java On peut implémenter des expressions régulières de manière simple, mais cela nécessite une étude assez poussée de la part du développeur afin qu'il puisse apprendre les différents éléments dont il dispose.
La manière dont nous pouvons exprimer les formules avec lesquelles nous pouvons tester nos modèles avec une construction de code particulière, nous allons l'appeler le syntaxe des expressions régulières.
Que nous permet la syntaxe ?Ce que la syntaxe nous permet, c'est d'établir des patrons par type de caractère, quantité, combinaison de caractère et de quantités, commencez par un élément particulier, définissez une expression pour le centre de la formule et une fin. Avec cela, nous pouvons identifier des modèles très spécifiques qui peuvent être nécessaires dans notre programme ou peut-être filtrer de manière plus adéquate une recherche sur un texte ou une base de données.
Voyons ci-dessous une petite liste des éléments les plus utilisés dans les expressions régulières avec Java, il y a beaucoup plus d'éléments que ceux montrés dans ce tutoriel, il est donc recommandé de faire vos propres recherches pour renforcer les connaissances :
Début de ligne\^ Avec cet élément, nous procédons à indiquer à Java qui commence une ligne dans l'expression régulière.
Fin de ligne$ Avec ce symbole, nous indiquons que nous avons terminé la ligne.
Liste des personnages[] Avec des crochets, nous indiquons à l'expression régulière qu'elle doit rechercher l'une des listes à l'intérieur.
Exclure[\^] Il nous permet de sélectionner n'importe quel personnage qui n'est pas répertorié.
Quantificateur{j, k} Localisez ce qu'il y a dans j le nombre de fois indiqué k; {j,} dans ce second cas, quoi qu'il en soit j une ou plusieurs fois; finalement {j} indique que ce qui est dans doit apparaître j une fois seulement.
Caractères de mots\ w Repérez les personnages qui appartiennent à mot, mais si on utilise \ W il fait le contraire localise les caractères qui n'appartiennent pas.
Chiffres\ ré Cela nous permet de faire des correspondances avec uniquement des chiffres et si nous utilisons \ RÉ nous ferons correspondre tout ce qui n'est pas un chiffre ou un caractère numérique.
Blancs\ s Cela nous permet de faire correspondre les espaces vides tels que les tabulations, la barre d'espace, mais si nous utilisons \ S fait le contraire, il correspond à tout ce qui n'est pas un espace blanc.
Comme on peut le voir avec ces quelques éléments on peut construire diverses combinaisons avec lesquelles on peut arriver à obtenir des motifs relativement complexes.
Si nous voulons en essayer un expression régulière Avant de compiler un programme, nous pouvons utiliser la page rubular.com où nous pouvons évaluer les modèles en temps réel.

AGRANDIR

Nous allons réaliser un exemple simple où nous allons tester un expression régulière pour valider un email, nous utiliserons les éléments suivants :

[_ a-z0-9 -] + (\. [_ a-z0-9 -] +) * @ [a-z0-9 -] + (\. [a-z0-9 -] +) * (\ . [az] {2,3}) $

Il faut d'abord saisir l'expression régulière dans le premier champ du formulaire de la page de rubular.com puis dans le champ appelé votre chaîne de test C'est là que nous allons tester différents e-mails pour vérifier que l'expression régulière fonctionne, voyons comment le validateur se comporte lorsque nous saisissons un e-mail invalide :

AGRANDIR

Comme nous pouvons le voir dans notre exemple d'e-mail il manque le point, il est donc invalide et non ne génère aucune correspondance Avec l'expression régulière, nous allons la corriger en plaçant le point manquant et le validateur génère automatiquement une réponse positive nous permettant de voir que notre expression régulière fonctionne sans problème.

AGRANDIR

Comme nous pouvons le voir, c'est une ressource très utile lorsque nous apprenons à utiliser des expressions régulières non seulement dans Java sinon dans n'importe quelle langue.
Une fois que nous savons ce que fait chacun des éléments de base de la syntaxe, nous devons maintenant apprendre comment nous pouvons faire un rechercher un modèle dans Java, avec cela, nous pouvons voir quelles méthodes, classes et packages entrent en jeu lorsque nous utilisons des expressions régulières.
La première chose que nous devons savoir est que tous ces utilitaires sont dans le package java.util.regex, donc pour faire ces exemples, nous devons inclure ce package au début de nos cours.
Une fois ce qui précède est fait, nous pouvons tester un modèle de la manière suivante :

 if (ourString.matches (ourExpression)) {// Si cela correspond ici, nous exécutons un code} 

On voit qu'on utilise la méthode allumettes (), cela évaluera la chaîne de caractères par rapport au modèle regex et retournera vrai ou alors faux, au cas où la chaîne de caractères correspond au modèle ou non.
Ce type d'utilisation convient bien dans les petites validations, cependant si nous allons utiliser une validation récurrente, c'est-à-dire qu'elle apparaîtra plusieurs fois dans notre programme, il est préférable de créer une petite routine ou classe qui nous permet d'évaluer la chaîne de forme paramétrique, c'est-à-dire une routine ou une méthode qui nous permet d'entrer une chaîne et de retourner vrai ou faux, en comparant déjà avec un modèle particulier.
Dans le programme suivant, nous allons tester un petit motif et nous allons l'évaluer par rapport à quelques chaînes et le programme nous dira laquelle il fait. correspondre, c'est-à-dire, laquelle correspond et laquelle ne correspond pas, voyons le code et nous verrons ensuite comment cela fonctionne :

 importer java.util.regex.*; public class TestPatterns {public static void main (String [] argv) {String pattern = "Q [u] \ d + \."; String [] input = {"QA777. Est l'identifiant de notre produit.", "Coin, couac, couac!" }; Motif p = Motif.compile (motif); for (String in: input) {boolean found = p.matcher (in) .lookingAt (); System.out.println ("'" + motif + "'" + (trouvé? "Correspondances'": "ne correspond pas à '") + in + "'"); }}} 

Ici, nous voyons comment la première chose que nous faisons est d'importer le package mentionné au début de cette section, afin d'obtenir ainsi les fonctionnalités de la recherche par expressions régulières. Ensuite, nous construisons un motif que nous utiliserons dans notre programme, dans ce cas il s'agit d'un motif qui correspond à la lettre "Q"Alors il doit avoir n'importe quel caractère sauf la lettre"ou alors« Et doit se terminer par un point. Ensuite, nous compilons notre modèle en utilisant la méthode compiler et nous pouvons l'utiliser pour faire les matchs. Enfin, si le motif correspond, il est imprimé avec le mot coïncide sinon on imprime ce n'est pas coïncidant.
Voyons dans l'image suivante à quoi cela ressemble lorsque nous exécutons le programme :

AGRANDIR

Nous notons ensuite, comme expliqué, la première chaîne ou chaîne si elle correspond, mais pas la seconde, et pour référence ultérieure, nous plaçons le motif sur lequel la comparaison doit être effectuée.
Nous allons maintenant réaliser un exemple plus avancé, nous allons identifier quelle partie de notre chaîne correspond, c'est très utile lorsque nous faisons des recherches de texte, car avec cela nous pourrions mettre en évidence les correspondances de ce que l'utilisateur entre.
Pour cela nous allons utiliser la même base de notre programme précédent avec quelques modifications, voyons le code puis l'explication de celui-ci :

 importer java.util.regex.*; public class Match {public static void main (String [] argv) {String pattern = "Q [u] \ d + \."; Motif r = Motif.compile (motif); String text = "L'identifiant est : QW990. Fin du test !"; Matcher m = r.matcher (texte); if (m.find ()) {System.out.println (pattern + "matches \" "+ m.group (0) +" \ "inside \" "+ text +" \ ""); } else {System.out.println ("Aucune correspondance"); }}} 

Une fois de plus, nous voyons comment nous commençons notre programme, y compris le package java.util.regex.*. Ensuite, nous utilisons le même modèle du programme précédent et le compilons avec la méthode compiler, la chose intéressante vient maintenant, nous avons utilisé la méthode matcher () pour localiser la correspondance puis avec la méthode trouver () et la méthode grouper () on peut extraire exactement ce qui correspond, enfin on fait les sérigraphies correspondantes. Voyons à quoi ressemble notre programme maintenant :

AGRANDIR

Ainsi voyons-nous alors comment nous avons pu isoler le mot qui correspond vraiment au schéma que nous avons arrangé pour la comparaison des expression régulière.
L'une des applications les plus utilisées se trouve sur le formes, où nous pouvons faire des validations de e-mails, numéros de téléphone, cartes de crédit, mots de passe, adresses IP, noms d'utilisateur, codes postaux et même valider que toutes nos balises dans notre document HTML sont correctement fermées, ce qui nous donne la possibilité d'atteindre une plus grande sécurité dans notre traitement des textes saisis par les utilisateurs.
Mais pas seulement dans les validations dans les champs d'un formulaire, comme nous l'avons remarqué dans notre dernier exemple, nous pouvons également faire longues recherches de texte Par un motif particulier, avec lui, nous pouvons rechercher dans des documents texte très complexes de manière systématique et ainsi gagner beaucoup de temps, simplement en écrivant un petit programme.
Avec cela, nous terminons ce tutoriel, nous avons appris comment nous pouvons passer d'avoir différents éléments pour exprimer des situations au sein de nos modèles à faire efficacement les comparaisons correspondantes du texte ou des caractères que nous voulons évaluer, tout cela grâce au expressions régulières. Ces évaluations sont assez rapides grâce aux optimisations que le langage fait dans les méthodes qu'il nous propose, elles sont donc très adaptées à la construction d'interfaces où nous devons rechercher et valider le texte que l'utilisateur saisit.Avez-vous aimé et aidé ce tutoriel ?Vous pouvez récompenser l'auteur en appuyant sur ce bouton pour lui donner un point positif