Opérateurs Java

Les opérateurs sont les petits symboles qui permettent d'effectuer des opérations sur des valeurs : les additionner, les comparer, combiner des tests booléens, manipuler des bits, choisir entre deux expressions. Ce chapitre est une vue d'ensemble de toutes les catégories d'opérateurs Java — chaque catégorie dispose de son propre chapitre dédié qui va plus loin.

Les catégories

Les opérateurs Java se répartissent en sept groupes :

Il y a aussi instanceof (vérification de type) et new (création d'objet) qui se comportent comme des opérateurs mais sont liés à des fonctionnalités spécifiques du langage.

Arithmétique

Les cinq opérateurs arithmétiques font ce qu'ils font dans n'importe quel langage, avec une particularité :

int sum     = 7 + 3;     // 10
int diff    = 7 - 3;     // 4
int product = 7 * 3;     // 21
int quotient = 7 / 3;    // 2  ← integer division truncates
int remainder = 7 % 3;   // 1

Pour une division en nombres réels, au moins un opérande doit être de type double (ou y être converti). Consultez Java Arithmetic Operators pour un traitement complet.

Unaire

int x = 5;
int neg = -x;       // -5
int inc = ++x;      // pre-increment: x becomes 6, inc is 6
int post = x++;     // post-increment: post is 6, then x becomes 7
boolean b = !true;  // false

++ et -- existent sous forme préfixe et postfixe. La forme préfixe modifie la variable puis retourne la nouvelle valeur ; la forme postfixe retourne l'ancienne valeur puis modifie la variable. Utilisez-les de préférence seuls sur leur propre ligne — imbriqués dans des expressions, ils sont une source fréquente de bugs.

Affectation

L'affectation de base est =. Les formes composées combinent une opération avec l'affectation :

int total = 0;
total += 5;    // total = total + 5
total *= 2;    // total = total * 2
total -= 1;    // total = total - 1

Les formes composées fonctionnent aussi avec les opérateurs bit à bit (&= |= ^=) et les décalages (<<= >>= >>>=). Une affectation composée effectue également un cast implicite vers le type de la variable, donc byte b = 10; b += 5; compile même si b + 5 est un int — un simple b = b + 5; ne compilerait pas. Consultez Java Assignment Operators pour les détails.

Comparaison

boolean a = (5 > 3);   // true
boolean b = (5 == 5);  // true
boolean c = (5 != 5);  // false

== fonctionne sur les primitives et les références. Sur les références, il teste l'identité des objets (même objet en mémoire), pas l'égalité du contenu. Pour comparer le contenu des objets, utilisez .equals() :

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

Cela surprend tout le monde la première fois. Le chapitre Java Comparison Operators explique pourquoi.

Logique

Les trois opérateurs logiques combinent des booléens :

boolean a = true && false;   // false
boolean b = true || false;   // true
boolean c = !true;           // false

&& et || court-circuitent — ils arrêtent l'évaluation dès que le résultat est connu. C'est essentiel quand un côté peut lever une exception :

if (list != null && list.size() > 0) { /* ... */ }  // safe — short-circuit

Parce que && s'arrête au premier false, list.size() n'est jamais appelé quand list est null, donc il n'y a pas de NullPointerException. Le chapitre Java Logical Operators couvre le court-circuit et les formes non-court-circuit &/| en détail.

Bit à bit

Pour manipuler des bits individuels :

int and    = 0b1100 & 0b1010;   // 0b1000 = 8
int or     = 0b1100 | 0b1010;   // 0b1110 = 14
int xor    = 0b1100 ^ 0b1010;   // 0b0110 = 6
int not    = ~0;                 // -1 — all bits flipped
int left   = 1 << 4;             // 16  — shift left
int right  = 16 >> 2;            // 4   — shift right (sign-preserving)
int uright = -1 >>> 28;          // 15  — unsigned shift right

La plupart du code Java du quotidien utilise ces opérateurs uniquement pour les drapeaux, le hachage et les entrées/sorties de bas niveau. Java Bitwise Operators va plus loin.

Ternaire

L'opérateur ternaire choisit entre deux expressions :

int x = 10;
String parity = (x % 2 == 0) ? "even" : "odd";   // "even"

Il s'évalue comme une valeur, il est donc plus utile comme partie droite d'une affectation ou à l'intérieur d'une expression plus grande. Pour des décisions en plusieurs étapes, utilisez un vrai if/else pour plus de lisibilité.

Précédence des opérateurs

Lorsque plusieurs opérateurs apparaissent dans une même expression, Java les évalue dans un ordre fixe. Les précédences les plus importantes, de la plus haute à la plus basse :

1. ++, --, unaire -, !, ~
2. *, /, %
3. +, -
4. <<, >>, >>>
5. <, <=, >, >=, instanceof
6. ==, !=
7. & (bitwise AND)
8. ^ (bitwise XOR)
9. | (bitwise OR)
10. &&
11. ||
12. ? :
13. =, +=, -=, etc.

En cas de doute, ajoutez des parenthèses. Elles ne coûtent rien à l'exécution et rendent l'intention évidente pour le prochain lecteur.

Une démonstration

La suite

Les chapitres suivants, catégorie par catégorie, approfondissent chaque groupe d'opérateurs. Java Arithmetic Operators est le prochain.

Pratique