Opérateurs de comparaison Java

Les opérateurs de comparaison prennent deux opérandes et produisent un boolean. Java en possède six — égal, différent, et les quatre opérateurs relationnels. Le piège est que == se comporte différemment sur les primitifs et sur les objets, ce qui est la source la plus fréquente de bugs chez les débutants.

Les six opérateurs

Chacun produit un boolean utilisable dans un test if, une condition de boucle ou comme valeur d'une variable :

int score = 85;
boolean passed = score >= 60;        // true
boolean perfect = score == 100;      // false
boolean failed = !(score >= 60);     // false

Les opérateurs relationnels (>, <, >=, <=) sont le plus souvent utilisés comme conditions if et gardes de boucle :

int temperature = 30;

if (temperature > 25) {
  System.out.println("warm");        // printed
} else if (temperature < 10) {
  System.out.println("cold");
}

for (int i = 0; i < 3; i++) {        // i < 3 is the loop guard
  System.out.println(i);             // 0 1 2
}

== sur les primitifs

Pour les types primitifs, == compare la valeur :

int a = 5;
int b = 5;
System.out.println(a == b);    // true

double x = 0.1 + 0.2;
double y = 0.3;
System.out.println(x == y);    // false — IEEE 754 rounding

Le cas des nombres à virgule flottante est un rappel : ne comparez pas les valeurs double pour une égalité exacte. Vérifiez qu'elles se trouvent dans une petite tolérance :

System.out.println(Math.abs(x - y) < 1e-9);   // true

== sur les objets — identité, pas égalité

Pour les types référence, == compare les références — si les deux variables pointent vers le même objet en mémoire. Deux objets distincts ayant un contenu identique ne sont pas == :

String s1 = new String("hello");
String s2 = new String("hello");

System.out.println(s1 == s2);          // false — different objects
System.out.println(s1.equals(s2));     // true  — same contents

La règle d'or : pour les objets, utilisez toujours .equals() pour comparer les contenus.

if (input.equals("quit")) { ... }      // correct
// if (input == "quit") { ... }        // works by coincidence, don't rely on it

La forme == "quit" retourne parfois true parce que Java déduplique les littéraux de chaîne — le même littéral est compilé vers le même objet. Mais c'est un détail d'implémentation, pas une garantie.

Objects.equals — null-safe

Si l'un des côtés peut être null, obj.equals(other) lève une NullPointerException. Utilisez Objects.equals à la place — il gère null de chaque côté :

import java.util.Objects;

String a = null;
String b = "hello";

System.out.println(Objects.equals(a, b));   // false (no NPE)
System.out.println(Objects.equals(a, null)); // true

Comparer les types enveloppes

Les types enveloppes (Integer, Long, etc.) suivent la règle des objets — == compare les références, pas les valeurs :

Integer x = 200;
Integer y = 200;
System.out.println(x == y);         // false (usually)
System.out.println(x.equals(y));    // true

(Les valeurs de -128 à 127 sont mises en cache, donc Integer x = 100; Integer y = 100; x == y est true par hasard — mais c'est une particularité de la JVM, pas la règle du langage. Ne vous y fiez pas.)

Comparer pour l'ordre — .compareTo

<, >, <=, >= ne fonctionnent que sur les primitifs. Pour comparer des objets selon un ordre, utilisez la méthode Comparable.compareTo (retourne un négatif, zéro ou un positif) :

String a = "apple";
String b = "banana";

System.out.println(a.compareTo(b));   // negative — "apple" < "banana"
System.out.println(a.compareTo(a));   // 0
System.out.println(b.compareTo(a));   // positive

Integer, Long, String, LocalDate et la plupart des types « naturels » implémentent Comparable. Pour un ordre personnalisé, utilisez Comparator — abordé dans Comparable et Comparator.

Une démonstration

Prochaine étape

Opérateurs logiques Java — combiner des expressions boolean avec &&, || et !.

Entraînement