Comment vérifier si une chaîne de caractères correspond à une expression régulière en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une chaîne de caractères correspond à une expression régulière en Java. Nous commencerons par comprendre les bases des expressions régulières et à créer un modèle simple à l'aide du package java.util.regex.

Vous explorerez ensuite les classes Pattern et Matcher pour effectuer des opérations de correspondance. Enfin, vous appliquerez vos connaissances pour tester des modèles d'expressions régulières avec des entrées utilisateur, acquérant ainsi une expérience pratique dans l'utilisation des expressions régulières pour la validation et la manipulation de chaînes de caractères en Java.

Créer un motif d'expression régulière de base

Dans cette étape, nous commencerons par comprendre ce que sont les expressions régulières (regex) et comment créer un modèle de base en Java.

Les expressions régulières sont des outils puissants utilisés pour correspondre et manipuler des chaînes de texte. Imaginez-les comme un mini-langage pour décrire des modèles dans le texte. Elles sont incroyablement utiles pour des tâches telles que la recherche de texte spécifique, la validation de formats d'entrée (comme les adresses e-mail ou les numéros de téléphone) et le remplacement de texte en fonction de modèles.

En Java, les expressions régulières sont gérées par le package java.util.regex. Les deux principales classes que nous utiliserons sont Pattern et Matcher.

Pattern : Cette classe représente une expression régulière compilée. Vous compilez une chaîne d'expression régulière en un objet Pattern.
Matcher : Cette classe est utilisée pour effectuer des opérations de correspondance sur une chaîne d'entrée en interprétant un Pattern.

Créons un simple programme Java pour définir et afficher un modèle d'expression régulière de base.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.
Remplacez tout le contenu du fichier par le code suivant :
```
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Print the pattern
        System.out.println("Our regex pattern is: " + pattern.pattern());
    }
}
```
Examinons les nouvelles parties :
- import java.util.regex.Pattern; : Cette ligne importe la classe Pattern, dont nous avons besoin pour travailler avec les expressions régulières.
- String regexPattern = "Java"; : Cette ligne définit une simple variable de chaîne regexPattern qui contient notre expression régulière. Dans ce cas, le modèle est simplement le mot littéral "Java".
- Pattern pattern = Pattern.compile(regexPattern); : C'est ici que nous compilons notre chaîne d'expression régulière en un objet Pattern. La méthode Pattern.compile() prend la chaîne d'expression régulière en argument et renvoie un objet Pattern.
- System.out.println("Our regex pattern is: " + pattern.pattern()); : Cette ligne affiche la chaîne d'expression régulière originale qui a été utilisée pour créer l'objet Pattern. La méthode pattern() de l'objet Pattern renvoie la chaîne d'expression régulière.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilons notre programme. Ouvrez le Terminal en bas de l'éditeur WebIDE et assurez-vous que vous êtes dans le répertoire ~/project. Exécutez la commande suivante :
```
javac HelloJava.java
```
S'il n'y a pas d'erreurs, un fichier HelloJava.class sera créé dans le répertoire ~/project.
Enfin, exécutez le programme compilé :
```
java HelloJava
```
Vous devriez voir la sortie suivante :
```
Our regex pattern is: Java
```
Cela confirme que notre modèle d'expression régulière de base a été correctement défini et compilé. Dans l'étape suivante, nous utiliserons ce modèle pour trouver des correspondances dans une chaîne donnée.

Utiliser les classes Pattern et Matcher

Dans cette étape, vous apprendrez à utiliser la classe Matcher avec votre Pattern pour trouver les occurrences du modèle dans une chaîne d'entrée donnée.

Comme nous l'avons vu dans l'étape précédente, la classe Pattern représente l'expression régulière compilée. La classe Matcher est utilisée pour effectuer les opérations de recherche sur une chaîne d'entrée spécifique en utilisant ce modèle compilé.

Voici comment le processus fonctionne généralement :

Compiler l'expression régulière : Créez un objet Pattern à partir de votre chaîne d'expression régulière en utilisant Pattern.compile().
Créer un Matcher : Obtenez un objet Matcher en appelant la méthode matcher() sur l'objet Pattern et en passant la chaîne d'entrée dans laquelle vous souhaitez effectuer la recherche.
Effectuer la correspondance : Utilisez les méthodes de l'objet Matcher pour trouver les correspondances. Les méthodes courantes incluent find() (pour trouver la prochaine correspondance) et matches() (pour vérifier si l'ensemble de la chaîne d'entrée correspond au modèle).

Modifions notre programme HelloJava.java pour utiliser un Matcher afin de trouver le mot "Java" dans une phrase d'exemple.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

Remplacez le code existant par le code suivant :

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

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // The input string to search within
        String inputString = "Hello, Java! Welcome to Java programming.";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
        }
    }
}

Voici ce qui est nouveau :

import java.util.regex.Matcher; : Nous importons la classe Matcher.
String inputString = "Hello, Java! Welcome to Java programming."; : Nous définissons la chaîne dans laquelle nous souhaitons effectuer la recherche.
Matcher matcher = pattern.matcher(inputString); : Nous créons un objet Matcher en appelant la méthode matcher() sur notre objet pattern et en passant la inputString.
while (matcher.find()) { ... } : Cette boucle utilise la méthode find() du Matcher. La méthode find() tente de trouver la prochaine sous-séquence de la séquence d'entrée qui correspond au modèle. Elle renvoie true si une correspondance est trouvée, et false sinon. La boucle while continue tant que find() renvoie true.
System.out.println("Found match at index: " + matcher.start()); : À l'intérieur de la boucle, si une correspondance est trouvée, matcher.start() renvoie l'indice de départ de la sous-séquence correspondante dans la chaîne d'entrée. Nous affichons cet indice.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le Terminal :
```
javac HelloJava.java
```
Exécutez le programme compilé :
```
java HelloJava
```

Vous devriez voir une sortie similaire à celle-ci :

Searching for pattern: 'Java' in string: 'Hello, Java! Welcome to Java programming.'
Found match at index: 7
Found match at index: 27

Cette sortie montre que notre programme a réussi à trouver deux occurrences du mot "Java" dans la chaîne d'entrée, et qu'il a affiché l'indice de départ de chaque correspondance.

Vous avez maintenant utilisé avec succès les classes Pattern et Matcher pour trouver un modèle spécifique dans une chaîne. Dans l'étape suivante, nous allons rendre ce programme interactif en permettant à l'utilisateur d'entrer la chaîne à rechercher.

Tester une expression régulière avec une entrée utilisateur

Dans cette étape finale, nous allons rendre notre programme d'expressions régulières interactif en permettant à l'utilisateur d'entrer la chaîne dans laquelle il souhaite effectuer la recherche. Cela rendra le programme plus flexible et montrera comment combiner les expressions régulières avec l'interaction utilisateur.

Nous allons utiliser la classe Scanner, que vous vous souvenez peut-être du "Votre premier laboratoire Java", pour lire l'entrée de l'utilisateur.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

Remplacez le code existant par le code suivant :

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

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Prompt the user to enter a string
        System.out.print("Enter the string to search within: ");
        String inputString = scanner.nextLine();

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        boolean found = false;
        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
            found = true;
        }

        if (!found) {
            System.out.println("No match found.");
        }

        // Close the scanner
        scanner.close();
    }
}

Voici les modifications que nous avons apportées :

import java.util.Scanner; : Nous importons la classe Scanner.
Scanner scanner = new Scanner(System.in); : Nous créons un objet Scanner pour lire l'entrée depuis la console.
System.out.print("Enter the string to search within: "); : Nous invitions l'utilisateur à entrer la chaîne.
String inputString = scanner.nextLine(); : Nous lisons toute la ligne d'entrée de l'utilisateur et la stockons dans la variable inputString.
Nous avons ajouté une variable boolean found = false; et un bloc if (!found) pour afficher un message si aucune correspondance n'est trouvée.
scanner.close(); : Nous fermons le Scanner pour libérer les ressources système.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le Terminal :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```

Le programme attendra maintenant que vous entriez une chaîne. Tapez une chaîne qui contient le mot "Java" (ou pas) et appuyez sur Entrée.

Par exemple, si vous entrez :

Learning Java is fun!

La sortie sera :

Enter the string to search within: Learning Java is fun!
Searching for pattern: 'Java' in string: 'Learning Java is fun!'
Found match at index: 9

Si vous entrez :

Python is also great.

La sortie sera :

Enter the string to search within: Python is also great.
Searching for pattern: 'Java' in string: 'Python is also great.'
No match found.

Vous avez maintenant créé avec succès un programme Java interactif qui utilise des expressions régulières pour rechercher un modèle dans une chaîne fournie par l'utilisateur. Ceci est un exemple pratique de l'utilisation des expressions régulières dans des applications du monde réel.

Résumé

Dans ce laboratoire, nous avons commencé par comprendre les bases des expressions régulières (regex) en Java, en nous concentrant sur le package java.util.regex. Nous avons appris que les expressions régulières sont un outil puissant pour la correspondance et la manipulation de motifs dans les chaînes de caractères, et que les classes clés sont Pattern et Matcher. Ensuite, nous avons pratiqué la création d'un motif d'expression régulière de base en définissant une simple chaîne de caractères et en la compilant en un objet Pattern à l'aide de Pattern.compile(), démontrant ainsi comment définir et afficher un motif d'expression régulière de base dans un programme Java.