Différence entre `!=` et l’affectation avec négation `a = !b` en Java

En Java, != est l’opérateur de comparaison « différent de » : il renvoie true lorsque ses opérandes ont des valeurs différentes. La séquence de caractères =! n’est pas un opérateur. Dans une expression telle que a = !b, Java interprète = comme une affectation et ! comme une négation booléenne ; la valeur booléenne inversée de b est donc affectée à a.

Les exemples ci-dessous montrent le résultat booléen de chaque comparaison et la façon dont une affectation combinée à une négation agit sur une condition.

Exemple de comparaison « différent de » avec != en Java

Utilisez != pour comparer deux valeurs. L’opérateur renvoie false si elles sont égales et true si elles diffèrent. Pour les valeurs numériques primitives, il compare les valeurs ; pour les valeurs de référence, il vérifie si les références désignent des objets différents. Pour nier une comparaison d’égalité, écrivez !(a == b) : cette expression produit le même résultat booléen que a != b.

L’opérateur produit une valeur booléenne : vous pouvez donc l’utiliser directement dans une condition if ou stocker son résultat dans une variable booléenne. Par exemple, if (count != limit) s’exécute lorsque les deux valeurs primitives diffèrent. Avec des objets, != vérifie leur identité, et non leur contenu : deux objets String distincts peuvent contenir le même texte tout en étant considérés comme différents par identité. Utilisez equals pour comparer le contenu des objets. Les parenthèses dans !(a == b) rendent l’ordre explicite : l’égalité est d’abord évaluée, puis son résultat est nié. Cette équivalence peut être utile pour lire une condition plus longue, même si a != b est généralement plus concis.

public class Main {
  public static void main(String[] args) {
    int a = 10;
    int b = 10;
    System.out.println(a != b);

    a = 20;
    System.out.println(a != b);
    System.out.println(!(a == b));
  }
}

false
true
true

Avec la première paire de valeurs, la comparaison renvoie false. Après la modification de a, les valeurs diffèrent : la comparaison « différent de » et l’expression d’égalité niée renvoient alors toutes deux true.

Exemple d’affectation et de négation avec =! en Java

Java ne comporte pas d’opérateur combiné =!. Dans a = !b, Java évalue d’abord !b, puis affecte ce résultat booléen à a. Cette même affectation peut figurer dans une condition if : la condition reçoit la valeur booléenne affectée, et le bloc s’exécute si cette valeur est true. Cette forme est valide, mais elle modifie a pendant l’évaluation de la condition. Si l’affectation n’est pas nécessaire, une condition directe comme if (!b) est souvent plus facile à lire.

L’affectation a une priorité inférieure à la négation unaire : l’expression se regroupe donc ainsi : a = (!b). L’expression d’affectation a elle-même une valeur booléenne : elle prend la valeur qui vient d’être stockée dans a. Java accepte donc cette expression comme condition de if ; la condition ne compare pas a à une autre valeur. Cette forme peut être utile lorsque l’affectation est intentionnelle, mais elle peut surprendre si l’on s’attend à une comparaison. Si vous devez à la fois enregistrer une valeur et effectuer un test distinct, faites d’abord l’affectation, puis le test dans une instruction séparée afin de distinguer clairement les deux opérations.

public class Main {
  public static void main(String[] args) {
    boolean a;
    boolean b = true;
    a = !b;
    System.out.println("a = " + a);

    b = false;
    if (a = !b) {
      System.out.println("condition is true; a = " + a);
    }
  }
}

a = false
condition is true; a = true

Lorsque b vaut true, !b vaut false, et cette valeur est affectée à a. Plus tard, lorsque b vaut false, l’affectation dans la condition stocke true dans a ; cette valeur true entraîne l’exécution du bloc if. Écrire l’expression sous la forme a = !b permet de distinguer plus facilement l’affectation de la négation, mais les espaces ne changent pas son sens.