1. Comparaison des références et du contenu
En Java, les chaînes sont des objets, pas des types primitifs. Lorsque vous écrivez les variables a et b, elles peuvent pointer vers la même chaîne dans le pool de chaînes. En revanche, c, créée via un constructeur, est déjà un autre objet. L’opérateur == compare les références et non le texte.
String a = "hello";
String b = "hello";
String c = new String("hello");
System.out.println(a == b); // true (très probablement, chaîne internée)
System.out.println(a == c); // false (objets différents)
Démonstration de l’erreur
String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1 == s2); // false
Bien que les chaînes aient l’air identiques, ce sont des objets différents en mémoire.
2. equals(): comparaison du contenu des chaînes
Pour comparer le contenu même, utilisez la méthode equals() — elle compare les chaînes caractère par caractère (sensible à la casse).
String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1.equals(s2)); // true
Exemple : comparaison de mots de passe
String inputPassword = "Secret123";
String realPassword = "Secret123";
if (inputPassword.equals(realPassword))
{
System.out.println("Accès autorisé !");
}
else
{
System.out.println("Mot de passe incorrect.");
}
Important !
Si au moins un des objets vaut null, l’appel de equals() provoquera une NullPointerException. Modèle sûr :
if ("quelque chose".equals(someString)) { ... }
3. equalsIgnoreCase(): comparaison sans tenir compte de la casse
Quand il est important d’ignorer la casse (par exemple, la saisie utilisateur), utilisez equalsIgnoreCase().
String name1 = "Ivan";
String name2 = "ivan";
System.out.println(name1.equalsIgnoreCase(name2)); // true
Exemple : comparaison d’adresses e-mail
String email1 = "User@Example.com";
String email2 = "user@example.com";
if (email1.equalsIgnoreCase(email2))
{
System.out.println("Les adresses e-mail correspondent !");
}
En bref: equals vs equalsIgnoreCase
| Méthode | Sensible à la casse ? | Exemple « Java » vs « java » |
|---|---|---|
|
Oui | |
|
Non | |
4. compareTo(): comparaison lexicographique des chaînes
La méthode compareTo() effectue une comparaison lexicographique (ordre de dictionnaire). Elle renvoie un nombre négatif si la première chaîne est « plus petite », 0 — égales, un nombre positif — si « plus grande ».
System.out.println("apple".compareTo("banana")); // < 0
System.out.println("apple".compareTo("apple")); // 0
System.out.println("banana".compareTo("apple")); // > 0
a.compareTo(b) →
< 0 — si a vient avant b
0 — si elles sont égales
> 0 — si a vient après bcompareTo()
Comment cela fonctionne ?
- La comparaison se fait de gauche à droite selon les codes Unicode des caractères.
- À la première différence, la méthode renvoie la différence des codes des caractères.
- Si une chaîne est un préfixe de l’autre, la plus courte est « plus petite ».
System.out.println("cat".compareTo("catalog")); // < 0 ("cat" est plus courte)
System.out.println("catalog".compareTo("cat")); // > 0
Exemple : trier un tableau de chaînes
String[] fruits = {"banana", "apple", "pear"};
Arrays.sort(fruits); // compareTo() est utilisé en interne
System.out.println(Arrays.toString(fruits)); // [apple, banana, pear]
compareToIgnoreCase()
System.out.println("Java".compareToIgnoreCase("java")); // 0
5. Méthodes startsWith() et endsWith()
Les méthodes startsWith() et endsWith() vérifient le début et la fin d’une chaîne, en renvoyant true/false.
String fileName = "document.pdf";
String url = "https://www.google.com";
System.out.println(fileName.startsWith("doc")); // true
System.out.println(fileName.endsWith(".txt")); // false
System.out.println(url.startsWith("https://")); // true
À quoi ça sert : validation des formats (noms de fichiers, URL) et filtrage par préfixes/suffixes (par exemple, tous les ".jpg").
6. Méthode contains(): recherche d’une sous-chaîne
contains(CharSequence s) — un moyen simple de vérifier la présence d’une sous-chaîne. Sensible à la casse.
String text = "Bienvenue dans le monde de Java !";
System.out.println(text.contains("monde")); // true
System.out.println(text.contains("C++")); // false
Pour ignorer la casse, convertissez les deux chaînes dans la même casse : toLowerCase()/toUpperCase().
7. Méthodes toLowerCase() et toUpperCase()
Elles renvoient une nouvelle chaîne convertie en minuscules ou en majuscules. Utile pour les comparaisons insensibles à la casse et le formatage.
String title = "Java Programming";
String lower = title.toLowerCase();
String upper = title.toUpperCase();
System.out.println(lower); // java programming
System.out.println(upper); // JAVA PROGRAMMING
8. Méthode split(): découper une chaîne en parties
split(String regex) découpe la chaîne selon un séparateur (expression régulière) et renvoie un tableau String[].
Exemple 1: par virgules
String names = "Alex,Maria,Ivan,Elena";
String[] nameArray = names.split(",");
for (String name : nameArray)
{
System.out.println(name.trim()); // trim() supprime d’éventuels espaces
}
// Sortie:
// Alex
// Maria
// Ivan
// Elena
Exemple 2: par espaces
String sentence = "J'étudie Java";
String[] words = sentence.split(" ");
for (String word : words)
{
System.out.println(word);
}
// Sortie:
// J'étudie
// Java
Particularités:
- Le séparateur est une expression régulière. Les métacaractères doivent être échappés (par exemple, le point : "\\.").
- La méthode renvoie toujours un tableau, même s’il ne contient qu’un seul élément.
9. Pratique: comparer des chaînes dans une application réelle
String registeredEmail = "user@example.com";
String registeredPassword = "Secret123";
Scanner console = new Scanner(System.in);
System.out.print("Entrez l'e-mail: ");
String email = console.nextLine();
System.out.print("Entrez le mot de passe: ");
String password = console.nextLine();
// On compare l’e-mail sans tenir compte de la casse, et le mot de passe en tenant compte de la casse
if (email.equalsIgnoreCase(registeredEmail) && password.equals(registeredPassword))
{
System.out.println("Bienvenue !");
}
else
{
System.out.println("E-mail ou mot de passe incorrect.");
}
Remarques : pour l’e-mail, nous utilisons equalsIgnoreCase(), et pour le mot de passe — strictement equals(). Il ne faut pas utiliser l’opérateur == pour les chaînes — il compare les références.
10. Erreurs typiques lors de la comparaison de chaînes
Erreur n° 1: Comparer des chaînes avec == au lieu de equals()
L’opérateur == compare les références et non le contenu, le résultat peut donc être inattendu.
Erreur n° 2: Appeler equals() sur un objet qui peut être null
Appelez la méthode sur un objet garanti non null ou utilisez Objects.equals(a, b).
Erreur n° 3: Ignorer la casse quand elle est importante
Par exemple, les mots de passe doivent être comparés en tenant compte de la casse. Précisez les exigences.
Erreur n° 4: Comparer des chaînes à des objets d’autres types
"123" et 123 ne sont pas la même chose. equals() ne convertit pas les types automatiquement.
Erreur n° 5: Trier des chaînes avec des casses différentes
Les majuscules viennent avant les minuscules. Pour un tri insensible à la casse, utilisez Arrays.sort(array, String.CASE_INSENSITIVE_ORDER).
GO TO FULL VERSION