Come troncare i decimali in Java (cast a int, Math.floor, BigDecimal setScale)

1. Cosa Significa “Truncare i Decimali” in Java?

Quando la gente dice “truncare i decimali” in Java, di solito intende rimuovere la parte frazionaria per ottenere un intero oppure eliminare le cifre dopo la n‑esima cifra decimale.
Nel codice reale, però, “truncare” può significare più di una cosa, quindi chiarifichiamo prima la conclusione.

1.1 “Truncare” significa floor? O cast? (Terminologia)

Esistono principalmente due pattern di “troncamento”.

• (A) Troncamento verso 0 (truncate) Rimuove la parte frazionaria, ma per i numeri negativi si avvicina “verso zero”. Esempi: 3.9 → 3 , -3.9 → -3 → In Java, il cast (int) si comporta così
• (B) Troncamento verso −∞ (floor) Si sposta verso il basso (verso valori più piccoli) sulla retta numerica Esempi: 3.9 → 3 , -3.9 → -4 → In Java, Math.floor() si comporta così

I principianti spesso si confondono perché per i numeri positivi, (A) e (B) producono lo stesso risultato.
Ma nel momento in cui si gestiscono numeri negativi, i risultati divergono.

1.2 Cosa Ti Aiuta a Fare Questo Articolo (Percorso più Veloce per Caso d’Uso)

Le persone che cercano “java truncate decimals” di solito vogliono una delle seguenti cose.

• Convertire semplicemente in un intero (es., 3.14 → 3) → Il cast con (int) è il più veloce. Attenzione però ai numeri negativi.
• Truncare a 2 cifre decimali (es., 1.239 → 1.23) → Math.floor(x * 100) / 100 può funzionare → Ma se la precisione è importante, BigDecimal è più sicuro
• Denaro/fatturazione/tassi dove gli errori sono inaccettabili → Usa BigDecimal + setScale + RoundingMode

Se scegli il metodo sbagliato, spesso “sembra funzionare” ma si rompe in seguito.
In particolare, i calcoli basati su double possono introdurre errori di precisione, quindi per la logica legata al denaro è più sicuro progettare fin da subito con BigDecimal.

1.3 Trappole Comuni (Correggi Prima Queste)

Tre errori frequenti sono:

• Supporre che (int) significhi sempre floor → In realtà arrotonda verso zero, quindi i numeri negativi differiscono.
• Usare Math.floor per truncare i decimali, ma ottenere leggere discrepanze → Spesso causate dalla precisione del double (dipende dai valori/ambiente).
• Usare la formattazione (DecimalFormat, ecc.) come se cambiasse il valore calcolato → La visualizzazione può cambiare mentre il valore interno rimane lo stesso.

Prima conferma il percorso più breve: “Se ti serve solo un intero, fai il cast.” Poi comprendi la “trappola dei numeri negativi”.

Nella sezione successiva spiegheremo il troncamento tramite cast (int) con esempi concreti.

2. Se Vuoi Solo un int, il Cast Funziona (Ma C’è un Problema)

Se vuoi solo rimuovere la parte frazionaria e ottenere un intero (int), l’approccio più veloce in Java è il cast (conversione di tipo).
Ma il cast non è “troncamento matematico (floor)”. È arrotondamento verso zero (truncate), il che conta molto.

2.1 Nozioni Base: Truncare la Parte Frazionaria con (int)

Quando converti un double o float in int, la parte frazionaria viene scartata.

double x = 3.99;
int a = (int) x;
System.out.println(a); // 3

Questa è la risposta più semplice per l’intento comune “voglio truncare i decimali”.

I passaggi sono:

• Verificare che il valore sia un double / float
• Aggiungere (int) per castarlo a int
• Verificare il risultato—inclusi i numeri negativi se possono comparire

2.2 Importante: Il Cast Arrotonda Verso Zero (I Numeri Negativi Differiscono)

Questa è la trappola #1 per i principianti.
Il cast non “scende sempre al valore più piccolo”.

System.out.println((int) 3.9);   // 3
System.out.println((int) -3.9);  // -3

-3.9 che diventa -3 (non -4) avviene perché il cast converte nella direzione più vicina a zero.

• 3.9 → 3 (verso zero)
• -3.9 → -3 (verso zero)

Se vuoi “troncamento matematico (floor)”, devi usare Math.floor(), non il cast.
Se ti dimentichi di questo, puoi incorrere in bug in cose come calcoli di P&L, calcoli di commissioni o matematica delle coordinate, dove solo il lato negativo è errato.

2.3 Errori comuni: Supporre l’arrotondamento / Interruzione sui numeri negativi

Il casting non è arrotondamento al più vicino.
Se pensi che “0,9 diventi 1”, sbaglierai.

System.out.println((int) 0.9);  // 0
System.out.println((int) 1.9);  // 1

Inoltre, con i numeri negativi può sembrare che il valore “aumenti” o “diminuisca” in modo inatteso.

• -3.9 → -3 si sposta nella direzione più grande sulla retta numerica
• Se ti aspettavi -4, questo è un vero bug

La correzione è semplice:

• Se gestisci solo valori positivi → il casting va bene
• Se possono comparire valori negativi → considera Math.floor()
• Se è richiesta precisione rigorosa (denaro, ecc.) → considera BigDecimal

Nella sezione successiva, spiegheremo Math.floor() / Math.ceil(), che ti permette di troncare in modo matematicamente coerente anche per i numeri negativi.

3. Usa Math.floor / Math.ceil per il corretto troncamento decimale

Se vuoi troncare i decimali matematicamente correttamente, l’approccio di base è usare Math.floor() invece del casting.
Soprattutto quando possono comparire numeri negativi, scegliere semplicemente Math.floor() riduce notevolmente i bug.

3.1 Troncamento con Math.floor() (Funzione floor)

Math.floor() è chiamata funzione floor e arrotonda i valori verso il basso (verso valori più piccoli) sulla retta numerica.

System.out.println(Math.floor(3.9));   // 3.0
System.out.println(Math.floor(-3.9));  // -4.0

Punti chiave:

• 3.9 → 3.0 (si sposta verso il basso)
• -3.9 → -4.0 (si sposta ancora più verso il basso)

Il vantaggio più grande è che il troncamento non si comporta in modo inatteso con i numeri negativi.

Una trappola comune è che Math.floor() restituisce un double.
Se ti serve un intero, devi convertirlo successivamente.

3.2 Math.ceil() arrotonda verso l’alto — Non confonderla

Math.ceil() è l’opposto di Math.floor() e arrotonda verso l’alto (verso valori più grandi) sulla retta numerica.

System.out.println(Math.ceil(3.1));   // 4.0
System.out.println(Math.ceil(-3.1));  // -3.0

Un errore comune è:

• Pensare che “rimuovere i decimali” significhi ceil → In realtà, ceil arrotonda verso l’alto, il che è spesso l’opposto di ciò che desideri.

Se hai cercato “troncare decimali”, floor è solitamente la scelta corretta.

3.3 Conversione di tipo quando si converte a long / int

Se vuoi convertire il risultato di Math.floor() in int o long, devi effettuare il cast.

double x = -3.9;

int a = (int) Math.floor(x);
System.out.println(a); // -4

Punti da tenere d’occhio:

• Il risultato di Math.floor() è un double
• Il cast a int rimuove la parte decimale (nessun mismatch in questa fase)
• Se il valore è troppo grande, potrebbe non entrare in un int

Per sicurezza, puoi scegliere prima long.

double x = 12345678901.9;

long b = (long) Math.floor(x);
System.out.println(b); // 12345678901

Gli errori comuni includono:

• Dimenticare di fare il cast e lasciare il valore come double
• Non comprendere la differenza tra floor e casting, causando bug con i negativi
• Overflow quando si supera l’intervallo di int

In breve, se possono essere coinvolti numeri negativi, è più sicuro progettare fin dall’inizio attorno a Math.floor().

Nella sezione successiva, spiegheremo come troncare alla n-esima cifra decimale (ad esempio, mantenendo due decimali) con esempi concreti.

4. Come troncare alla n-esima cifra decimale (comune in visualizzazioni e calcoli)

Nelle applicazioni reali, è molto comune voler mantenere fino a una certa cifra decimale e scartare il resto, non solo rimuovere tutti i decimali. Esempi includono aliquote fiscali, tassi di cambio, prezzi unitari e percentuali.

Qui organizziamo metodi pratici per troncare alla n-esima cifra decimale. Quando si usa double, possono verificarsi problemi di precisione, quindi tratteremo anche le insidie.

4.1 Modello base: Moltiplicare per 10^n, floor, poi dividere

1. Decidi il numero di decimali n
2. Moltiplica per 10^n
3. Applica Math.floor()
4. Dividi per 10^n per ripristinare la scala

Per troncare a 2 decimali (ad es., 1.239 → 1.23):

double x = 1.239;
double y = Math.floor(x * 100) / 100;
System.out.println(y); // 1.23

Per troncare a 3 decimali (ad es., 1.2399 → 1.239):

double x = 1.2399;
double y = Math.floor(x * 1000) / 1000;
System.out.println(y); // 1.239

Vantaggi di questo approccio:

• Codice breve e facile
• Usa Math.floor(), quindi il comportamento con numeri negativi è coerente
• Nessuna libreria aggiuntiva richiesta

Tuttavia, poiché si basa su double, non è adatto per calcoli rigorosi come il denaro.

4.2 Insidia: Risultati Inattesi a Causa della Precisione double

Il double di Java è un tipo a virgola mobile e non può sempre rappresentare valori come 0.1 o 0.01 esattamente.
Di conseguenza, potresti vedere discrepanze apparentemente “senza senso” (a seconda dei valori e dell’ambiente).

• Aspetti 1.29, ma appare come 1.28
• Gestisci 0.3, ma internamente è 0.299999999...

Ad esempio, il seguente codice sembra logicamente corretto:

double x = 1.29;
double y = Math.floor(x * 100) / 100;
System.out.println(y);

Ma internamente, x * 100 potrebbe essere rappresentato come 128.999999999....
Se floor restituisce 128, il risultato diventa 1.28.
Questo non è un bug in Java, ma una proprietà dell’aritmetica a virgola mobile.

La parte tricky è che questo accade solo occasionalmente, il che lo rende difficile da catturare durante i test.

4.3 Tronca in Modo Sicuro con BigDecimal (Raccomandato)

Se vuoi troncare al n-esimo posto decimale in modo affidabile, usare BigDecimal è la scelta più sicura.
BigDecimal gestisce i numeri in base-10 esattamente ed è comunemente usato per calcoli monetari.

Il pattern base è:

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

BigDecimal x = new BigDecimal("1.239");
BigDecimal y = x.setScale(2, RoundingMode.DOWN); // truncate at 2 decimal places
System.out.println(y); // 1.23

Punti chiave:

• setScale(2, ...) mantiene due decimali
• RoundingMode.DOWN specifica la troncazione verso zero

Nota che DOWN di BigDecimal non è lo stesso di Math.floor().
Con numeri negativi, il comportamento differisce, quindi potresti dover considerare anche FLOOR (spiegato più avanti).

Errori comuni includono:

• Creare BigDecimal da un double (introducendo errori di precisione)
• Dimenticare di chiamare setScale
• Usare la modalità di arrotondamento sbagliata e arrotondare accidentalmente half-up

In sintesi, Math.floor potrebbe essere sufficiente per scopi di sola visualizzazione, ma per calcoli importanti, BigDecimal è la scelta più sicura.

Nella prossima sezione, approfondiremo la troncazione con BigDecimal, inclusa il modo corretto di creare istanze per codice del mondo reale.

5. Troncamento con BigDecimal (Il Più Sicuro per Finanza, Fatturazione e Tassi)

Se vuoi troncare i decimali con massima accuratezza, BigDecimal dovrebbe essere la tua prima scelta in Java.
double è veloce ma soggetto a errori di precisione, che spesso causano problemi in seguito nei calcoli di denaro, fatturazione, commissioni o tassi.
BigDecimal gestisce i numeri decimali in un modo più vicino alle aspettative umane, quindi è ampiamente usato nel codice aziendale.

5.1 Fondamenti di BigDecimal: Creare da double È Pericoloso (Il Più Importante)

Un errore molto comune con BigDecimal è come viene creato.
Se passi un double direttamente, l’errore di precisione interno potrebbe essere preservato.

import java.math.BigDecimal;

BigDecimal a = new BigDecimal(0.1);
System.out.println(a); // May become something like 0.10000000000000000555...

Troncare o calcolare con questo valore spesso porta a discrepanze “misteriose”.

Modi sicuri per creare BigDecimal sono:

(A) Crea da una Stringa (il più esplicito e sicuro)

BigDecimal a = new BigDecimal("0.1");

(B) Usa BigDecimal.valueOf(double) (spesso raccomandato)

BigDecimal a = BigDecimal.valueOf(0.1);

Per i principianti, la regola più sicura è: quando hai dei dubbi, crea BigDecimal da una Stringa.

5.2 Truncare a n cifre decimali con RoundingMode.DOWN

Per troncare alla n‑esima cifra decimale, usa setScale.

• setScale(2, ...) → mantieni due cifre decimali
• RoundingMode.DOWN → tronca verso zero

  import java.math.BigDecimal;
  import java.math.RoundingMode;
  
  BigDecimal x = new BigDecimal("123.4567");
  BigDecimal y = x.setScale(2, RoundingMode.DOWN);
  
  System.out.println(y); // 123.45
  

Se vuoi eliminare tutte le cifre decimali e ottenere un valore simile a un intero, si applica lo stesso approccio.

BigDecimal x = new BigDecimal("123.999");
BigDecimal y = x.setScale(0, RoundingMode.DOWN);

System.out.println(y); // 123

Un dettaglio importante: setScale cambia il valore stesso, non solo il modo in cui viene visualizzato.
Questa è un’operazione di calcolo, non di formattazione.

5.3 Troncare verso zero vs direzione floor (Differenza importante)

BigDecimal offre molteplici modalità di arrotondamento, e ce ne sono due che sembrano “troncamento”, il che può creare confusione.

• RoundingMode.DOWN : tronca verso zero
  • 3.9 → 3
  • -3.9 → -3
• RoundingMode.FLOOR : tronca verso −∞ (floor matematico)
  • 3.9 → 3
  • -3.9 → -4

Se vuoi che i valori si spostino sempre verso il lato più piccolo della retta numerica, FLOOR è la scelta corretta.

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

BigDecimal x1 = new BigDecimal("-3.9");
System.out.println(x1.setScale(0, RoundingMode.DOWN));  // -3
System.out.println(x1.setScale(0, RoundingMode.FLOOR)); // -4

Quale sia “corretto” dipende interamente dal tuo caso d’uso.

• Semplicemente eliminare le cifre (troncamento) → DOWN
• Troncamento matematico (floor) → FLOOR

Se questa distinzione non è chiara, i valori negativi possono causare gravi bug di specifica.

5.4 Errori comuni con BigDecimal

Ecco gli errori più frequenti quando si tronca con BigDecimal:

• Creare BigDecimal da double e introdurre errori di precisione → Evita new BigDecimal(0.1) ; usa una Stringa o valueOf
• Usare la scala sbagliata → Per esempio, usare 0 invece di 2 cifre decimali
• Confondere le modalità di arrotondamento → Confondere DOWN e FLOOR, causando problemi con numeri negativi
• Modificare i valori quando intendevi solo formattare → setScale cambia il valore; separa calcolo e visualizzazione

In sintesi, per denaro, fatturazione o tariffe—dove anche una differenza di un centesimo conta— usa BigDecimal e correggi sia il metodo di creazione sia la modalità di arrotondamento.

Nella sezione successiva, spiegheremo come evitare di confondere formattazione di visualizzazione e troncamento di calcolo.

6. DecimalFormat / String.format sono solo per la visualizzazione (non usarli per i calcoli)

Quando si troncano i decimali, è fondamentale distinguere se si vuole troncare il valore calcolato o solo formattare la visualizzazione. Mescolare questi due porta a situazioni in cui lo schermo sembra corretto ma il valore interno è sbagliato, causando bug in seguito.

Il punto chiave: DecimalFormat e String.format sono solo per la visualizzazione. Se hai bisogno di troncare il valore reale, usa BigDecimal o Math.floor().

6.1 Formattare le cifre decimali con DecimalFormat (troncamento possibile)

DecimalFormat è una classe per convertire numeri in stringhe formattate. Per esempio, è spesso usata quando vuoi visualizzare due cifre decimali.

import java.text.DecimalFormat;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
System.out.println(df.format(x)); // May become 1.24 (rounded)

Ciò che è importante è che il valore di ritorno di format() è una Stringa, e il valore numerico di x stesso non cambia.

Puoi anche specificare la modalità di arrotondamento. Per troncare la visualizzazione, fai quanto segue:

import java.text.DecimalFormat;
import java.math.RoundingMode;

double x = 1.239;

java DecimalFormat df = new DecimalFormat(“0.00”); df.setRoundingMode(RoundingMode.DOWN);

System.out.println(df.format(x)); // 1.23

However, this only changes the displayed string; the value of x remains unchanged.

6.2 Caveats When Using String.format

String.format also lets you control numeric output formatting.

java double x = 1.239; System.out.println(String.format(“%.2f”, x)); // Spesso arrotonda a 1.24

In many cases, String.format("%.2f", x) performs round half up behavior.
It’s usually unsuitable if you specifically want truncation.

A very common beginner mistake is converting a formatted string back into a number and using it in calculations.

java double x = 1.239; String s = String.format(“%.2f”, x); // “1.24” double y = Double.parseDouble(s); // 1.24

// A questo punto, i calcoli usano un valore arrotondato, non troncato

This mixes display concerns into calculation logic, making future changes harder.

6.3 Key Pitfall: Correct Display Does Not Mean Correct Values

The most dangerous assumption is “it looks correct on the screen, so it must be fine.”

• DecimalFormat / String.format change how values look
• Math.floor / BigDecimal.setScale change the actual value

If you confuse these, you may run into problems like:

• The UI shows “$1.23” but internal calculations still sum “$1.239”
• Rounding happens at the wrong stage, causing billing totals to differ
• Display rounding leaks into calculations, causing audit discrepancies

A simple rule of thumb:

• Only formatting for display → DecimalFormat (or UI formatting)
• Truncating as part of calculation → BigDecimal / Math.floor

In the next section, we’ll provide a quick reference table so you can instantly choose the right approach by use case.

7. Best Practices by Use Case (Quick Reference)

“Java decimal truncation” is confusing because there are multiple valid approaches.
Here, we fix the decision by mapping use case → best solution, so you can choose quickly.

7.1 Convert to int (Positive Numbers Only) → Casting Is Enough

If you just want to remove decimals and convert to int, and negative numbers will never appear, casting is the fastest option.

java double x = 12.99; int y = (int) x; System.out.println(y); // 12

Things to remember:

• Casting rounds toward zero
• With positive values, it looks the same as truncation
• If negatives may appear, don’t lock in this approach

7.2 Truncate Including Negative Numbers → Math.floor

If you want mathematical truncation (floor), Math.floor() is the correct choice.
It’s safer than casting when negative numbers may occur.

java double x = -3.9; int y = (int) Math.floor(x); System.out.println(y); // -4

Common notes:

• Math.floor() returns a double
• Cast to int or long if needed
• Watch out for int overflow with large values

7.3 Truncate at the n-th Decimal Place (Strict) → BigDecimal + setScale

If you want to truncate at a specific decimal place without precision errors, BigDecimal is the safest option.

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

BigDecimal x = new BigDecimal(“1.239”); BigDecimal y = x.setScale(2, RoundingMode.DOWN);

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

This approach is ideal for:

• Money (JPY, USD, etc.)
• Billing and tax calculations
• Rate calculations where errors are unacceptable
• Batch jobs requiring deterministic results

Common pitfalls:

• Do not create BigDecimal from double (avoid new BigDecimal(0.1) )
• Understand the difference between DOWN and FLOOR (negative numbers)

7.4 Format for Display Only → DecimalFormat (Never for Calculation)

If you only want to format numbers for display (e.g., two decimals), DecimalFormat is convenient.
However, it does not change the underlying numeric value, so never use it for calculations.

import java.text.DecimalFormat;
import java.math.RoundingMode;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.DOWN);

System.out.println(df.format(x)); // "1.23"

Note:

• Il valore di ritorno è una String
• Mescolare la logica di visualizzazione nei calcoli causa bug

In una frase, il punto chiave è:

• Veloce e semplice → Casting
• Corretto con i negativi → Math.floor
• Precisione prima (mondo reale) → BigDecimal
• Solo visualizzazione → DecimalFormat

Successivamente, riassumeremo gli errori più comuni e come evitarli.

8. Errori comuni e avvisi chiave

Il troncamento decimale spesso “sembra funzionare”, rendendo facile per i principianti non notare bug sottili.
Ecco errori del mondo reale e come evitarli.

8.1 Fraintendimento del significato di “Troncamento” (verso 0 vs Floor)

L’errore più comune è presumere che troncamento significhi sempre “andare più piccolo”.
In Java, il significato dipende dal metodo.

• Casting (int) : verso zero

  • 3.9 → 3
  • -3.9 → -3

  • Math.floor() : verso −∞

  • 3.9 → 3

  • -3.9 → -4

Se i valori negativi sono possibili e si usa il casting, solo il lato negativo sarà errato.
Questo spesso passa inosservato se i test usano solo valori positivi.

Contromisure:

• Se possono comparire valori negativi, considerare Math.floor() fin dall’inizio
• Con BigDecimal, non confondere RoundingMode.DOWN e FLOOR

8.2 Risultati inattesi dovuti alla precisione double

Quando si implementa il troncamento con Math.floor(x * 100) / 100, si possono vedere discrepanze anche se la logica sembra corretta.
La causa è la rappresentazione interna del double.

double x = 1.29;
double y = Math.floor(x * 100) / 100;
System.out.println(y);

Secondo il valore, x * 100 può diventare 128.999999999..., risultando in 1.28.
Poiché ciò non accade ogni volta, spesso viene scoperto in produzione.

Contromisure:

• Usa BigDecimal per denaro e fatturazione
• Se si usa double, limitare l’uso a casi in cui piccoli errori sono accettabili

8.3 Uso di double per calcoli monetari

Usare double per il denaro spesso porta a:

• Totali non corrispondenti dopo il troncamento
• Accumulo di piccoli errori di arrotondamento
• Discrepanza tra valori visualizzati e interni

Contromisure:

• Usa BigDecimal per valori monetari
• Correggi il metodo di creazione (String o valueOf )
• Documenta esplicitamente le regole di arrotondamento

8.4 Uso della formattazione di visualizzazione per i calcoli

Formattare con DecimalFormat o String.format e poi riconvertire in numeri è pericoloso.

double x = 1.239;
String s = String.format("%.2f", x); // display formatting
double y = Double.parseDouble(s);    // used in calculation (dangerous)

Ciò causa:

• Arrotondamento di visualizzazione che trapela nei calcoli
• Cambiamenti di specifica che influenzano la logica
• Perdita di separazione tra visualizzazione e calcolo

Contromisure:

• Completa i calcoli con BigDecimal o Math.floor()
• Formatta solo nell’ultima fase di visualizzazione
• Mantieni separati calcolo e presentazione

9. Riepilogo: Conclusioni da copiare-incollare

Ci sono diversi modi per troncare i decimali in Java, ma il percorso più veloce è scegliere in base al caso d’uso.
Ecco conclusioni pronte all’uso.

9.1 Se non sei sicuro, usa questi

Caso 1: Convertire in int (solo numeri positivi)

double x = 12.99;
int y = (int) x;  // 12

Nota: Con numeri negativi, -3.9 → -3, quindi non è floor matematico.

Caso 2: Troncamento matematico includendo i negativi

double x = -3.9;
int y = (int) Math.floor(x); // -4

Nota: Math.floor() tronca verso −∞.

Caso 3: Troncamento a n cifre decimali (double, semplice)

*Usa solo quando piccoli errori di precisione sono accettabili.

double x = 1.239;
double y = Math.floor(x * 100) / 100; // 1.23

Avviso: potrebbero verificarsi problemi di precisione del double. Per precisione rigorosa, usa BigDecimal.

Caso 4: Troncamento affidabile a n cifre decimali (Consigliato)

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

BigDecimal x = new BigDecimal("1.239");
BigDecimal y = x.setScale(2, RoundingMode.DOWN); // 1.23

Punti chiave:

• Non creare BigDecimal da un double
• Usa questo per denaro, fatturazione e tariffe

Caso 5: Solo visualizzazione (Mai per il calcolo)

import java.text.DecimalFormat;
import java.math.RoundingMode;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.DOWN);

System.out.println(df.format(x)); // "1.23"

Punto: Questo produce una String; il valore numerico rimane invariato.

FAQ

Q1. Qual è il modo più semplice per troncare i decimali in Java?

Risposta: Se ti serve solo un intero, il cast con (int) è il più veloce. Se possono comparire numeri negativi, considera Math.floor().

Q2. Perché (int) restituisce risultati inattesi per i numeri negativi?

Risposta: Il cast arrotonda verso zero. Per esempio, -3.9 → -3. Per un troncamento matematico, usa Math.floor().

Q3. Come tronco a due cifre decimali (es. 1.239 → 1.23)?

Risposta: Per un approccio semplice, usa Math.floor(x * 100) / 100. Per precisione rigorosa, usa BigDecimal.setScale(2, RoundingMode.DOWN).

Q4. Perché Math.floor(x * 100) / 100 a volte produce valori errati?

Risposta: È dovuto agli errori di precisione del double. Per denaro o fatturazione, passa a BigDecimal.

Q5. Qual è il modo corretto di troncare usando BigDecimal?

Risposta: Crea BigDecimal da una String o con valueOf, poi usa setScale(n, RoundingMode.DOWN). Evita new BigDecimal(double).

Q6. Qual è la differenza tra RoundingMode.DOWN e FLOOR?

Risposta: Differiscono per i numeri negativi. DOWN tronca verso zero; FLOOR tronca verso −∞. Scegli in base a se vuoi troncare o applicare il floor matematico.

Q7. Posso troncare i decimali con DecimalFormat?

Risposta: Puoi troncare la visualizzazione impostando una modalità di arrotondamento, ma è solo per la visualizzazione. Il valore interno non cambia.

Q8. Quando dovrebbe essere applicato il troncamento nei calcoli?

Risposta: Dipende dalle specifiche. Decidi se troncare ad ogni passaggio o solo alla fine, documenta la regola chiaramente e implementala in modo coerente—preferibilmente con BigDecimal.