Les opérateurs d'affectation en Java

Le simple = est l'opérateur d'affectation de base. Java fournit également une famille d'opérateurs d'affectation composés qui combinent une opération arithmétique, binaire ou de décalage avec l'affectation elle-même. Ils permettent d'économiser quelques caractères et rendent l'intention — « modifier cette variable sur place » — plus claire.

Affectation simple

Le membre droit est évalué, puis stocké dans la variable du membre gauche :

int x = 5;
int y = x + 3;
y = y * 2;
System.out.println(y);   // 16

Quelques règles :

• Le membre gauche doit être une variable (ou un élément de tableau, ou un champ), jamais une expression comme (x + 1) = 5.
• Les types doivent correspondre — ou le membre droit doit être implicitement convertible vers le type du membre gauche.
• L'affectation est elle-même une expression : int a = (b = 5); assigne 5 à la fois à a et à b.

Opérateurs d'affectation composés

Chaque opérateur arithmétique et binaire possède une forme d'affectation composée associée :

En pratique :

int total = 0;
total += 5;    // total = 5
total += 3;    // total = 8
total *= 2;    // total = 16
total -= 1;    // total = 15
total /= 3;    // total = 5

Les formes binaires et de décalage fonctionnent de la même manière — elles appliquent l'opération sur la valeur actuelle de la variable et stockent le résultat :

int flags = 0b0101;   // 5
flags |= 0b0010;      // set a bit  -> 0b0111 = 7
flags &= 0b0110;      // clear bits -> 0b0110 = 6
flags <<= 1;          // shift left -> 0b1100 = 12

Le membre droit est traité comme un tout

x op= y n'est pas une simple substitution textuelle de x = x op y. Le compilateur traite l'intégralité du membre droit comme un seul opérande, comme s'il était entre parenthèses — x = x op (y) :

int x = 10;
x *= 2 + 3;   // x = x * (2 + 3) = 50, NOT x = x * 2 + 3 = 23
System.out.println(x);   // 50

+= avec les chaînes de caractères

+= permet également de concaténer des chaînes :

String greeting = "Hello";
greeting += ", world!";   // "Hello, world!"

Chaque += sur une String crée une nouvelle chaîne en coulisses — les chaînes sont immuables. Pour les boucles qui construisent une longue chaîne, utilisez plutôt StringBuilder (abordé dans Java String Concatenation).

L'affectation composée inclut un cast implicite

Une subtilité importante : les opérateurs d'affectation composés incluent un cast implicite vers le type de la variable. L'affectation simple ne le fait pas.

byte b = 10;
// b = b + 1;       // compile error: int can't fit into byte without a cast
b += 1;             // OK — compound form casts implicitly
System.out.println(b);   // 11

C'est parfois utile — et parfois une source d'erreur silencieuse si cela masque un débordement.

L'affectation est une expression — mais à ne pas abuser

Puisque l'affectation produit une valeur, vous pouvez la chaîner :

int a, b, c;
a = b = c = 10;     // all three set to 10

Vous pouvez également affecter à l'intérieur d'un test if :

String line;
while ((line = reader.readLine()) != null) {
    process(line);
}

Ces idiomes sont courants dans les boucles d'E/S. En dehors de while ((x = ...) != null), préférez des instructions séparées — elles sont plus faciles à lire.

= vs ==

La principale source de bugs à un seul caractère en Java est la confusion entre = (affectation) et == (comparaison) :

int x = 5;
// if (x = 10) { ... }   // compile error: int is not a boolean
// if (x == 10) { ... }  // OK

Pour int et la plupart des types, le compilateur détecte immédiatement l'erreur car = renvoie un int, pas un boolean. Avec les variables boolean, il n'y a pas d'erreur de compilation — l'affectation avec = renvoie toujours le boolean affecté — soyez donc particulièrement vigilant lors du test de drapeaux :

boolean isOpen = false;
if (isOpen = true) { ... }   // bug: this sets isOpen and is always true
if (isOpen == true) { ... }  // works, but...
if (isOpen) { ... }          // ...this is what you actually want

Une démonstration

Et ensuite

Java Comparison Operators couvre ==, !=, les opérateurs relationnels, et la différence cruciale entre == et .equals() pour les objets.

Pratique