Comment vérifier si une chaîne de caractères contient des caractères spéciaux en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une chaîne de caractères contient des caractères spéciaux en Java en utilisant des expressions régulières (regular expressions). Nous commencerons par définir les caractères spéciaux à l'aide de motifs d'expressions régulières (regex patterns), en comprenant les caractères spéciaux courants et leur utilisation.

Après avoir défini les caractères spéciaux, vous explorerez comment utiliser la méthode Pattern.matches() pour déterminer efficacement si une chaîne de caractères contient l'un des caractères spéciaux définis. Enfin, vous apprendrez à compter le nombre d'occurrences de caractères spéciaux dans une chaîne de caractères donnée, ce qui vous offrira une compréhension complète de la gestion des caractères spéciaux en Java.

Définir les caractères spéciaux avec des expressions régulières (regex)

Dans cette étape, nous apprendrons à définir les caractères spéciaux à l'aide d'expressions régulières (regex) en Java. Les expressions régulières sont des outils puissants pour la correspondance de motifs dans les chaînes de caractères. Les caractères spéciaux dans les expressions régulières ont des significations spécifiques et sont utilisés pour définir des motifs.

Voici quelques caractères spéciaux courants dans les expressions régulières :

. : Correspond à n'importe quel caractère unique (sauf le caractère de nouvelle ligne).
* : Correspond à l'élément précédent zéro fois ou plus.
+ : Correspond à l'élément précédent une fois ou plus.
? : Correspond à l'élément précédent zéro ou une fois.
[] : Correspond à n'importe quel caractère unique contenu entre les crochets.
| : Agit comme un opérateur OU.
() : Regroupe des éléments ensemble.
\ : Échappe un caractère spécial, le faisant correspondre au caractère littéral.

Par exemple, si nous voulons correspondre à n'importe quel chiffre, nous pouvons utiliser \d. Si nous voulons correspondre à n'importe quel caractère non-chiffre, nous utilisons \D. De même, \s correspond à n'importe quel caractère d'espace blanc, et \S correspond à n'importe quel caractère non-espace blanc.

Créons un simple programme Java pour démontrer comment définir un motif d'expression régulière pour les caractères spéciaux.

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.Matcher;
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        String text = "Hello! This is a test string with some special characters: @#$%^&*()_+";
        // Define a regex pattern to match special characters
        String regex = "[^a-zA-Z0-9\\s]";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);

        System.out.println("Original String: " + text);
        System.out.println("Regex Pattern: " + regex);

        System.out.print("Special characters found: ");
        while (matcher.find()) {
            System.out.print(matcher.group() + " ");
        }
        System.out.println(); // Print a newline at the end
    }
}
```
Comprenons les nouvelles parties de ce code :
- import java.util.regex.Matcher; et import java.util.regex.Pattern; : Ces lignes importent les classes nécessaires pour travailler avec les expressions régulières en Java.
- String regex = "[^a-zA-Z0-9\\s]"; : Cette ligne définit notre motif d'expression régulière.
  - [] : Il s'agit d'une classe de caractères, ce qui signifie qu'elle correspondra à n'importe quel caractère unique contenu entre les crochets.
  - ^ : Lorsqu'il est utilisé au début d'une classe de caractères ([^...]), il inverse la classe, ce qui signifie qu'elle correspondra à n'importe quel caractère n'étant pas dans la classe.
  - a-zA-Z0-9 : Cela correspond à n'importe quelle lettre minuscule (de a à z), n'importe quelle lettre majuscule (de A à Z) ou n'importe quel chiffre (de 0 à 9).
  - \\s : Cela correspond à n'importe quel caractère d'espace blanc (espace, tabulation, nouvelle ligne, etc.). Nous utilisons \\ car \ est un caractère spécial dans les chaînes de caractères Java et doit être échappé.
  - Ainsi, l'ensemble du motif [^a-zA-Z0-9\\s] correspond à n'importe quel caractère qui n'est pas une lettre, un chiffre ou un caractère d'espace blanc. Ce sont nos "caractères spéciaux" dans ce contexte.
- Pattern pattern = Pattern.compile(regex); : Cette ligne compile le motif d'expression régulière en un objet Pattern. Compiler le motif améliore les performances si vous utilisez le même motif plusieurs fois.
- Matcher matcher = pattern.matcher(text); : Cette ligne crée un objet Matcher, qui est utilisé pour effectuer des opérations de correspondance sur la chaîne d'entrée (text) en utilisant le motif compilé.
- while (matcher.find()) : Cette boucle trouve la prochaine sous-séquence de la séquence d'entrée qui correspond au motif.
- matcher.group() : Cela renvoie la sous-séquence correspondante.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme en utilisant la commande javac dans le terminal :
```
javac HelloJava.java
```

Exécutez le programme compilé en utilisant la commande java :

java HelloJava

Vous devriez voir une sortie similaire à celle-ci :

Original String: Hello! This is a test string with some special characters: @#$%^&*()_+
Regex Pattern: [^a-zA-Z0-9\s]
Special characters found: ! : @ ## $ % ^ & * ( ) _ +

Vous avez réussi à définir un motif d'expression régulière pour identifier les caractères spéciaux et l'avez utilisé dans un programme Java.

Utiliser Pattern.matches() pour les caractères spéciaux

Dans cette étape, nous explorerons une autre façon d'utiliser les expressions régulières en Java : la méthode Pattern.matches(). Contrairement à l'objet Matcher que nous avons utilisé dans l'étape précédente pour trouver toutes les occurrences d'un motif, Pattern.matches() vérifie si l'ensemble de la chaîne d'entrée correspond à l'expression régulière donnée.

Cette méthode est utile lorsque vous souhaitez valider si une chaîne de caractères respecte un format spécifique, par exemple, vérifier si un mot de passe contient au moins un caractère spécial ou si un nom d'utilisateur ne contient que des caractères autorisés.

Modifions notre programme HelloJava.java pour utiliser Pattern.matches() afin de vérifier si une chaîne de caractères contient au moins un caractère spécial en fonction de l'expression régulière que nous avons définie précédemment.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
Remplacez le code existant par le code suivant :
```
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        String text1 = "Hello World";
        String text2 = "Hello World!";
        // Define a regex pattern to check for the presence of special characters
        // This pattern checks if the string contains at least one character that is NOT a letter, digit, or whitespace
        String regex = ".*[^a-zA-Z0-9\\s].*";

        boolean containsSpecial1 = Pattern.matches(regex, text1);
        boolean containsSpecial2 = Pattern.matches(regex, text2);

        System.out.println("String 1: \"" + text1 + "\"");
        System.out.println("Contains special characters? " + containsSpecial1);

        System.out.println("String 2: \"" + text2 + "\"");
        System.out.println("Contains special characters? " + containsSpecial2);
    }
}
```
Examinons les modifications :
- Nous avons seulement besoin d'importer java.util.regex.Pattern; pour cette méthode.
- Le motif d'expression régulière est maintenant .*[^a-zA-Z0-9\\s].*. Décortiquons-le :
  - .* : Cela correspond à n'importe quel caractère (.) zéro fois ou plus (*). Le premier .* correspond à tout ce qui précède le caractère spécial.
  - [^a-zA-Z0-9\\s] : Il s'agit de la même classe de caractères que dans l'étape précédente, correspondant à un seul caractère spécial.
  - .* : Cela correspond à n'importe quel caractère (.) zéro fois ou plus (*). Le deuxième .* correspond à tout ce qui suit le caractère spécial.
  - Ensemble, .*[^a-zA-Z0-9\\s].* signifie "correspondre à n'importe quelle chaîne qui contient au moins un caractère qui n'est pas une lettre, un chiffre ou un espace blanc".
- Pattern.matches(regex, text1) : Cette méthode statique de la classe Pattern prend le motif d'expression régulière et la chaîne d'entrée en arguments et renvoie true si l'ensemble de la chaîne correspond au motif, et false sinon.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme :
```
javac HelloJava.java
```

Exécutez le programme :

java HelloJava

Vous devriez voir la sortie suivante :

String 1: "Hello World"
Contains special characters? false
String 2: "Hello World!"
Contains special characters? true

Cette sortie montre que Pattern.matches() a correctement identifié que la deuxième chaîne contient un caractère spécial (!) tandis que la première n'en contient pas.

Compter les caractères spéciaux dans une chaîne de caractères

Dans cette étape finale, nous allons combiner ce que nous avons appris sur la définition de motifs d'expressions régulières (regex) et l'utilisation de l'objet Matcher pour compter le nombre de caractères spéciaux dans une chaîne de caractères donnée. Il s'agit d'une application pratique des expressions régulières pour l'analyse ou la validation de données.

Nous allons utiliser le même motif d'expression régulière que dans l'Étape 1 ([^a-zA-Z0-9\\s]) pour identifier les caractères spéciaux et parcourir la chaîne de caractères à l'aide de l'objet Matcher pour compter le nombre de fois où le motif est trouvé.

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) {
        String text = "This string has 5 special characters: !@#$%";
        // Define a regex pattern to match special characters
        String regex = "[^a-zA-Z0-9\\s]";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);

        int count = 0;
        while (matcher.find()) {
            count++;
        }

        System.out.println("Original String: \"" + text + "\"");
        System.out.println("Regex Pattern: " + regex);
        System.out.println("Number of special characters found: " + count);
    }
}

Voici ce qui se passe dans le nouveau code :

Nous importons à nouveau les classes Matcher et Pattern.
Nous utilisons le même motif d'expression régulière [^a-zA-Z0-9\\s] pour correspondre aux caractères spéciaux individuels.
Nous initialisons une variable entière count à 0.
La boucle while (matcher.find()) parcourt la chaîne de caractères, et chaque fois que la méthode matcher.find() trouve une correspondance pour le motif, le code à l'intérieur de la boucle est exécuté.
À l'intérieur de la boucle, nous incrémentons la variable count de 1 pour chaque caractère spécial trouvé.
Enfin, nous affichons le nombre total de caractères spéciaux.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme :
```
javac HelloJava.java
```

Exécutez le programme :

java HelloJava

Vous devriez voir la sortie suivante :

Original String: "This string has 5 special characters: !@#$%"
Regex Pattern: [^a-zA-Z0-9\s]
Number of special characters found: 5

La sortie montre correctement qu'il y a 5 caractères spéciaux dans la chaîne de caractères fournie. Vous avez réussi à utiliser les expressions régulières et l'objet Matcher pour compter des caractères spécifiques dans une chaîne de caractères.

Résumé

Dans ce laboratoire (lab), nous avons appris à définir les caractères spéciaux à l'aide d'expressions régulières (regex) en Java. Nous avons exploré les caractères spéciaux courants des expressions régulières et leur signification, tels que ., *, +, ?, [], |, () et \. Nous avons également vu comment utiliser des classes de caractères prédéfinies telles que \d, \D, \s et \S.

Ensuite, nous avons appris à utiliser la méthode Pattern.matches() pour vérifier si une chaîne de caractères contient des caractères spéciaux en fonction d'un motif d'expression régulière défini. Enfin, nous avons exploré comment compter le nombre d'occurrences de caractères spéciaux dans une chaîne de caractères en utilisant la méthode Matcher.find() et en parcourant les correspondances.