1. Introduction
Pourquoi la comparaison de chaînes est‑elle importante en Java ?
En programmation Java, travailler avec des chaînes (String) est extrêmement courant. Vérifier des noms d’utilisateur, valider des entrées de formulaire et vérifier les réponses d’une API ne sont que quelques exemples où la comparaison de chaînes est nécessaire.
À ce stade, comment comparer correctement les chaînes devient un obstacle étonnamment fréquent pour les débutants. En particulier, ne pas comprendre la différence entre l’opérateur == et la méthode equals() peut entraîner des bugs qui produisent des résultats inattendus.
Pourquoi ne pas comprendre « == » vs « equals() » est dangereux
Par exemple, jetez un œil au code suivant.
String a = "apple";
String b = new String("apple");
System.out.println(a == b); // Result: false
System.out.println(a.equals(b)); // Result: true
Beaucoup de personnes sont surprises par ce résultat. Même si les chaînes semblent identiques, == renvoie false alors que equals() renvoie true. Cela se produit parce que Java traite les chaînes comme des types de référence, et == compare les adresses de référence, pas le contenu.
Comme vous pouvez le voir, comparer correctement les chaînes a un impact direct sur la fiabilité et la lisibilité du programme. En revanche, une fois que vous avez compris l’approche correcte, vous pouvez éviter de nombreux bugs avant qu’ils ne surviennent.
Ce que vous apprendrez dans cet article
Dans cet article, nous expliquerons soigneusement la comparaison de chaînes en Java, des bases aux techniques plus avancées. Nous répondrons aux questions courantes de manière claire et structurée, afin que les débutants puissent suivre facilement.
- Quelle est la différence entre
==etequals()? - Comment comparer des chaînes en ignorant la casse ?
- Comment comparer des chaînes dans l’ordre lexicographique (dictionnaire) ?
- Comment comparer des chaînes en toute sécurité avec
null?
En parcourant des exemples de code pratiques, vous développerez une compréhension solide de la comparaison correcte des chaînes en Java.
2. Bases des chaînes en Java
Les chaînes sont des types de référence
En Java, le type String n’est pas un type primitif (comme int ou boolean), mais un type de référence. Cela signifie qu’une variable String ne stocke pas le texte réel, mais contient une référence à un objet chaîne situé dans la mémoire du tas.
Par exemple, lorsque vous écrivez ce qui suit :
String a = "hello";
String b = "hello";
a et b peuvent référencer le même objet chaîne "hello", de sorte que a == b peut renvoyer true. Cependant, ce comportement dépend du mécanisme d’optimisation des littéraux de chaîne de Java (String Interning).
Littéraux de chaîne vs new String()
En Java, lorsqu’un même littéral de chaîne est utilisé plusieurs fois, la JVM optimise l’utilisation de la mémoire en réutilisant la même référence. Cela permet d’améliorer l’efficacité mémoire en partageant les objets chaîne.
String s1 = "apple";
String s2 = "apple";
System.out.println(s1 == s2); // true (same literal, same reference)
En revanche, lorsque vous créez explicitement une chaîne avec le mot‑clé new, un nouvel objet est créé avec une référence différente.
String s3 = new String("apple");
System.out.println(s1 == s3); // false (different references)
System.out.println(s1.equals(s3)); // true (same content)
Cela montre clairement la différence : == vérifie l’égalité de référence, tandis que equals() vérifie l’égalité de contenu. Leurs objectifs sont fondamentalement différents.
Les chaînes sont immuables
Une autre caractéristique importante de String est qu’elle est immutable. Une fois qu’un objet String est créé, son contenu ne peut plus être modifié.
Par exemple :
String original = "hello";
original = original + " world";
Cela peut donner l’impression que la chaîne d’origine est modifiée, mais en réalité, un nouvel objet String est créé et réassigné à original.
Grâce à cette immutabilité, les objets String sont thread‑safe et jouent un rôle important dans la sécurité et l’optimisation du cache.
3. Méthodes de comparaison de chaînes
Comparaison de références avec l’opérateur ==
== compare les références (adresses) des objets String. En d’autres termes, même si le contenu est identique, il renvoie false si les objets sont différents.
String a = "Java";
String b = new String("Java");
System.out.println(a == b); // false
Dans cet exemple, a est un littéral et b est créé avec new, ils font donc référence à des objets différents et le résultat est false. Attention : ceci n’est pas adapté pour comparer le contenu.
Comparaison de contenu avec equals()
equals() est la méthode correcte pour comparer le contenu d’une chaîne. Dans la plupart des cas, cette méthode est recommandée.
String a = "Java";
String b = new String("Java");
System.out.println(a.equals(b)); // true
Comme indiqué ci‑dessus, même si les références sont différentes, elle renvoie true lorsque les contenus correspondent.
Remarques importantes lors de la comparaison avec null
Le code suivant peut provoquer une NullPointerException.
String input = null;
System.out.println(input.equals("test")); // Exception!
Pour éviter cela, il est recommandé d’écrire les comparaisons sous la forme constant.equals(variable).
System.out.println("test".equals(input)); // false (safe)
Comparaison insensible à la casse avec equalsIgnoreCase()
Si vous avez besoin d’une comparaison insensible à la casse (par exemple, noms d’utilisateur ou adresses e‑mail), equalsIgnoreCase() est pratique.
String a = "Hello";
String b = "hello";
System.out.println(a.equalsIgnoreCase(b)); // true
Cependant, dans certains cas Unicode particuliers (comme la lettre turque « İ »), le comportement peut être inattendu, il faut donc faire attention à l’internationalisation.
Comparaison lexicographique avec compareTo()
compareTo() compare deux chaînes lexicographiquement (ordre dictionnaire) et renvoie un entier selon les règles suivantes :
- 0 : égal
- valeur négative : la chaîne appelante vient en premier (plus petite)
- valeur positive : la chaîne appelante vient après (plus grande)
String a = "apple"; String b = "banana"; System.out.println(a.compareTo(b)); // negative value ("apple" comes before "banana")
Ceci est souvent utilisé pour le tri lexicographique et le filtrage, et il est également utilisé en interne pour la comparaison de clés dans Collections.sort() et TreeMap.
4. Exemples pratiques
Validation de l’entrée utilisateur (fonction de connexion)
L’un des cas d’utilisation les plus courants consiste à vérifier si un nom d’utilisateur ou un mot de passe correspond.
String inputUsername = "Naohiro";
String registeredUsername = "naohiro";
if (registeredUsername.equalsIgnoreCase(inputUsername)) {
System.out.println("Login successful");
} else {
System.out.println("Username does not match");
}
Comme dans cet exemple, lorsque vous voulez comparer des chaînes sans tenir compte de la casse, l’utilisation de equalsIgnoreCase() est appropriée.
Cependant, pour les comparaisons de mots de passe, vous devez traiter les majuscules et minuscules comme différentes pour des raisons de sécurité, donc utilisez equals().
Validation d’entrée (gestion de formulaire)
Par exemple, la comparaison de chaînes est également utilisée pour valider les valeurs saisies à partir de listes déroulantes ou de champs texte.
String selectedOption = request.getParameter("plan");
if ("premium".equals(selectedOption)) {
System.out.println("You selected the Premium plan.");
} else {
System.out.println("You selected a different plan.");
}
En pratique, le modèle "constant".equals(variable) est largement utilisé comme comparaison sûre qui gère aussi le null. L’entrée utilisateur n’est pas toujours présente, ce style aide donc à prévenir les NullPointerException.
Branches avec multiples conditions (logique de type switch)
Si vous souhaitez créer des branches en fonction de plusieurs valeurs de chaîne possibles, il est courant d’enchaîner des comparaisons equals().
String cmd = args[0];
if ("start".equals(cmd)) {
startApp();
} else if ("stop".equals(cmd)) {
stopApp();
} else {
System.out.println("Invalid command");
}
À partir de Java 14, les instructions switch pour les chaînes sont également prises en charge officiellement.
.« ` switch (cmd) { case « start »: startApp(); break; case « stop »: stopApp(); break; default: System.out.println(« Unknown command »); }
Parce que **la comparaison de chaînes affecte directement la logique de branchement**, une compréhension précise est essentielle.
### Bugs causés par la comparaison avec null et comment les prévenir
Un cas d'échec courant est lorsqu'une application plante à cause de la comparaison d'une valeur `null`.
String keyword = null;
if (keyword.equals(« search »)) { // Exception occurs: java.lang.NullPointerException }
Dans de tels cas, vous pouvez comparer en toute sécurité en l'écrivant ainsi :
if (« search ».equals(keyword)) { System.out.println(« Executing search »); }
Alternativement, vous pouvez d'abord effectuer une vérification de null plus stricte.
if (keyword != null && keyword.equals(« search »)) { System.out.println(« Executing search »); }
**Écrire du code sûr face aux nulls est une compétence indispensable** pour créer des applications robustes.
## 5. Performance et optimisation
### Coût de traitement de la comparaison de chaînes
`equals()` et `compareTo()` sont généralement bien optimisés et rapides. Cependant, en interne ils comparent les caractères un par un, donc **les longues chaînes ou les grands ensembles de données peuvent avoir un impact sur les performances**. En particulier, comparer de façon répétée la même chaîne à l'intérieur de boucles peut entraîner une dégradation de performance non souhaitée.
for (String item : items) { if (item.equals(« keyword »)) { // Be careful if this comparison runs many times } }
### Accélérer les comparaisons avec String.intern()
La méthode Java `String.intern()` enregistre les chaînes ayant un contenu identique dans le **pool de chaînes du JVM** et partage leurs références. En tirant parti de cela, les comparaisons utilisant `==` peuvent devenir possibles, ce qui peut offrir des avantages de performance dans certains scénarios.
String a = new String(« hello »).intern(); String b = « hello »;
System.out.println(a == b); // true
Cependant, une utilisation excessive du pool de chaînes peut augmenter la pression sur la mémoire du tas, donc **cette approche doit être limitée à des cas d'utilisation bien définis**.
### Pièges de equalsIgnoreCase() et alternatives
`equalsIgnoreCase()` est pratique, mais il effectue une conversion de casse en interne, ce qui le rend **légèrement plus coûteux que `equals()`**. Dans les situations sensibles aux performances, il est souvent plus rapide de normaliser les chaînes à l'avance puis de les comparer.
String input = userInput.toLowerCase(); if (« admin ».equals(input)) { // Optimized comparison }
En **normalisant les chaînes au préalable puis en utilisant `equals()`**, vous pouvez améliorer l'efficacité des comparaisons.
### Utiliser efficacement StringBuilder / StringBuffer
Lorsque de nombreuses concaténations de chaînes sont impliquées, utiliser directement `String` crée de nouveaux objets à chaque fois, augmentant la charge mémoire et CPU. Même lorsque la logique de comparaison est impliquée, la meilleure pratique est d'**utiliser `StringBuilder` pour la construction et de garder les valeurs en `String` pour la comparaison**.
StringBuilder sb = new StringBuilder(); sb.append(« user_ »); sb.append(« 123 »);
String result = sb.toString();
if (result.equals(« user_123 »)) { // Comparison logic }
### Concevoir pour la rapidité avec le caching et le prétraitement
Si les mêmes comparaisons de chaînes se produisent de façon répétée, il peut être efficace d'**mettre en cache les résultats des comparaisons** ou d'**utiliser des maps (comme HashMap) pour le prétraitement** afin de réduire le nombre de comparaisons.
Map
Runnable action = commandMap.get(inputCommand); if (action != null) { action.run(); }
Avec cette approche, la comparaison de chaînes avec `equals()` est remplacée par une recherche unique dans une map, améliorant à la fois **la lisibilité et les performances**.
## 6. Questions fréquemment posées (FAQ)
### Q1. Quelle est la différence entre `==` et `equals()` ?
**A.**
`==` effectue une **comparaison de références** (c’est‑à‑dire qu’il vérifie si deux variables pointent vers la même adresse mémoire). En revanche, `equals()` compare le **contenu réel des chaînes**.
String a = new String(« abc »); String b = « abc »;
System.out.println(a == b); // false (different references) System.out.println(a.equals(b)); // true (same content)
Par conséquent, lorsque vous souhaitez comparer le contenu d’une chaîne, utilisez toujours `equals()`.
### Q2. Pourquoi l’utilisation de `equals()` provoque‑t‑elle parfois des erreurs dues à null ?
**A.**
Appeler une méthode sur `null` entraîne une **NullPointerException**.
String input = null; System.out.println(input.equals(« test »)); // Exception!
Pour éviter cette erreur, il est plus sûr d’**appeler `equals()` sur une constante**, comme indiqué ci‑dessous.
System.out.println(« test ».equals(input)); // false (safe)
### Q3. Comment comparer des chaînes sans tenir compte de la casse ?
**A.**
Utilisez la méthode `equalsIgnoreCase()` pour ignorer les différences entre les caractères majuscules et minuscules.
String a = « Hello »; String b = « hello »;
System.out.println(a.equalsIgnoreCase(b)); // true
Cependant, sachez qu’avec les caractères en pleine largeur ou certains caractères Unicode spéciaux, les résultats peuvent ne pas toujours être ceux attendus.
### Q4. Comment comparer des chaînes dans l’ordre trié (lexicographique) ?
**A.**
Utilisez `compareTo()` lorsque vous souhaitez vérifier l’**ordre lexicographique** des chaînes.
String a = « apple »; String b = « banana »;
System.out.println(a.compareTo(b)); // negative value (« apple » comes before « banana ») « `
Signification de la valeur de retour :
- 0 → égal
- valeur négative → la chaîne de gauche vient en premier
- valeur positive → la chaîne de gauche vient après
Cette méthode est couramment utilisée dans les opérations de tri.
Q5. Quelles sont les meilleures pratiques pour la comparaison de chaînes ?
A.
- Utilisez toujours
equals()pour la comparaison de contenu - Assurez la sécurité face à null en utilisant
"constant".equals(variable) - Pour la comparaison insensible à la casse, utilisez
equalsIgnoreCase()ou normalisez avectoLowerCase()/toUpperCase() - Pour les comparaisons à grande échelle ou critiques en termes de performance, envisagez
intern()ou des stratégies de mise en cache - Toujours équilibrer lisibilité et sécurité
7. Conclusion
Choisir correctement la bonne méthode de comparaison de chaînes en Java est essentiel
Dans cet article, nous avons couvert la comparaison de chaînes en Java, des bases aux cas d’utilisation pratiques et aux considérations de performance. Étant donné que String est un type de référence en Java, utiliser la mauvaise méthode de comparaison peut facilement entraîner un comportement inattendu.
En particulier, la différence entre == et equals() est l’un des premiers points qui confondent les débutants. Comprendre cette distinction et utiliser chaque méthode de façon appropriée est essentiel pour écrire du code sûr et fiable.
Ce que vous avez appris dans cet article (liste de contrôle)
==compare les références (adresses mémoire)equals()compare le contenu des chaînes et est l’option la plus sûreequalsIgnoreCase()permet la comparaison insensible à la cassecompareTo()permet la comparaison lexicographique des chaînes"constant".equals(variable)assure une comparaison sûre face à null- Pour les cas sensibles à la performance,
intern()et les stratégies de mise en cache peuvent être efficaces
Connaissances de la comparaison de chaînes qui rapportent dans le développement réel
La comparaison de chaînes joue un rôle crucial dans les tâches de développement quotidiennes telles que la validation de connexion, la validation d’entrée, les recherches en base de données et les branches conditionnelles. Avec une compréhension solide de ces concepts, vous pouvez prévenir les bugs et garantir que votre code se comporte exactement comme prévu.
Chaque fois que vous écrivez du code qui manipule des chaînes, revenez aux principes présentés dans cet article et choisissez la méthode de comparaison qui correspond le mieux à votre objectif.
