Come sommare due numeri in Java

Sommare due numeri è la prima operazione aritmetica che la maggior parte delle persone scrive in Java, ma il modo "giusto" dipende da dove provengono i numeri e da quanto possono essere grandi. Questo capitolo illustra gli approcci idiomatici: l'addizione letterale con int, il parsing di valori da testo, l'addizione in virgola mobile e l'addizione sicura senza overflow silenzioso.

Sommare due valori int

Il caso più semplice consiste nel sommare due variabili int con l'operatore +, uno degli operatori aritmetici di Java. Il risultato è anch'esso un int.

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

Questo è il caso quotidiano, quello che scriverai più spesso. L'unica cosa da tenere d'occhio è l'intervallo di int: contiene valori da -2.147.483.648 a 2.147.483.647. Superare questo limite provoca un avvolgimento silenzioso del valore anziché un'eccezione — trattato più avanti.

Sommare numeri ottenuti dal parsing di testo

Quando i numeri arrivano come stringhe — da input da console, un file o una richiesta HTTP — è necessario convertirli prima di sommarli. Usa Integer.parseInt per i numeri interi o Double.parseDouble per i decimali.

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

Un errore comune per i principianti è usare + direttamente sulle stringhe: "42" + "58" produce "4258" perché + concatena le stringhe anziché sommarle. Prima esegui il parsing, poi sommale. Se il testo non è un numero valido, parseInt lancia NumberFormatException, quindi valida o racchiudi la chiamata in un try/catch quando l'input non è attendibile.

Sommare decimali e gestire l'overflow

Per i valori decimali, somma operandi double (o float). Tieni presente che la rappresentazione binaria in virgola mobile non può rappresentare ogni decimale esattamente, quindi 0.1 + 0.2 è 0.30000000000000004, non 0.3. Per il denaro, usa invece BigDecimal.

Per i numeri interi che possono superare l'intervallo di int, amplia un operando a long, oppure usa Math.addExact per trasformare l'overflow in un'eccezione anziché in un risultato errato. Scegliere il tipo numerico corretto fin dall'inizio è la difesa più pulita — consulta i tipi di dati Java per l'intervallo di ciascun tipo.

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

Sommare due numeri inseriti dall'utente

In un programma reale gli operandi spesso provengono dalla tastiera. Uno Scanner legge ogni riga e la converte in un numero in un unico passaggio con nextInt (o nextDouble per i decimali), quindi non è necessario chiamare parseInt manualmente.

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));
    }
}

Se l'utente digita qualcosa che non è un intero, nextInt lancia InputMismatchException. Proteggiti con hasNextInt() o un try/catch quando l'input non è attendibile.

Un esempio pratico

Cosa ricavare dall'esecuzione:

• int sum: 12 mostra l'operatore + che somma direttamente due valori int — il caso quotidiano.
• parsed sum: 100 conferma che Integer.parseInt trasforma "42" e "58" in numeri prima di sommarli, anziché concatenarli in "4258".
• double sum: 0.30000000000000004 è l'errore di rappresentazione in virgola mobile da 0.1 + 0.2 — prova che double non è esatto per i decimali, quindi usa BigDecimal quando la precisione è importante.
• int overflow: -2147483648 mostra Integer.MAX_VALUE + 1 che si avvolge silenziosamente al valore int più negativo, mentre long safe: 2147483648 fornisce la risposta corretta ampliando un operando a long.
• addExact: overflow detected conferma che Math.addExact lancia ArithmeticException sullo stesso overflow anziché restituire un valore errato.

Pratica