Expression régulière en Java – Exemple de Regex Java

Bienvenue dans les expressions régulières en Java. Elles sont également appelées Regex en Java. Quand j’ai commencé à programmer, les expressions régulières en Java étaient un cauchemar pour moi. Ce tutoriel vise à vous aider à maîtriser les expressions régulières en Java. Je reviendrai également ici pour rafraîchir mes connaissances sur les Regex en Java.

Expressions régulières en Java

L’expression régulière en Java définit un motif pour une chaîne de caractères. Les expressions régulières peuvent être utilisées pour rechercher, modifier ou manipuler du texte. Une expression régulière n’est pas spécifique à un langage, mais elles diffèrent légèrement pour chaque langage. Les expressions régulières en Java sont très similaires à Perl. Les classes Regex en Java sont présentes dans le package java.util.regex qui contient trois classes :

1. Pattern : L’objet Pattern est la version compilée de l’expression régulière. La classe Pattern n’a pas de constructeur public et nous utilisons sa méthode statique publique compile pour créer l’objet pattern en passant l’argument de l’expression régulière.
2. Matcher: Matcher est l’objet moteur d’expressions régulières Java qui correspond au motif de chaîne d’entrée avec l’objet de motif créé. La classe Matcher n’a pas de constructeur public et nous obtenons un objet Matcher en utilisant la méthode matcher de l’objet de motif qui prend la chaîne d’entrée comme argument. Ensuite, nous utilisons la méthode matches qui renvoie un résultat booléen basé sur la correspondance de la chaîne d’entrée avec le motif regex ou non.
3. PatternSyntaxException: PatternSyntaxException est levée si la syntaxe de l’expression régulière n’est pas correcte.

Jetons un coup d’œil à un exemple de programme Java Regex.

package com.journaldev.util;

import java.util.regex.*;

public class PatternExample {

	public static void main(String[] args) {
		Pattern pattern = Pattern.compile(".xx.");
		Matcher matcher = pattern.matcher("MxxY");
		System.out.println("Input String matches regex - "+matcher.matches());
		// mauvaise expression régulière
		pattern = Pattern.compile("*xx*");

	}

}

Lorsque nous exécutons ce programme d’exemple de regex Java, nous obtenons la sortie ci-dessous.

Input String matches regex - true
Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
*xx*
^
	at java.util.regex.Pattern.error(Pattern.java:1924)
	at java.util.regex.Pattern.sequence(Pattern.java:2090)
	at java.util.regex.Pattern.expr(Pattern.java:1964)
	at java.util.regex.Pattern.compile(Pattern.java:1665)
	at java.util.regex.Pattern.(Pattern.java:1337)
	at java.util.regex.Pattern.compile(Pattern.java:1022)
	at com.journaldev.util.PatternExample.main(PatternExample.java:13)

Étant donné que l’expression régulière Java tourne autour de la classe String, la classe String a été étendue en Java 1.4 pour fournir une méthode matches qui effectue une correspondance de motifs regex. En interne, elle utilise les classes regex Java Pattern et Matcher pour effectuer le traitement, mais évidemment elle réduit les lignes de code. La classe Pattern contient également la méthode matches qui prend un regex et une chaîne d’entrée comme arguments et renvoie un résultat booléen après les avoir mis en correspondance. Donc, le code ci-dessous fonctionne bien pour mettre en correspondance une chaîne d’entrée avec une expression régulière en Java.

String str = "bbb";
System.out.println("Using String matches method: "+str.matches(".bb"));
System.out.println("Using Pattern matches method: "+Pattern.matches(".bb", str));

Alors, si votre exigence est simplement de vérifier si la chaîne d’entrée correspond au motif, vous devriez gagner du temps et des lignes de code en utilisant la méthode de correspondance de chaînes simple. Vous devriez utiliser les classes Pattern et Matches uniquement lorsque vous avez besoin de manipuler la chaîne d’entrée ou lorsque vous devez réutiliser le motif. Notez que le motif défini par regex est appliqué sur la chaîne de gauche à droite et une fois qu’un caractère source est utilisé dans une correspondance, il ne peut pas être réutilisé. Par exemple, la regex « 121 » correspondra à « 31212142121 » seulement deux fois comme « _121____121 ».

Expression régulière en Java – symboles de correspondance courants

Métacaractères Java Regex

Nous avons quelques métacaractères dans Java regex, c’est comme des codes courts pour des motifs de correspondance courants.

Il existe deux façons d’utiliser les métacaractères comme des caractères ordinaires dans les expressions régulières.

1. Précédez le métacaractère d’un antislash (\).
2. Gardez le métacarctère entre \Q (qui commence la citation) et \E (qui la termine).

Expression Régulière en Java – Quantificateurs

Les quantificateurs Java Regex spécifient le nombre d’occurrences d’un caractère à rechercher.

Les quantificateurs Java Regex peuvent également être utilisés avec des classes de caractères et des groupes de capture. Par exemple, [abc]+ signifie – a, b ou c – une ou plusieurs fois. (abc)+ signifie le groupe « abc » une ou plusieurs fois. Nous allons discuter des Groupes de Capture maintenant.

Expression Régulière en Java – Groupes de Capture

Les groupes de capture de l’expression régulière en Java sont utilisés pour traiter plusieurs caractères comme une seule unité. Vous pouvez créer un groupe en utilisant (). La portion de la chaîne d’entrée qui correspond au groupe de capture est enregistrée en mémoire et peut être rappelée en utilisant Référence arrière. Vous pouvez utiliser la méthode matcher.groupCount pour connaître le nombre de groupes de capture dans un motif regex Java. Par exemple, ((a)(bc)) contient 3 groupes de capture – ((a)(bc)), (a) et (bc). Vous pouvez utiliser Référence arrière dans l’expression régulière avec un antislash (\) suivi du numéro du groupe à rappeler. Les groupes de capture et les références arrière peuvent être déroutants, alors comprenons cela avec un exemple.

System.out.println(Pattern.matches("(\\w\\d)\\1", "a2a2")); //true
System.out.println(Pattern.matches("(\\w\\d)\\1", "a2b2")); //false
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B2AB")); //true
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B3AB")); //false

Dans le premier exemple, à runtime, le premier groupe de capture est (\w\d) qui s’évalue à « a2 » lorsqu’il correspond à la chaîne d’entrée « a2a2 » et est enregistré en mémoire. Ainsi, \1 fait référence à « a2 » et donc renvoie vrai. Pour la même raison, la deuxième déclaration imprime faux. Essayez de comprendre ce scénario pour les déclarations 3 et 4 vous-même. 🙂 Maintenant, nous allons examiner quelques méthodes importantes des classes Pattern et Matcher.

1. On peut créer un objet Pattern avec des indicateurs. Par exemple, Pattern.CASE_INSENSITIVE permet une correspondance insensible à la casse.
2. La classe Pattern fournit également une méthode split(String) similaire à la méthode split() de la classe String.
3. La méthode toString() de la classe Pattern retourne la chaîne d’expression régulière à partir de laquelle ce modèle a été compilé.
4. Les classes Matcher ont des méthodes d’index start() et end() qui montrent précisément où la correspondance a été trouvée dans la chaîne d’entrée.
5. La classe Matcher fournit également des méthodes de manipulation de chaîne replaceAll(String replacement) et replaceFirst(String replacement).

Examinons ces méthodes regex Java dans un exemple de programme simple.

package com.journaldev.util;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexExamples {

	public static void main(String[] args) {
		// en utilisant un modèle avec des indicateurs
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		// en utilisant les méthodes find(), group(), start() et end() de Matcher
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		// en utilisant la méthode Pattern split()
		pattern = Pattern.compile("\\W");
		String[] words = pattern.split("one@two#three:four$five");
		for (String s : words) {
			System.out.println("Split using Pattern.split(): " + s);
		}

		// en utilisant les méthodes Matcher.replaceFirst() et replaceAll()
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}

}

La sortie du programme d’exemple de regex Java ci-dessus est.

Found the text "AB" starting at 0 index and ending at index 2
Found the text "ab" starting at 3 index and ending at index 5
Found the text "Ab" starting at 6 index and ending at index 8
Split using Pattern.split(): one
Split using Pattern.split(): two
Split using Pattern.split(): three
Split using Pattern.split(): four
Split using Pattern.split(): five
Using replaceAll: _345_678
Using replaceFirst: _34512678

C’est tout pour les expressions régulières en Java. Les expressions régulières en Java semblent difficiles au début, mais si vous travaillez avec elles pendant un certain temps, il est facile d’apprendre et de les utiliser.

Vous pouvez consulter le code complet et d’autres exemples d’expressions régulières depuis notre Dépôt GitHub.