Opérateurs arithmétiques Java

Java dispose de cinq opérateurs arithmétiques : addition, soustraction, multiplication, division et reste. Leur syntaxe est identique à celle de C, JavaScript ou Python — mais le typage statique de Java introduit quelques surprises concernant la division et le dépassement de capacité qu'il est utile de connaître avant d'écrire le moindre calcul.

Cette page couvre les cinq opérateurs, la raison pour laquelle la division entière tronque, le comportement de % avec les nombres négatifs, la priorité des opérateurs, les raccourcis ++/--, le dépassement silencieux des entiers, et le piège de la précision en virgule flottante. Pour l'ensemble des opérateurs Java, consultez l'aperçu Java Operators.

Les cinq opérateurs

int a = 14;
int b = 4;

System.out.println(a + b);  // 18
System.out.println(a - b);  // 10
System.out.println(a * b);  // 56
System.out.println(a / b);  // 3   — integer division
System.out.println(a % b);  // 2   — remainder

La division entière tronque

Lorsque les deux opérandes de / sont des entiers, le résultat est un entier et la partie fractionnaire est supprimée (tronquée vers zéro) :

System.out.println(7 / 2);    // 3, not 3.5
System.out.println(-7 / 2);   // -3
System.out.println(1 / 3);    // 0

Pour obtenir un résultat en nombre réel, au moins un opérande doit être de type virgule flottante. Vous pouvez écrire un littéral en double (7.0) ou convertir un int en double :

System.out.println(7.0 / 2);        // 3.5
System.out.println(7 / 2.0);        // 3.5
System.out.println((double) 7 / 2); // 3.5

Le transtypage est prioritaire sur /, donc (double) 7 / 2 convertit d'abord 7, puis divise — donnant 3.5. Attention à (double) (7 / 2) : la division entière s'effectue en premier et vous obtenez 3.0.

Cela piège constamment les débutants. Si vous voyez 0 là où vous attendiez un quotient non nul, suspectez une division entière.

L'opérateur reste %

% retourne le reste de la division entière. Il est défini de sorte que (a / b) * b + (a % b) == a :

System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1  — sign matches the dividend
System.out.println(10 % -3);   // 1

Utilisations courantes :

• Tester la divisibilité : if (n % 2 == 0) vérifie si le nombre est pair.
• Indexation circulaire : arr[(i + 1) % arr.length] revient à 0 après le dernier élément.
• Extraire des chiffres ou des unités : n % 10 est le dernier chiffre ; seconds % 60 correspond aux secondes dans la minute.

Pour d'autres fonctions numériques — puissances, arrondis, racines carrées — consultez la Java Math Class.

% fonctionne aussi avec double, où il retourne le reste IEEE 754 — utile, mais la méthode Math.IEEEremainder offre un contrôle plus précis.

Priorité des opérateurs

Les règles standard s'appliquent :

1. *, /, % en premier
2. puis +, -
3. de gauche à droite au même niveau de priorité

int result = 2 + 3 * 4;      // 14, not 20
int result2 = (2 + 3) * 4;   // 20
int result3 = 10 - 2 - 3;    // 5  — left-to-right

En cas de doute, utilisez des parenthèses. Cela ne coûte rien.

Incrémentation et décrémentation — ++ et --

Les opérateurs unaires ++ et -- incrémentent ou décrémentent une variable de 1 :

int x = 5;
x++;     // x is 6
x--;     // x is 5

Ils existent sous forme préfixe (++x) et postfixe (x++). La différence n'a d'importance qu'à l'intérieur d'une expression :

int a = 5;
int b = a++;   // postfix: b is 5 (old value), a becomes 6
int c = ++a;   // prefix: a becomes 7, c is 7

Pour la lisibilité, placez ++ et -- sur leur propre ligne autant que possible.

Le dépassement de capacité est silencieux

L'arithmétique entière sur int et long se boucle en cas de dépassement — aucune exception n'est levée :

int max = Integer.MAX_VALUE;    // 2147483647
int wrapped = max + 1;          // -2147483648 (Integer.MIN_VALUE)

Si vous avez besoin de détecter les dépassements, utilisez Math.addExact, Math.multiplyExact, etc., qui lèvent une ArithmeticException en cas de dépassement.

Particularités de la virgule flottante

double est conforme à IEEE 754 — rapide et bien supporté, mais il ne peut pas représenter exactement la plupart des fractions décimales :

System.out.println(0.1 + 0.2);   // 0.30000000000000004

Ce n'est pas un bug Java — c'est ainsi que fonctionne la virgule flottante binaire. Pour les calculs monétaires, la précision scientifique, ou partout où vous avez besoin d'une arithmétique décimale exacte, utilisez BigDecimal :

import java.math.BigDecimal;

BigDecimal sum = new BigDecimal("0.1").add(new BigDecimal("0.2"));
System.out.println(sum);   // 0.3

(Passez toujours une chaîne de caractères à new BigDecimal(...) ; new BigDecimal(0.1) reprendrait quand même l'imprécision binaire.)

Une démonstration

Et ensuite

Java Assignment Operators — =, +=, et la famille des affectations composées.

Pratique