Java Academy · Leçon

Expressions régulières avec Pattern et Matcher

Validez des adresses e-mail, extrayez des sous-chaînes et remplacez des motifs à l’aide des expressions régulières de Java.

Expressions régulières avec Pattern et Matcher est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Expressions régulières : compilation et mise en correspondance

Le paquetage java.util.regex de Java fournit des outils puissants pour la recherche, la validation, l'extraction et le remplacement de texte à l'aide d'expressions régulières.

Pourquoi utiliser des expressions régulières ?

Les expressions régulières sont des motifs servant à rechercher du texte. Dans Java, elles servent à valider des adresses e-mail et des numéros de téléphone, à extraire des données de journaux et à analyser du texte structuré.

import java.util.regex.*;

// Is this a valid email?
String email = "alice@example.com";
boolean valid = email.matches("[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}");
System.out.println(valid); // true

// Extract version numbers from a string
String log = "App v1.2.3 deployed; api v2.0.0 started";
Pattern p = Pattern.compile("v(\\d+\\.\\d+\\.\\d+)");
Matcher m = p.matcher(log);
while (m.find()) System.out.println(m.group(1));
// 1.2.3 
// 2.0.0

Bases de la syntaxe des expressions régulières

Principaux métacaractères des expressions régulières :

. — n'importe quel caractère
\d — chiffre ; \w — caractère alphanumérique ; \s — espace blanc
* — 0 ou plus ; + — 1 ou plus ; ? — 0 ou 1
{n,m} — entre n et m fois
^/$ — début/fin de ligne
[abc] — classe de caractères

// In Java strings, backslash must be doubled: \d = "\\d"
Pattern digit   = Pattern.compile("\\d+");      // one or more digits
Pattern word    = Pattern.compile("\\w{3,20}");  // 3-20 word chars
Pattern space   = Pattern.compile("\\s+");       // whitespace
Pattern phone   = Pattern.compile("\\d{3}-\\d{3}-\\d{4}"); // 555-867-5309

System.out.println(digit.matcher("42").matches());       // true
System.out.println(phone.matcher("555-867-5309").matches()); // true

Pattern.compile et mise en correspondance

Compilez un motif une fois et réutilisez l'objet de mise en correspondance pour plusieurs entrées : c'est plus efficace que d'utiliser String.matches() pour des validations répétées.

import java.util.regex.*;

Pattern emailPattern = Pattern.compile(
    "^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,6}$"
);

String[] emails = {"alice@example.com", "bad@", "test.user@co.uk", "no-at-sign"};
for (String e : emails) {
    Matcher m = emailPattern.matcher(e);
    System.out.println(e + " -> " + (m.matches() ? "valid" : "invalid"));
}

find() contre matches()

matches() teste la chaîne entière. find() recherche l'occurrence suivante dans la chaîne. Utilisez find pour rechercher et matches pour valider la chaîne entière.

import java.util.regex.*;

Pattern price = Pattern.compile("\\d+\\.\\d{2}");

String invoice = "Total: 129.99, Tax: 10.40, Shipping: 5.00";
Matcher m = invoice.matcher(invoice);

// find() locates all matches
while (m.find()) {
    System.out.println("Found: " + m.group() + " at " + m.start());
}
// Found: 129.99 at 7
// Found: 10.40 at 20
// Found: 5.00 at 34

Groupes de capture

Les parenthèses créent des groupes de capture. Utilisez group(n) pour extraire les sous-chaînes correspondantes.

import java.util.regex.*;

Pattern date = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
Matcher m = date.matcher("Deployed on 2024-06-15 and 2024-07-01");

while (m.find()) {
    String year  = m.group(1);
    String month = m.group(2);
    String day   = m.group(3);
    System.out.println(year + "/" + month + "/" + day);
}
// 2024/06/15
// 2024/07/01

Groupes nommés

Les groupes nommés (?<name>...) rendent les groupes de capture plus lisibles et permettent d'y accéder par leur nom.

import java.util.regex.*;

Pattern log = Pattern.compile(
    "(?<timestamp>\\d{4}-\\d{2}-\\d{2}) (?<level>[A-Z]+) (?<message>.+)"
);

String line = "2024-06-15 ERROR Database connection failed";
Matcher m = log.matcher(line);

if (m.matches()) {
    System.out.println("Time: "    + m.group("timestamp"));
    System.out.println("Level: "   + m.group("level"));
    System.out.println("Message: " + m.group("message"));
}
// Time: 2024-06-15
// Level: ERROR
// Message: Database connection failed

replaceAll et replaceFirst

Remplacement fondé sur un motif : remplacer toutes les occurrences ou uniquement la première.

import java.util.regex.*;

String text = "Call us at 123-456-7890 or 098-765-4321";

// Mask phone numbers for privacy logs
String masked = text.replaceAll("\\d{3}-\\d{3}-\\d{4}", "XXX-XXX-XXXX");
System.out.println(masked);
// Call us at XXX-XXX-XXXX or XXX-XXX-XXXX

// Replace multiple whitespace with single space
String cleaned = "too   many   spaces".replaceAll("\\s+", " ");
System.out.println(cleaned); // too many spaces

split() avec une expression régulière

String.split() accepte une expression régulière. Utilisez-le pour diviser du texte selon plusieurs délimiteurs ou des séparateurs complexes.

// Split on comma with optional spaces
String csv = "Alice, Bob,  Charlie,Diana";
String[] names = csv.split("\\s*,\\s*");
for (String name : names) System.out.println("'" + name + "'");
// 'Alice' 'Bob' 'Charlie' 'Diana'

// Split on any whitespace
String words = "one  two\tthree  four";
String[] parts = words.split("\\s+");
System.out.println(parts.length); // 4

// Limit splits
String line = "key=value=extra";
String[] kv = line.split("=", 2); // [key, value=extra]

Indicateurs des expressions régulières

Les indicateurs modifient le comportement des expressions régulières : insensibilité à la casse, MULTILINE et DOTALL.

import java.util.regex.*;

// Case-insensitive match
Pattern p = Pattern.compile("hello", Pattern.CASE_INSENSITIVE);
System.out.println(p.matcher("HELLO World").find()); // true

// MULTILINE: ^ and $ match line boundaries
Pattern multi = Pattern.compile("^ERROR", Pattern.MULTILINE);
String logs = "INFO start\nERROR crash\nINFO end";
Matcher m = multi.matcher(logs);
int count = 0;
while (m.find()) count++;
System.out.println("ERROR lines: " + count); // 1

Cas pratique : analyseur de journaux

Analyser des lignes de journaux d'accès au format Apache avec des groupes nommés.

import java.util.regex.*;

Pattern accessLog = Pattern.compile(
    "(?<ip>[\\d.]+) - - \\[(?<time>[^\\]]+)\\] " +
    "\"(?<method>[A-Z]+) (?<path>[^ ]+)[^\"]*\" " +
    "(?<status>\\d{3}) (?<bytes>\\d+)"
);

String line = "192.168.1.1 - - [27/May/2024:10:30:00 +0000] \"GET /api/products HTTP/1.1\" 200 1024";
Matcher m = accessLog.matcher(line);
if (m.matches()) {
    System.out.println("IP: "     + m.group("ip"));
    System.out.println("Method: " + m.group("method"));
    System.out.println("Status: " + m.group("status"));
}

Vérification rapide

Quelle est la différence entre matches() et find() dans l'objet de mise en correspondance ?

Récapitulatif : expressions régulières, compilation et mise en correspondance

Points essentiels :

Pattern.compile() compile une expression régulière ; l'objet de mise en correspondance la teste sur des chaînes
matches() valide la chaîne entière ; find() recherche des occurrences
Les groupes de capture () extraient des sous-chaînes ; utilisez group(n) ou group("nom") pour y accéder
Les groupes nommés (?<name>...) rendent les motifs plus lisibles
replaceAll() et split() acceptent des motifs d'expressions régulières pour une manipulation flexible du texte
Utilisez les indicateurs d'insensibilité à la casse, MULTILINE et DOTALL pour modifier le comportement des recherches

Questions Fréquemment Posées

La leçon « Expressions régulières avec Pattern et Matcher » est-elle gratuite ?

Oui — le texte complet de « Expressions régulières avec Pattern et Matcher » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Expressions régulières avec Pattern et Matcher » ?

Validez des adresses e-mail, extrayez des sous-chaînes et remplacez des motifs à l’aide des expressions régulières de Java. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Expressions régulières avec Pattern et Matcher » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Immutabilité des chaînes et pool de chaînes
StringBuilder pour une concaténation efficace
Blocs de texte et String.format
Expressions régulières avec Pattern et Matcher

← Retour à Java Academy