Les expressions régulières (regex) constituent un outil puissant en Java pour la manipulation de chaînes de caractères. Elles permettent de définir des motifs complexes pour la recherche, la validation, le remplacement et la division de texte, améliorant ainsi l'efficacité et la lisibilité du code.

Le package java.util.regex fournit les classes essentielles pour travailler avec les expressions régulières en Java :

• Pattern : Représente une expression régulière compilée.
• Matcher : Est utilisé pour effectuer des opérations de correspondance de motifs sur une chaîne d'entrée.

Voici un exemple de validation d'adresse e-mail en Java :

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

public class EmailVerifier {

    private static final String EMAIL_PATTERN = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";

    public static boolean checkEmailFormat(String email) {
        Pattern compiledPattern = Pattern.compile(EMAIL_PATTERN);
        Matcher textMatcher = compiledPattern.matcher(email);
        return textMatcher.matches();
    }

    public static void main(String[] args) {
        String testEmail = "test.user@example.com";
        boolean result = checkEmailFormat(testEmail);
        System.out.println("L'adresse e-mail '" + testEmail + "' est valide : " + result);
    }
}

L'expression régulière EMAIL_PATTERN est compilée en un objet Pattern, puis un Matcher est créé pour vérifier si la chaîne d'entrée correspond au motif.

Opérations courantes avec les regex

Recherche de sous-chaînes

Cet exemple montre comment trouver toutes les occurrences d'un mot spécifique dans un texte.

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

public class StringFinder {
    public static void main(String[] args) {
        String content = "Le langage Java est populaire pour le développement web et d'applications mobiles.";
        String keywordRegex = "\\bJava\\b"; // Correspond au mot entier "Java"

        Pattern regexPattern = Pattern.compile(keywordRegex);
        Matcher stringMatcher = regexPattern.matcher(content);

        System.out.println("Occurrences trouvées :");
        while (stringMatcher.find()) {
            System.out.println(" - Début : " + stringMatcher.start() + ", Fin : " + stringMatcher.end());
        }
    }
}

La méthode find() du Matcher permet d'itérer sur toutes les correspondances.

Remplacement de texte

Voici comment remplacer une partie d'une chaîne basée sur un motif.

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

public class TextReplacer {
    public static void main(String[] args) {
        String originalText = "La couleur principale est le bleu.";
        String targetRegex = "\\bbleu\\b";
        String replacementText = "vert";

        Pattern patternToReplace = Pattern.compile(targetRegex);
        Matcher textMatcher = patternToReplace.matcher(originalText);

        String modifiedText = textMatcher.replaceAll(replacementText);
        System.out.println("Texte modifié : " + modifiedText);
    }
}

La méthode replaceAll() remplace toutes les occurrences trouvées par la chaîne de remplacement.

Division de chaînes

Les expressions régulières peuvent aussi servir de délimiteurs pour diviser une chaîne.

import java.util.regex.Pattern;

public class StringSplitter {
    public static void main(String[] args) {
        String dataString = "pomme,banane;orange|raisin";
        String delimiterRegex = "[,;|]"; // Sépare par virgule, point-virgule ou barre verticale

        Pattern splitPattern = Pattern.compile(delimiterRegex);
        String[] elements = splitPattern.split(dataString);

        System.out.println("Éléments séparés :");
        for (String element : elements) {
            System.out.println("- " + element);
        }
    }
}

La méthode split() de la classe Pattern retourne un tableau de chaînes résultant de la division.

Application avancée : Validation d'adresses IP

Valider une adresse IPv4 nécessite une expression régulière plus complexe.

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

public class IpAddressChecker {

    // Regex pour valider une adresse IPv4
    private static final String IPV4_REGEX = 
        "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$";

    public static boolean validateIpv4(String ipAddress) {
        Pattern ipPattern = Pattern.compile(IPV4_REGEX);
        Matcher ipMatcher = ipPattern.matcher(ipAddress);
        return ipMatcher.matches();
    }

    public static void main(String[] args) {
        String testIp = "192.168.0.255";
        boolean isValid = validateIpv4(testIp);
        System.out.println("L'adresse IP '" + testIp + "' est valide : " + isValid);
    }
}

Cette expression régulière décompose la structure d'une adresse IPv4, validant chaque octet et les séparateurs.