Comment additionner deux nombres en Java

Additionner deux nombres est la première opération arithmétique que la plupart des gens écrivent en Java, mais la « bonne » façon dépend de l'origine des nombres et de leur taille potentielle. Ce chapitre couvre les approches idiomatiques : l'addition littérale avec int, l'analyse de valeurs depuis du texte, l'addition en virgule flottante et l'addition sécurisée sans débordement silencieux.

Additionner deux valeurs int

Le cas le plus simple consiste à additionner deux variables int avec l'opérateur +, l'un des opérateurs arithmétiques de Java. 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 courant, celui que vous écrirez le plus souvent. La seule chose à surveiller est la plage de int : il contient des valeurs de -2 147 483 648 à 2 147 483 647. Si vous dépassez cette limite, la valeur revient silencieusement à zéro au lieu de lever une exception — ce point est abordé ci-dessous.

Additionner des nombres analysés depuis du texte

Lorsque 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 courante chez les débutants est d'utiliser + directement sur les chaînes : "42" + "58" produit "4258" car + concatène les chaînes plutôt que de les additionner. Analysez d'abord, puis additionnez. Si le texte n'est pas un nombre valide, parseInt lève une NumberFormatException, il convient donc de valider ou d'encadrer l'appel dans un try/catch lorsque la saisie 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 chaque décimal exactement, donc 0.1 + 0.2 donne 0.30000000000000004 et non 0.3. Pour les montants monétaires, utilisez BigDecimal à la place.

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ésultat incorrect. Choisir le bon type numérique dès le départ est la solution la plus propre — consultez les types de données Java pour la plage de chaque type.

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

Additionner deux nombres saisis par l'utilisateur

Dans un vrai programme, les opérandes viennent souvent du clavier. Un Scanner lit chaque ligne et la convertit en nombre en une seule étape avec nextInt (ou nextDouble pour les décimaux), vous n'avez donc pas à appeler parseInt vous-même.

import java.util.Scanner;

public class AddInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter first number: ");
        int a = scanner.nextInt();
        System.out.print("Enter second number: ");
        int b = scanner.nextInt();
        System.out.println("Sum: " + (a + b));
    }
}

Si l'utilisateur saisit quelque chose qui n'est pas un entier, nextInt lève une InputMismatchException. Protégez-vous contre cela avec hasNextInt() ou un try/catch lorsque la saisie n'est pas fiable.

Un exemple complet

Ce que retenir de l'exécution :

• int sum: 12 montre l'opérateur + simple additionnant deux valeurs int directement — le cas courant.
• parsed sum: 100 confirme que Integer.parseInt transforme "42" et "58" en nombres avant de les additionner, plutôt que 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, donc utilisez BigDecimal lorsque la précision est importante.
• int overflow: -2147483648 montre Integer.MAX_VALUE + 1 qui revient silencieusement à la valeur int la plus négative, 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 ArithmeticException sur le même débordement au lieu de retourner une valeur incorrecte.

Pratique