1. Introduzione
Nella vita reale è raro che ci serva vedere lunghi «decimali» dopo la virgola. Per esempio, se calcoli il prezzo di un prodotto, lo stipendio, la media dei voti o l’area di una stanza — di solito bastano un paio di cifre decimali, e non 15.
Per esempio, il risultato della divisione:
double x = 10.0 / 3.0;
System.out.println(x); // 3.3333333333333335
Un utente, vedendo un risultato del genere, potrebbe spaventarsi e pensare che il programma sia impazzito. Perciò spesso i numeri vanno arrotondati — al più vicino intero, a due cifre decimali e così via.
In Java esistono diversi strumenti comodi per farlo.
2. Metodo Math.round(): arrotondare al più vicino intero
Il modo più semplice per arrotondare un numero è usare il metodo Math.round(). Accetta un numero in virgola mobile (sia float che double) e restituisce l’intero più vicino.
Come funziona Math.round
- Se la parte frazionaria è minore di 0.5 — arrotonda per difetto.
- Se la parte frazionaria è 0.5 o maggiore — arrotonda per eccesso.
Esempi:
System.out.println(Math.round(2.3)); // 2
System.out.println(Math.round(2.7)); // 3
System.out.println(Math.round(2.5)); // 3
System.out.println(Math.round(-2.5)); // -2
Tipo del valore restituito
- Se si passa un float, restituisce un int.
- Se si passa un double, restituisce un long.
float f = 5.8f;
int roundedF = Math.round(f); // 6
double d = 5.8;
long roundedD = Math.round(d); // 6
Attenzione: a volte questo sorprende — si arrotonda un double e si ottiene un long! Se ti serve un int, devi fare un cast esplicito:
int rounded = (int) Math.round(5.6); // 6
3. Arrotondare a un numero desiderato di cifre decimali
Spesso serve arrotondare non all’intero, ma, per esempio, a due cifre decimali (per denaro, percentuali ecc.).
In Java non esiste un metodo «magico» come Math.roundTo2Digits(), ma si può fare manualmente.
Metodo 1: trucco matematico con moltiplicazione e divisione
- Moltiplica il numero per 100 (se servono due cifre).
- Arrotonda all’intero con Math.round.
- Dividi di nuovo per 100.
Esempio:
double value = 3.14159;
double rounded = Math.round(value * 100.0) / 100.0;
System.out.println(rounded); // 3.14
Come funziona:
- 3.14159 * 100 = 314.159
- Math.round(314.159) = 314
- 314 / 100.0 = 3.14
4. Formattazione dei numeri: classe DecimalFormat
A volte non basta arrotondare un numero, ma occorre anche visualizzarlo bene — con un certo numero di cifre decimali, zeri iniziali, separatori delle migliaia ecc. Per questo in Java c’è la classe DecimalFormat del pacchetto java.text.
Come funziona DecimalFormat
- Crea un oggetto con il pattern desiderato.
- Chiama su di esso il metodo format(...).
import java.text.DecimalFormat;
double value = 3.14159;
DecimalFormat df = new DecimalFormat("0.00");
System.out.println(df.format(value)); // 3.14
Com'è fatto il pattern
- "0.00" — sempre due cifre decimali (anche se il numero è intero).
- "0.###" — fino a tre cifre decimali, gli zeri superflui non vengono mostrati.
- "#,##0.00" — aggiunge i separatori delle migliaia (per esempio, "1,234.56").
Esempi di pattern diversi:
| Pattern | Numero | Risultato |
|---|---|---|
|
2 | 2.00 |
|
2.5 | 2.50 |
|
2.567 | 2.57 |
|
2.567 | 2.567 |
|
2.5 | 2.5 |
|
12345.678 | 12,345.68 |
Esempio con separatori delle migliaia
DecimalFormat df = new DecimalFormat("#,##0.00");
System.out.println(df.format(1234567.89)); // 1,234,567.89
Esempio: output senza zeri superflui
DecimalFormat df = new DecimalFormat("0.##");
System.out.println(df.format(3.1)); // 3.1
System.out.println(df.format(3.141)); // 3.14
System.out.println(df.format(3.145)); // 3.15
5. Formattazione con String.format
A volte, per i casi semplici, è comodo usare String.format — un modo integrato per formattare le stringhe, simile a printf in altri linguaggi.
double value = 3.14159;
System.out.println(String.format("%.2f", value)); // 3.14
Qui "%.2f" significa «stampare il numero con due cifre decimali».
Confronto degli approcci:
- DecimalFormat — più potente, supporta pattern e localizzazione, comodo per i separatori delle migliaia.
- String.format — più semplice quando serve solo specificare il numero di cifre decimali.
6. Particolarità dell'arrotondamento: Math.floor, Math.ceil, Math.rint
- Math.floor(x) — arrotonda per difetto (verso il basso), anche per i numeri negativi.
- Math.ceil(x) — arrotonda per eccesso (verso l’alto).
- Math.rint(x) — arrotonda al più vicino intero, ma restituisce double.
Esempi:
System.out.println(Math.floor(2.7)); // 2.0
System.out.println(Math.ceil(2.1)); // 3.0
System.out.println(Math.rint(2.5)); // 2.0 (sì sì, non è un refuso!)
System.out.println(Math.rint(3.5)); // 4.0
Attenzione: Math.rint talvolta arrotonda «al più vicino pari» — questa regola (il cosiddetto banker's rounding) aiuta a ridurre l’accumulo degli errori nei calcoli massivi.
7. Dettagli utili
Visualizzazione: tabella degli arrotondamenti
| Numero | Math.round | Math.floor | Math.ceil | Math.rint |
|---|---|---|---|---|
| 2.3 | 2 | 2.0 | 3.0 | 2.0 |
| 2.5 | 3 | 2.0 | 3.0 | 2.0 |
| 3.5 | 4 | 3.0 | 4.0 | 4.0 |
| -2.3 | -2 | -3.0 | -2.0 | -2.0 |
| -2.5 | -2 | -3.0 | -2.0 | -2.0 |
Arrotondare non è formattare!
È molto importante capire la differenza tra arrotondamento e formattazione.
- Arrotondamento — modifica del valore del numero (per esempio, 2.718 → 2.72).
- Formattazione — modifica di come il numero appare in output (per esempio, 2.718 → "2.72" a schermo, ma in memoria resta 2.718).
double x = 2.718;
System.out.println(String.format("%.2f", x)); // 2.72
System.out.println(x); // 2.718
Se vuoi usare il numero arrotondato in calcoli successivi — arrotonda matematicamente! Se serve solo per la visualizzazione — formatta.
8. Errori tipici nell'arrotondamento e nella formattazione dei numeri
Errore n. 1: si arrotonda solo per l’output e poi si usa il numero «con molti decimali».
Capita spesso: si stampa a schermo un valore ben formattato e poi si usa nei calcoli il numero originale «lungo». Per importi monetari, punteggi e totali — prima arrotonda (per esempio Math.round o il trucco con moltiplicazione/divisione), poi salva/trasmetti il valore all’utente.
Errore n. 2: aspettarsi che Math.round(x) restituisca un double con due cifre decimali.
Math.round() arrotonda sempre all’intero più vicino: per float restituisce int, per double restituisce long. Per due cifre usa moltiplicazione/divisione o la formattazione.
Errore n. 3: usare DecimalFormat per i calcoli.
DecimalFormat.format() restituisce una stringa. Non puoi usarla in aritmetica: otterrai un errore di compilazione o una NumberFormatException durante il parsing inverso.
Errore n. 4: pattern DecimalFormat errato.
Il pattern deve corrispondere alle aspettative: "0.00" mostra sempre due cifre ("2.00"), mentre "0.##" elimina gli zeri superflui ("2", "2.1", "2.12").
Errore n. 5: perdita di precisione quando si divide per 100.
Se dividi un int per un int, anche il risultato è int!
int a = 5;
System.out.println(a / 2); // 2, non 2.5!
Per ottenere una divisione «con la virgola», almeno uno degli operandi deve essere double:
int a = 5;
System.out.println(a / 2.0); // 2.5
GO TO FULL VERSION