Comment additionner deux nombres en Java

Additionner deux nombres est la première arithmétique que la plupart des gens écrivent en Java, mais la « bonne » manière dépend d’où viennent les nombres et de leur taille possible. Ce chapitre couvre les approches idiomatiques : le calcul avec des littéraux int, l’analyse de valeurs depuis du texte, l’addition en virgule flottante et l’addition sûre sans débordement silencieux.

Additionner deux valeurs int

Le cas le plus simple est l’addition de deux variables int avec l’opérateur +. Le résultat est lui-même un int.

int a = 7;
int b = 5;
int sum = a + b;
System.out.println(sum); // 12

C’est le cas quotidien et celui que vous écrirez le plus. La seule chose à surveiller est la plage de int : il contient des valeurs de -2 147 483 648 à 2 147 483 647. Additionnez au-delà de cette limite et la valeur boucle silencieusement au lieu de lever une exception — voir ci-dessous.

Additionner des nombres analysés depuis du texte

Quand les nombres arrivent sous forme de chaînes — depuis une saisie console, un fichier ou une requête HTTP —, vous devez les convertir avant de les additionner. Utilisez Integer.parseInt pour les entiers ou Double.parseDouble pour les décimaux.

String first = "42";
String second = "58";
int sum = Integer.parseInt(first) + Integer.parseInt(second);
System.out.println(sum); // 100

Une erreur fréquente de débutant est d’utiliser + directement sur les chaînes : "42" + "58" produit "4258" parce que + concatène les chaînes au lieu de les additionner. Analysez d’abord, puis additionnez. Si le texte n’est pas un nombre valide, parseInt lève une NumberFormatException, donc validez ou enveloppez l’appel dans un try/catch quand l’entrée n’est pas fiable.

Additionner des décimaux et gérer le débordement

Pour les valeurs décimales, additionnez des opérandes double (ou float). Sachez que la virgule flottante binaire ne peut pas représenter exactement chaque décimal, donc 0.1 + 0.2 vaut 0.30000000000000004, pas 0.3. Pour de l’argent, utilisez plutôt BigDecimal.

Pour les entiers qui peuvent dépasser la plage de int, élargissez un opérande en long, ou utilisez Math.addExact pour transformer le débordement en exception plutôt qu’en réponse fausse.

int big = Integer.MAX_VALUE;
System.out.println(big + 1);               // -2147483648 (wrapped!)
System.out.println((long) big + 1);        // 2147483648 (correct)
System.out.println(Math.addExact(big, 1)); // throws ArithmeticException

Un exemple détaillé

Ce qu’il faut retenir de l’exécution :

• int sum: 12 montre l’opérateur + simple additionnant deux valeurs int directement — le cas quotidien.
• parsed sum: 100 confirme que Integer.parseInt transforme "42" et "58" en nombres avant l’addition, au lieu de les concaténer en "4258".
• double sum: 0.30000000000000004 est l’erreur de représentation en virgule flottante de 0.1 + 0.2 — la preuve que double n’est pas exact pour les décimaux, alors tournez-vous vers BigDecimal quand la précision compte.
• int overflow: -2147483648 montre Integer.MAX_VALUE + 1 bouclant silencieusement vers le int le plus négatif, tandis que long safe: 2147483648 donne la bonne réponse en élargissant un opérande en long.
• addExact: overflow detected confirme que Math.addExact lève une ArithmeticException sur le même débordement au lieu de renvoyer une valeur fausse.

Practice