Deep Java

Come arrotondare i numeri in Java: Math.round(), cifre decimali, BigDecimal e RoundingMode

Fondamenti di Java
目次

1. Cosa significa “Arrotondamento (四捨五入)” in Java

Quando vuoi eseguire un “arrotondamento (四捨五入)” in Java, in realtà non esiste un unico metodo che arrotondi sempre come ti aspetti.
Questo perché in Java, l’approccio di arrotondamento appropriato dipende dal tipo numerico (int / double / BigDecimal, ecc.) e dallo scopo (calcolo vs visualizzazione).

In questa sezione, organizzeremo prima i concetti fondamentali e chiariremo perché l’arrotondamento in Java può risultare confuso.

1.1 Regola di arrotondamento di base (5 e oltre arrotonda per eccesso)

La regola generale di arrotondamento è la seguente:

  • Se la cifra successiva è 5 o più → arrotonda per eccesso
  • Se la cifra successiva è 4 o meno → arrotonda per difetto

Esempio (arrotondamento all’unità)

  • 1.4 → 1
  • 1.5 → 2

Questa regola è la stessa in Java, ma la vera sfida è “quale metodo applica questa regola” e “quante cifre puoi gestire”.

In Java, l’arrotondamento è tipicamente separato per scopo, ad esempio:

  • Vuoi semplicemente arrotondare un numero semplice
  • Vuoi arrotondare alla n‑esima cifra decimale
  • Hai bisogno di tolleranza zero per l’errore (ad esempio, calcoli monetari)

Se provi a gestire tutti questi casi con lo stesso approccio, otterrai spesso risultati indesiderati.

1.2 Perché l’arrotondamento in Java può risultare confuso

Le ragioni principali per cui l’arrotondamento in Java è spesso descritto come “difficile” o “non funziona come previsto” sono questi tre punti:

Motivo 1: Errori di precisione dei numeri in virgola mobile (double)

double è un tipo che rappresenta i decimali in binario.
Di conseguenza, anche numeri che sembrano puliti in decimale possono contenere errori di precisione interni.

Esempio:

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

Se arrotondi in questo stato, potresti ottenere risultati che non corrispondono all’intuizione umana.

Motivo 2: Non puoi “arrotondare direttamente alla n‑esima cifra decimale”

Java non fornisce un metodo dedicato tipo:
“arrotonda a 2 cifre decimali”
di default.

Quindi, nella maggior parte dei casi, devi usare un aggiustamento aritmetico, ad esempio:

  • Moltiplica per 10 o 100
  • Arrotonda
  • Riporta alla magnitudine originale

Se sbagli i passaggi, il risultato sarà errato.

Motivo 3: I metodi differiscono per comportamento e tipo di ritorno

Ad esempio, Math.round() è comodo, ma restituisce un tipo intero (int / long).
Se vuoi arrotondare mantenendo le cifre decimali, non puoi usarlo così com’è.

Trappole comuni e cose da tenere d’occhio

  • Assumere che “arrotondare = Math.round()” → Spesso insufficiente per 2+ cifre decimali o calcoli monetari
  • Eseguire calcoli monetari con double e arrotondare dopo → Gli errori possono accumularsi e diventare rischiosi in sistemi reali
  • Usare lo stesso arrotondamento per visualizzazione e calcolo → Potresti perdere precisione arrotondando i calcoli interni

L’arrotondamento è un processo per “pulire l’output finale”, e il momento e il tipo di dato a cui lo applichi sono estremamente importanti.

2. Arrotondamento con Math.round() (l’approccio più basilare)

Math.round() è uno dei metodi più basilari e semplici per arrotondare in Java.
È un buon primo approccio per i principianti, ma devi comprendere i suoi casi d’uso validi e le limitazioni per evitare usi impropri.

In questa sezione, organizzeremo l’uso corretto di Math.round() e le trappole comuni che potresti incontrare nello sviluppo reale.

2.1 Uso di base di Math.round()

Math.round() arrotonda il numero fornito al intero più vicino.

double a = 1.4;
double b = 1.5;

System.out.println(Math.round(a)); // 1
System.out.println(Math.round(b)); // 2

Punti chiave:

  • Arrotonda per eccesso quando la parte frazionaria è 0,5 o più
  • Arrotonda per difetto quando è meno di 0,5
  • Segue la regola standard di round‑half‑up

Sembra intuitivo, ma il tipo di ritorno è un aspetto importante da tenere in considerazione.

2.2 Attenzione: il tipo di ritorno è int / long

Math.round() cambia il suo tipo di ritorno a seconda del tipo dell’argomento.

Argument typeReturn type
floatint
doublelong

Esempio:

double x = 3.7;
long result = Math.round(x);

Il punto chiave è: il valore restituito è sempre di tipo intero.

In altre parole, non è adatto così com’è per casi come:

  • Vuoi mantenere i decimali nel risultato
  • Vuoi mantenere 1 o 2 cifre decimali

perché Math.round() produce un intero.

Esempio di errore comune

double price = 12.34;
double rounded = Math.round(price); // actually long → assigned to double

Questo codice non genera un errore di compilazione, ma
la parte frazionaria viene completamente persa e diventa 12.0, quindi fai attenzione.

2.3 Come arrotondare al 2° decimale o oltre (tecnica ×10 / ×100)

Se vuoi usare Math.round() per arrotondare al n‑esimo decimale,
di solito segui questo processo:

Passaggi

  1. Moltiplica il valore target per 10ⁿ
  2. Arrotonda a un intero con Math.round()
  3. Dividi per 10ⁿ per tornare alla scala originale

Esempio: Arrotondare a 2 decimali

double value = 1.234;
double rounded = Math.round(value * 100) / 100.0;

System.out.println(rounded); // 1.23

Esempio: Arrotondare a 1 decimale

double value = 1.25;
double rounded = Math.round(value * 10) / 10.0;

System.out.println(rounded); // 1.3

Questo approccio è semplice, ma non elimina completamente i problemi di precisione specifici dei double.

Insidie, avvertimenti e errori comuni

  • Dividere accidentalmente per interi Math.round(value * 100) / 100; // 100 è int → i decimali scompaiono → Usa sempre un double come 100.0
  • Usarlo direttamente per calcoli monetari → Va bene per la visualizzazione, ma spesso non è adatto per i calcoli
  • Arrotondare troppo presto → Se arrotondi i risultati intermedi, il valore finale può deviare

Math.round() è ottimo quando “vuoi solo un intero” o “vuoi arrotondare per la visualizzazione”, ma devi ricordare che
ha limitazioni quando la precisione è critica.

3. Un modo comune per arrotondare al n‑esimo decimale

Richieste come “Voglio arrotondare a 2 decimali” o “Voglio mantenere 3 decimali” sono estremamente comuni, e
questo è anche l’intento di ricerca principale dietro la parola chiave java 四捨五入.

In questa sezione, spiegheremo un approccio comune per arrotondare al n‑esimo decimale usando Math.round(),
e indicheremo chiaramente le sue limitazioni.

3.1 Il modello di formula di base

Poiché Java non fornisce un metodo dedicato per arrotondare al n‑esimo decimale,
un approccio ampiamente usato è scalare il numero, arrotondarlo e poi riportarlo alla scala originale.

Formula di base

Math.round(value × 10^n) ÷ 10^n

Esempio: Arrotondare a 2 decimali

double value = 12.345;
double rounded = Math.round(value * 100) / 100.0;

System.out.println(rounded); // 12.35

Esempio: Arrotondare a 3 decimali

double value = 12.34567;
double rounded = Math.round(value * 1000) / 1000.0;

System.out.println(rounded); // 12.346

Questo metodo è facile da capire ed è sufficientemente pratico per l’elaborazione di numeri solo a scopo di visualizzazione.

3.2 Un caso in cui non funziona bene (il problema 0.1 + 0.2)

Tuttavia, questo metodo non può evitare completamente gli errori di precisione dei double.

Un esempio classico è il caso seguente:

double value = 0.1 + 0.2;
double rounded = Math.round(value * 10) / 10.0;

System.out.println(value);   // 0.30000000000000004
System.out.println(rounded); // 0.3

Potrebbe sembrare corretto qui, ma a seconda del calcolo e del numero di cifre, potresti comunque ottenere risultati di arrotondamento inaspettati.

I seguenti casi sono particolarmente rischiosi:

  • Calcoli monetari
  • Calcoli cumulativi per aliquote fiscali o percentuali
  • Arrotondare ripetutamente all’interno di cicli

3.3 Perché si verificano gli errori (spiegazione molto breve)

double è un tipo a virgola mobile che rappresenta i decimali in binario.
Quindi anche valori esatti in base 10 possono includere piccoli errori nella loro rappresentazione interna.

Questo è un dettaglio della specifica Java, non un bug.

Idee sbagliate comuni

  • “La mia formula è sbagliata” → ❌
  • “Java è rotto” → ❌
  • “È dovuto alla natura del double” → ✅

Insidie, Avvertimenti e Errori Comuni

  • Ottenere l’ordine di scaling/divisione sbagliato Math.round(value) * 100 / 100.0; // senza senso
  • Usare un intero nella divisione Math.round(value * 100) / 100; // i decimali scompaiono
  • Arrotondare ripetutamente durante i passaggi intermedi → fa sì che gli errori si accumulino più facilmente

Questo metodo è “facile e veloce”, ma devi capire che può essere insufficiente quando è richiesta precisione.

4. Arrotondamento Accurato con BigDecimal (Consigliato)

Per i calcoli monetari, i calcoli fiscali e altri flussi di lavoro dove gli errori non sono accettabili, arrotondare con double e Math.round() non è appropriato.

In questi casi, l’approccio consigliato è usare BigDecimal.
BigDecimal è una classe che può gestire numeri in base 10 con precisione, ed è la soluzione standard in Java per “arrotondamenti accurati”.

4.1 Quando Dovresti Usare BigDecimal

Dovresti usare BigDecimal per casi come questi:

  • Calcoli monetari (prezzi, fatture, saldi)
  • Calcoli basati su tassi, come aliquote fiscali e tassi d’interesse
  • Sistemi di contabilità, finanza e business
  • Elaborazioni dove i risultati dell’arrotondamento devono essere riproducibili

Se il risultato del calcolo è importante di per sé (non solo la visualizzazione), è più sicuro scegliere BigDecimal invece di double.

4.2 Il Modo Corretto per Creare BigDecimal (new vs valueOf)

L’errore più comune con BigDecimal è crearlo nel modo sbagliato.

❌ Esempio errato (non consigliato)

BigDecimal bd = new BigDecimal(1.23);

Questo trasporta l’errore di precisione da double.

✅ Esempi corretti (consigliati)

BigDecimal bd1 = new BigDecimal("1.23");
BigDecimal bd2 = BigDecimal.valueOf(1.23);
  • Costruttore da Stringa: l’opzione più sicura
  • valueOf : sicuro perché converte internamente tramite String

Regola pratica: evita new BigDecimal(double).

4.3 Come Usare setScale() e RoundingMode

Per arrotondare con BigDecimal, tipicamente combini
setScale() con RoundingMode.

Esempio: Arrotondare a 2 cifre decimali

import java.math.BigDecimal;
import java.math.RoundingMode;

BigDecimal value = new BigDecimal("12.345");
BigDecimal rounded = value.setScale(2, RoundingMode.HALF_UP);

System.out.println(rounded); // 12.35
  • Primo argomento: numero di cifre decimali da mantenere
  • Secondo argomento: regola di arrotondamento

RoundingMode.HALF_UP corrisponde alla tipica regola “round half up” (5 e oltre arrotonda verso l’alto).

Insidie, Avvertimenti e Errori Comuni

  • Non specificare RoundingMode value.setScale(2); // può lanciare un'eccezione
  • Fare double → BigDecimal → arrotondamento nell’ordine sbagliato → Usa BigDecimal fin dall’inizio
  • Confondere visualizzazione e calcolo → Usa BigDecimal per il calcolo; formatta solo al momento della visualizzazione

BigDecimal aggiunge più codice, ma è essenziale ogni volta che precisione e sicurezza sono le massime priorità.

5. Tipi di RoundingMode e Differenze

Quando arrotondi con BigDecimal, il concetto chiave da capire è RoundingMode (modalità di arrotondamento).

RoundingMode definisce esplicitamente “quale regola usare”, e nella pratica dovrebbe essere considerato obbligatorio, perché non specificarlo rende il comportamento ambiguo.

5.1 HALF_UP (Arrotondamento tipico)

RoundingMode.HALF_UP corrisponde alla definizione più comune di arrotondamento.

Regola

  • Se la cifra successiva è 5 o più → arrotonda verso l’alto
  • Se la cifra successiva è 4 o meno → arrotonda verso il basso

Esempio

BigDecimal value = new BigDecimal("2.345");
BigDecimal rounded = value.setScale(2, RoundingMode.HALF_UP);

System.out.println(rounded); // 2.35

Se non hai una ragione speciale, scegliere HALF_UP per l’arrotondamento è di solito corretto.

5.2 Come Differisce da HALF_DOWN / HALF_EVEN

RoundingMode include diversi stili di arrotondamento con nomi simili. Molte persone si confondono, quindi chiarifichiamo le differenze.

HALF_DOWN

  • Se la cifra successiva è esattamente 5, arrotonda verso il basso
    2.345 → 2.34

HALF_EVEN (Arrotondamento bancario)

  • Se la cifra successiva è esattamente 5, arrotonda verso il numero pari più vicino
    2.345 → 2.34
2.355 → 2.36

HALF_EVEN è usato per ridurre il bias sistematico di arrotondamento e può essere specificato negli standard finanziari o statistici, ma non è necessario per la maggior parte dei casi aziendali generali e per il codice adatto ai principianti.

5.3 Come scegliere

Se non sei sicuro, la regola decisionale è semplice:

  • Arrotondamento tipico → HALF_UP
  • Dominio finanziario/regolamentato con uno standard definito → seguire la specifica
  • Nessuna ragione speciale → solo HALF_UP

Errori comuni

  • “Usare HALF_EVEN solo perché”
  • “Copia‑incolla senza capire la differenza”

I modi di arrotondamento sono parte della specifica del tuo sistema. Non dovresti cambiarli senza una ragione chiara.

Insidie, Avvertimenti ed Errori Comuni

  • Omettere RoundingMode → può causare eccezioni a runtime
  • Assumere che l’arrotondamento significhi sempre HALF_UP → può confliggere con le specifiche aziendali
  • Regole di arrotondamento non standardizzate all’interno del team → può portare a risultati di calcolo incoerenti

6. Insidie, Avvertimenti ed Esempi di Fallimento

L’arrotondamento in Java è un’area in cui è facile commettere errori anche se conosci la sintassi e le API. In questa sezione, riassumeremo gli errori che i principianti e gli sviluppatori di livello intermedio commettono più spesso, spiegando chiaramente “perché è sbagliato” e “come evitarlo”.

6.1 Eseguire calcoli monetari con double

Questo è sia l’errore più comune sia il più pericoloso.

double price = 1000.0;
double tax = price * 0.1;
double total = price + tax;

Potrebbe sembrare corretto a prima vista, ma poiché double è un tipo che può includere errori di precisione, introduce il rischio di risultati errati nei calcoli monetari.

Mentalità corretta

  • Per il calcolo: BigDecimal
  • Per la visualizzazione: arrotondamento/formattazione
    BigDecimal price = new BigDecimal("1000");
BigDecimal tax = price.multiply(new BigDecimal("0.1"));
BigDecimal total = price.add(tax);

6.2 Sbagliare l’ordine di arrotondamento

Con l’arrotondamento, quando lo applichi è importante.

❌ Esempio sbagliato

double a = Math.round(x * 100) / 100.0;
double b = Math.round(a * y * 100) / 100.0;

Se arrotondi ripetutamente durante i passaggi intermedi, gli errori si accumulano.

✅ Linea guida di base

  • Completa tutti i calcoli prima
  • Applica l’arrotondamento solo una volta al risultato finale

6.3 Mescolare arrotondamento di visualizzazione con arrotondamento di calcolo

Se confondi “arrotondamento per la visualizzazione” con “arrotondamento per i calcoli interni”, il tuo design si romperà.

Incomprensioni comuni

  • Usare un valore arrotondato per la visualizzazione nel calcolo successivo
  • Modificare la logica di calcolo per soddisfare i requisiti dell’interfaccia utente

Separazione corretta

  • Calcolo interno : dare priorità alla precisione (BigDecimal)
  • Visualizzazione : formattazione/arrotondamento

6.4 Non standardizzare RoundingMode

Se diverse parti del tuo codice usano una combinazione di HALF_UP, HALF_DOWN e HALF_EVEN, potresti ottenere risultati incoerenti dalla stessa operazione.

Contromisure

  • Definisci la regola di arrotondamento come costante
  • Standardizzala in tutto il team/progetto
    static final RoundingMode ROUND_MODE = RoundingMode.HALF_UP;

Riepilogo delle Insidie Comuni

  • Solo perché double “può calcolare” non significa che sia “accurato”
  • Arrotonda solo una volta, alla fine
  • Considera le regole di arrotondamento come parte della tua specifica
  • Separa calcolo e visualizzazione

Tenere questi punti a mente ti aiuta a evitare la maggior parte dei problemi legati all’arrotondamento.

7. Riferimento Rapido: Quale Metodo Usare (Per Caso d’Uso)

Come spiegato finora, Java ha diversi modi per arrotondare i numeri, e il punto chiave non è “qual è quello corretto”, ma che
la scelta corretta dipende dal caso d’uso.

In questa sezione, organizzeremo la selezione pratica dei metodi per scenario così i lettori possono decidere rapidamente.

7.1 Se vuoi un intero semplice → Math.round()

Casi d’uso tipici

  • Vuoi visualizzare un valore calcolato come intero
  • Conteggi, numero di persone, punti di valutazione, ecc.
  • Elaborazione in cui gli errori di precisione non sono un problema

Approccio consigliato

long result = Math.round(value);

Note

  • Il tipo di ritorno è int o long
  • Non adatto se devi mantenere i decimali

👉 Se “vuoi semplicemente un intero”, usa Math.round().

7.2 Se vuoi visualizzare fino a N cifre decimali → Math.round() + Scaling

Casi d’uso tipici

  • Numeri per la visualizzazione UI
  • Report e output di log
  • Casi in cui la precisione rigorosa non è richiesta

Approccio consigliato (2 cifre decimali)

double rounded = Math.round(value * 100) / 100.0;

Note

  • Gli errori di precisione del double rimangono comunque
  • Non usarlo per dati di calcolo

👉 Accettabile solo per la visualizzazione

7.3 Denaro, tasse, logica di business → BigDecimal + HALF_UP

Casi d’uso tipici

  • Denaro, fatturazione, pagamenti
  • Aliquote fiscali e tassi di sconto
  • Logica di business e dati persistiti

Approccio consigliato

BigDecimal rounded =
    value.setScale(2, RoundingMode.HALF_UP);

Perché

  • Gestisce correttamente i numeri in base 10
  • Rende esplicite le regole di arrotondamento
  • Garantisce la riproducibilità

👉 Questo è effettivamente l’approccio standard nei sistemi reali

7.4 Un semplice flusso decisionale quando non sei sicuro

  • “È accettabile qualche errore?” wp:list /wp:list

    • YES → Math.round() -based approaches
    • NO → BigDecimal

    • “Salverai/riutilizzerai il risultato?” wp:list /wp:list

    • YES → BigDecimal

    • NO (display only) → Math.round()

Errori comuni (Selezione del metodo)

  • Riutilizzare codice solo per la visualizzazione nella logica di business
  • Continuare a usare double per valori monetari
  • Abusare di Math.round() “perché è facile”

Una volta organizzata la selezione dei metodi, puoi ridurre significativamente il costo di futuri cambiamenti di specifiche e correzioni di bug.

FAQ (Domande Frequenti)

Q1. Qual è il modo più semplice per arrotondare in Java?

A. Se vuoi semplicemente arrotondare a un intero, Math.round() è il più semplice. Tuttavia, il tipo di ritorno è un intero, quindi non puoi mantenere i decimali.

Q2. Come arrotondo a 2 cifre decimali (o alla n‑esima cifra decimale)?

A. Per scopi di visualizzazione, scala il numero così:
Math.round(value * 100) / 100.0
Se ti serve precisione, usa BigDecimal.setScale().

Q3. Perché i risultati si discostano anche se sto usando Math.round()?

A. Questo è causato dagli errori di precisione del punto mobile in double. È parte del comportamento di Java, non un bug.

Q4. Dovrei evitare Math.round() per i calcoli monetari?

A. Sì, non è consigliato. Per i calcoli di denaro e tasse, è più sicuro usare BigDecimal e arrotondare con RoundingMode.HALF_UP.

Q5. Sto usando BigDecimal ma vedo ancora errori a volte

A. Potresti stare usando new BigDecimal(double).
Usa invece new BigDecimal("1.23") o BigDecimal.valueOf(1.23).

Q6. Quale RoundingMode dovrei scegliere?

A. Per l’arrotondamento tipico, RoundingMode.HALF_UP è un valore predefinito sicuro. Se il tuo dominio ha uno standard/specification definito, seguilo.

Q7. È accettabile arrotondare durante i calcoli intermedi?

A. Non consigliato. Arrotondare durante i passaggi intermedi fa accumulare gli errori, quindi la regola base è applicarlo solo al risultato finale.

Q8. Dovrei separare l’arrotondamento per la visualizzazione da quello per i calcoli?

A. Sì.

  • Per i calcoli: BigDecimal (prima la precisione)
  • Per la visualizzazione: Math.round() o formattazione Separarli è il design corretto.