Operatori Aritmetici in Java

Java dispone di cinque operatori aritmetici: addizione, sottrazione, moltiplicazione, divisione e resto. La loro sintassi è la stessa del C, JavaScript o Python — ma la tipizzazione statica di Java introduce alcune sorprese riguardo alla divisione e all'overflow che vale la pena conoscere prima di scrivere un singolo calcolo.

Questa pagina tratta tutti e cinque gli operatori, il motivo per cui la divisione intera tronca, il comportamento di % con i numeri negativi, la precedenza degli operatori, le abbreviazioni ++/--, l'overflow silenzioso degli interi e l'insidia della precisione in virgola mobile. Per il set completo degli operatori Java, consulta la panoramica degli Operatori Java.

I cinque operatori

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 divisione intera tronca

Quando entrambi gli operandi di / sono interi, il risultato è un intero e la parte frazionaria viene eliminata (troncata verso zero):

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

Per ottenere un risultato in numero reale, almeno uno degli operandi deve essere di tipo in virgola mobile. Puoi scrivere un letterale come double (7.0) oppure convertire un int in 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

Il cast ha precedenza maggiore rispetto a /, quindi (double) 7 / 2 converte prima 7, poi divide — ottenendo 3.5. Attenzione a (double) (7 / 2): la divisione intera avviene prima e si ottiene 3.0.

Questo è uno degli errori più comuni per i principianti. Se vedi 0 dove ti aspettavi un quoziente non zero, sospetta la divisione intera.

L'operatore resto %

% restituisce il resto della divisione intera. È definito in modo che (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

Usi comuni:

• Verificare la divisibilità: if (n % 2 == 0) controlla se il numero è pari.
• Indicizzazione ciclica: arr[(i + 1) % arr.length] torna a 0 dopo l'ultimo elemento.
• Estrarre cifre o unità: n % 10 è l'ultima cifra; seconds % 60 sono i secondi nel minuto.

Per ulteriori funzioni numeriche — potenze, arrotondamento, radici quadrate — consulta la Classe Math di Java.

% funziona anche con double, dove restituisce il resto IEEE 754 — utile, ma il metodo Math.IEEEremainder offre un controllo più preciso.

Precedenza degli operatori

Si applicano le regole standard:

1. Prima *, /, %
2. Poi +, -
3. Da sinistra a destra all'interno dello stesso livello di precedenza

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

In caso di dubbio, usa le parentesi. Non costa nulla.

Incremento e decremento — ++ e --

Gli operatori unari ++ e -- incrementano o decrementano una variabile di 1:

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

Esistono nella forma prefissa (++x) e postfissa (x++). La differenza è rilevante solo all'interno di un'espressione:

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

Per leggibilità, mantieni ++ e -- su una riga propria quando possibile.

L'overflow avviene silenziosamente

L'aritmetica intera su int e long va in overflow circolare — non lancia un'eccezione:

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

Se hai bisogno di rilevare l'overflow, usa Math.addExact, Math.multiplyExact, ecc., che lanciano ArithmeticException in caso di overflow.

Particolarità dei numeri in virgola mobile

double è IEEE 754 — veloce e ben supportato, ma non può rappresentare la maggior parte delle frazioni decimali in modo esatto:

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

Non si tratta di un bug di Java — è il modo in cui funziona la virgola mobile binaria. Per denaro, precisione scientifica o ovunque sia necessaria un'aritmetica decimale esatta, usa BigDecimal:

import java.math.BigDecimal;

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

(Passa sempre una stringa a new BigDecimal(...); new BigDecimal(0.1) acquisirà comunque l'imprecisione binaria.)

Una dimostrazione

Cosa c'è dopo

Operatori di Assegnazione Java — =, += e la famiglia degli operatori di assegnazione composti.

Esercitati