Comment vérifier si une chaîne de caractères est égale à une autre en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à comparer efficacement des chaînes de caractères (strings) en Java. Comprendre la comparaison de chaînes de caractères est essentiel pour diverses tâches de programmation. Nous explorerons la méthode standard equals() pour vérifier si deux chaînes de caractères ont la même séquence de caractères, même si elles sont des objets différents en mémoire.

De plus, vous apprendrez à gérer les problèmes potentiels liés à l'exception NullPointerException lors de la comparaison de chaînes de caractères qui pourraient être null. Enfin, nous aborderons la méthode equalsIgnoreCase(), qui vous permet d'effectuer des comparaisons de chaînes de caractères sans tenir compte de la casse (case-insensitive), offrant ainsi une plus grande flexibilité lorsque la casse des caractères n'a pas d'importance pour votre logique de comparaison.

Comparer des chaînes de caractères à l'aide de la méthode equals()

Dans cette étape, nous apprendrons à comparer des chaînes de caractères en Java en utilisant la méthode equals(). La comparaison de chaînes de caractères est une opération fondamentale en programmation, et il est crucial de savoir la faire correctement.

En Java, les chaînes de caractères sont des objets, et non des types de données primitifs comme les entiers ou les booléens. Cela signifie que lorsque vous comparez des chaînes de caractères, vous comparez les objets eux-mêmes, et non seulement leurs valeurs. L'utilisation de l'opérateur == pour comparer des chaînes de caractères vérifie si les deux variables de chaîne de caractères font référence au même objet en mémoire. Cependant, souvent, vous voulez vérifier si deux chaînes de caractères ont la même séquence de caractères, même si elles sont des objets différents. Pour cela, vous devriez utiliser la méthode equals().

Créons un simple programme Java pour illustrer cela.

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 :
```
public class StringComparison {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");

        System.out.println("Comparing str1 and str2 using equals(): " + str1.equals(str2));
        System.out.println("Comparing str1 and str3 using equals(): " + str1.equals(str3));
        System.out.println("Comparing str1 and str2 using ==: " + (str1 == str2));
        System.out.println("Comparing str1 and str3 using ==: " + (str1 == str3));
    }
}
```
Dans ce code :
- Nous déclarons trois variables de chaîne de caractères : str1, str2 et str3.
- str1 et str2 sont créées à l'aide de littéraux de chaîne de caractères. Java optimise souvent les littéraux de chaîne de caractères de sorte que des littéraux identiques font référence au même objet.
- str3 est créée à l'aide du constructeur new String(), qui crée explicitement un nouvel objet de chaîne de caractères en mémoire, même si son contenu est le même que celui des littéraux existants.
- Nous utilisons equals() pour comparer le contenu des chaînes de caractères.
- Nous utilisons == pour comparer si les variables de chaîne de caractères font référence au même objet.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, compilons notre programme. Ouvrez le terminal en bas de l'interface WebIDE et assurez-vous que vous êtes dans le répertoire ~/project. Exécutez la commande suivante :
```
javac StringComparison.java
```
Si la compilation réussit, vous ne verrez aucun résultat. Un fichier StringComparison.class sera créé dans le répertoire ~/project.
Enfin, exécutez le programme compilé à l'aide de la commande java :
```
java StringComparison
```
Vous devriez voir un résultat similaire à ceci :
```
Comparing str1 and str2 using equals(): true
Comparing str1 and str3 using equals(): true
Comparing str1 and str2 using ==: true
Comparing str1 and str3 using ==: false
```
Notez que str1.equals(str2) et str1.equals(str3) retournent tous les deux true car le contenu des chaînes de caractères est le même. Cependant, str1 == str3 retourne false car str1 et str3 font référence à différents objets de chaîne de caractères en mémoire, même s'ils contiennent les mêmes caractères. str1 == str2 retourne true dans ce cas spécifique en raison de l'optimisation des littéraux de chaîne de caractères, mais il est généralement déconseillé de s'appuyer sur == pour comparer des chaînes de caractères car cela peut entraîner des résultats inattendus.

Cela démontre pourquoi l'utilisation de la méthode equals() est la bonne façon de comparer le contenu des chaînes de caractères en Java.

Gérer les chaînes de caractères null lors de la vérification d'égalité

Dans cette étape, nous allons explorer comment gérer les chaînes de caractères null lors de vérifications d'égalité en Java. Une chaîne de caractères null signifie que la variable de chaîne de caractères ne fait référence à aucun objet. Tenter d'appeler une méthode sur une variable null entraînera une NullPointerException, qui est une erreur courante en Java.

Lors de la comparaison de chaînes de caractères, il est important de prendre en compte la possibilité qu'une ou les deux chaînes de caractères puissent être null. Si vous appelez la méthode equals() sur une chaîne de caractères null, votre programme plantera.

Modifions notre programme précédent pour voir comment cela fonctionne et comment le gérer en toute sécurité.

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

Modifiez la méthode main pour inclure une chaîne de caractères null :

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");
        String str4 = null; // Cette chaîne de caractères est null

        System.out.println("Comparing str1 and str2 using equals(): " + str1.equals(str2));
        System.out.println("Comparing str1 and str3 using equals(): " + str1.equals(str3));
        System.out.println("Comparing str1 and str2 using ==: " + (str1 == str2));
        System.out.println("Comparing str1 and str3 using ==: " + (str1 == str3));

        // Essayons de comparer avec la chaîne de caractères null
        // System.out.println("Comparing str1 and str4 using equals(): " + str1.equals(str4)); // Cette ligne causerait une NullPointerException
        // System.out.println("Comparing str4 and str1 using equals(): " + str4.equals(str1)); // Cette ligne causerait également une NullPointerException

        // Bonne façon de comparer lorsqu'une chaîne de caractères peut être null
        System.out.println("Comparing str1 and str4 safely: " + (str1 != null && str1.equals(str4)));
        System.out.println("Comparing str4 and str1 safely: " + (str4 != null && str4.equals(str1)));
        System.out.println("Comparing str4 and null safely: " + (str4 == null));
    }
}

Dans le code modifié :

Nous avons ajouté une chaîne de caractères null str4.
Nous avons mis en commentaire les lignes qui causeraient une NullPointerException si elles étaient exécutées.
Nous avons ajouté des exemples de la façon de comparer en toute sécurité des chaînes de caractères lorsqu'une d'entre elles peut être null. La façon la plus sûre est de vérifier que la chaîne de caractères sur laquelle vous appelez equals() n'est pas null avant d'appeler la méthode. Un modèle courant est (stringVariable != null && stringVariable.equals(anotherString)). Alternativement, vous pouvez appeler equals() sur la chaîne de caractères connue non nulle si possible, comme "hello".equals(str4).

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié dans le terminal :
```
javac StringComparison.java
```

Exécutez le programme compilé :

java StringComparison

Vous devriez voir un résultat similaire à ceci :

Comparing str1 and str2 using equals(): true
Comparing str1 and str3 using equals(): true
Comparing str1 and str2 using ==: true
Comparing str1 and str3 using ==: false
Comparing str1 and str4 safely: false
Comparing str4 and str1 safely: false
Comparing str4 and null safely: true

Le résultat montre que les comparaisons sécurisées gèrent correctement la chaîne de caractères null sans causer d'erreur. La comparaison entre str1 et str4 (qui est null) est correctement évaluée à false.

Cette étape souligne l'importance de gérer les valeurs null lors de la manipulation d'objets en Java, en particulier les chaînes de caractères, pour éviter les erreurs NullPointerException.

Utiliser equalsIgnoreCase() pour une comparaison insensible à la casse

Dans cette étape finale, nous allons apprendre à utiliser la méthode equalsIgnoreCase(), qui permet de comparer des chaînes de caractères sans tenir compte de la casse des caractères. Cela est très utile lorsque vous souhaitez vérifier si deux chaînes de caractères sont identiques, que les lettres soient en majuscules ou en minuscules.

La méthode equals() que nous avons utilisée dans les étapes précédentes effectue une comparaison sensible à la casse. Cela signifie que "hello" n'est pas égal à "Hello" lorsque vous utilisez equals(). La méthode equalsIgnoreCase() ignore la casse, donc "hello" et "Hello" seraient considérés comme égaux.

Modifions notre programme une dernière fois pour démontrer l'utilisation de equalsIgnoreCase().

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

Ajoutez de nouvelles variables de chaîne de caractères avec des casse différentes et utilisez equalsIgnoreCase() pour les comparer :

public class StringComparison {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");
        String str4 = null;
        String str5 = "Hello"; // Casse différente
        String str6 = "HELLO"; // Toutes en majuscules

        System.out.println("Comparing str1 and str2 using equals(): " + str1.equals(str2));
        System.out.println("Comparing str1 and str3 using equals(): " + str1.equals(str3));
        System.out.println("Comparing str1 and str2 using ==: " + (str1 == str2));
        System.out.println("Comparing str1 and str3 using ==: " + (str1 == str3));

        // Comparaison sécurisée avec null
        System.out.println("Comparing str1 and str4 safely: " + (str1 != null && str1.equals(str4)));
        System.out.println("Comparing str4 and str1 safely: " + (str4 != null && str4.equals(str1)));
        System.out.println("Comparing str4 and null safely: " + (str4 == null));

        System.out.println("\n--- Case-Insensitive Comparisons ---");
        System.out.println("Comparing str1 and str5 using equals(): " + str1.equals(str5));
        System.out.println("Comparing str1 and str5 using equalsIgnoreCase(): " + str1.equalsIgnoreCase(str5));
        System.out.println("Comparing str1 and str6 using equalsIgnoreCase(): " + str1.equalsIgnoreCase(str6));
        System.out.println("Comparing str5 and str6 using equalsIgnoreCase(): " + str5.equalsIgnoreCase(str6));

        // equalsIgnoreCase() gère également les null en toute sécurité si appelée sur une chaîne non null
        System.out.println("Comparing str1 and str4 using equalsIgnoreCase(): " + str1.equalsIgnoreCase(str4));
        // System.out.println("Comparing str4 and str1 using equalsIgnoreCase(): " + str4.equalsIgnoreCase(str1)); // Cela causerait toujours une NullPointerException
    }
}

Dans le code mis à jour :

Nous avons ajouté str5 et str6 avec des casse différentes.
Nous avons ajouté de nouvelles instructions d'impression pour démontrer la différence entre equals() et equalsIgnoreCase().
Nous montrons également qu'appeler equalsIgnoreCase() sur une chaîne de caractères non null avec un argument null ne cause pas d'erreur, tout comme equals(). Cependant, appeler equalsIgnoreCase() sur une variable de chaîne de caractères null entraînera toujours une NullPointerException.

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

Exécutez le programme compilé :

java StringComparison

Vous devriez voir un résultat similaire à ceci :

Comparing str1 and str2 using equals(): true
Comparing str1 and str3 using equals(): true
Comparing str1 and str2 using ==: true
Comparing str1 and str3 using ==: false
Comparing str1 and str4 safely: false
Comparing str4 and str1 safely: false
Comparing str4 and null safely: true

--- Case-Insensitive Comparisons ---
Comparing str1 and str5 using equals(): false
Comparing str1 and str5 using equalsIgnoreCase(): true
Comparing str1 and str6 using equalsIgnoreCase(): true
Comparing str5 and str6 using equalsIgnoreCase(): true
Comparing str1 and str4 using equalsIgnoreCase(): false

Le résultat montre clairement que equalsIgnoreCase() retourne true lors de la comparaison de chaînes de caractères avec les mêmes caractères mais des casse différentes, tandis que equals() retourne false.

Vous avez maintenant appris à comparer des chaînes de caractères en Java en utilisant equals() pour une comparaison sensible à la casse, à gérer en toute sécurité les chaînes de caractères null et à utiliser equalsIgnoreCase() pour une comparaison insensible à la casse. Ce sont des compétences essentielles pour travailler avec les chaînes de caractères en Java.

Résumé

Dans ce laboratoire (lab), nous avons appris à comparer des chaînes de caractères en Java. Nous avons commencé par comprendre la différence entre la comparaison d'objets de chaîne de caractères à l'aide de l'opérateur == et la comparaison de leur contenu à l'aide de la méthode equals(). Nous avons vu que == vérifie l'identité de l'objet, tandis que equals() vérifie l'égalité de la séquence de caractères.

Nous avons ensuite exploré comment gérer le risque de NullPointerException lors de la comparaison de chaînes de caractères en nous assurant que la chaîne de caractères sur laquelle equals() est appelée n'est pas null. Enfin, nous avons appris à effectuer des comparaisons de chaînes de caractères insensibles à la casse à l'aide de la méthode equalsIgnoreCase().