Java double spiegato: intervallo, precisione, insidie comuni e alternative BigDecimal

1. Cos’è il tipo double di Java?

Il tipo double di Java è un tipo di dato fondamentale per lavorare con valori decimali. A differenza di int o long, che rappresentano numeri interi, double viene usato per rappresentare numeri con la virgola decimale come “1.5”, “3.14” o “0.01”. È uno dei tipi più frequentemente usati quando si eseguono calcoli numerici in Java.

Poiché i principianti spesso inciampano qui all’inizio, è importante prima comprendere che tipo di caratteristiche ha double.

1.1 double è “Floating-Point a doppia precisione”

double è un numero floating-point a doppia precisione che rappresenta i valori usando 64 bit (8 byte). Come suggerisce il termine “floating-point”, double gestisce internamente i valori numerici come approssimazioni.

Di conseguenza, ha le seguenti caratteristiche:

• Può gestire un intervallo di valori estremamente ampio
• Può eseguire calcoli che coinvolgono parti frazionarie
• Tuttavia, non può rappresentare esattamente ogni valore decimale

Il fatto che non possa rappresentare ogni decimale esattamente è spiegato in dettaglio più avanti, ma tenere a mente che double non è onnipotente rende il resto molto più facile da capire.

1.2 Un’immagine pratica di ciò che double può rappresentare

L’intervallo di valori che un double può rappresentare è estremamente ampio. In linea di massima, può gestire:

• Numeri molto piccoli (ad esempio 0.0000000001)
• Numeri molto grandi (dell’ordine di 10^300)
• Numeri decimali tipici della vita quotidiana

Ad esempio, tutti i seguenti valori possono essere memorizzati in un double:

double a = 3.14;
double b = 0.1;
double c = 123456789.987;

Per calcoli come l’elaborazione numerica quotidiana, le quantità fisiche, i dati statistici e i calcoli di coordinate—dove “approssimativamente corretto è sufficiente”—double è comunemente usato come scelta standard.

1.3 In Java, i letterali decimali sono per impostazione predefinita double

In Java, quando scrivi un letterale numerico con la virgola decimale, viene trattato come double per impostazione predefinita, a meno che non specifichi diversamente.

double x = 1.23;   // OK
float  y = 1.23;   // コンパイルエラー

Nell’esempio sopra, float y = 1.23; fallisce perché 1.23 è interpretato come un double. Se vuoi che sia trattato come un float, devi specificarlo esplicitamente così:

float y = 1.23f;

Questo comportamento dimostra che in Java, double è il valore predefinito per i calcoli decimali.

1.4 Situazioni comuni in cui si usa double

double è comunemente usato in situazioni come le seguenti:

• Quando vuoi un risultato di divisione come decimale
• Calcoli come medie e rapporti
• Rendering di grafici e calcoli di coordinate
• Calcolo scientifico e elaborazione statistica

D’altra parte, non è adatto per calcoli monetari o elaborazioni decimali rigorose. Questo sarà spiegato più dettagliatamente più avanti, nella parte su come scegliere tra double e BigDecimal.

1.5 Punti chiave da ricordare prima

Per riassumere ciò che hai imparato finora in modo adatto ai principianti:

• double è il tipo base per i numeri decimali
• Internamente, i calcoli usano valori approssimati
• In Java, i letterali decimali sono per impostazione predefinita double
• Devi fare attenzione quando la precisione è importante

2. Intervallo e precisione di double (Una guida alle cifre significative)

Quando si studia il tipo double, un argomento inevitabile è la questione di “quanto accuratamente può rappresentare i numeri?” In questa sezione imparerai l’intervallo numerico, la precisione e il concetto di cifre significative per double, in modo adatto ai principianti.

2.1 L’intervallo numerico che double può rappresentare

Poiché double utilizza 64 bit per rappresentare i valori, può gestire un intervallo di numeri estremamente ampio.

Concettualmente, l’intervallo appare così:

• Numeri molto piccoli: ad esempio fino a circa 4.9 × 10^-324
• Numeri molto grandi: ad esempio fino a circa 1.8 × 10^308

Nella programmazione quotidiana, raramente è necessario pensare a questi limiti.
Per la maggior parte degli scopi pratici, puoi considerarlo come la gestione di un intervallo quasi “quasi infinito”.

2.2 Le cifre significative sono approssimativamente 15‑17 cifre

Il concetto chiave per comprendere la precisione di double è cifre significative.

Si dice spesso che un double possa memorizzare circa 15‑17 cifre con precisione.

Ad esempio, considera i seguenti valori:

double a = 123456789012345.0;
double b = 1234567890123456.0;

• a (15 cifre) può essere rappresentato con precisione
• b (16+ cifre) può avere le cifre inferiori arrotondate

In altre parole, man mano che il numero di cifre aumenta, la precisione fine viene gradualmente persa.

2.3 “Alta precisione” non significa “decimali esatti”

Ecco un fraintendimento comune tra i principianti.

double ha alta precisione
→ quindi può gestire i decimali esattamente

Questo non è sempre corretto.

double è davvero un tipo ad alta precisione, ma ciò significa:
“può essere accurato come approssimazione fino a un certo numero di cifre”
piuttosto che “ogni valore decimale è esatto.”

Ad esempio, considera questo calcolo:

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

Molte persone si aspettano 0.3, ma in realtà potresti vedere qualcosa del genere:

0.30000000000000004

Questo non è un bug. È come funziona double.
Il motivo è che 0.1 e 0.2 non possono essere rappresentati esattamente in binario.

2.4 Perché le cifre significative sono importanti

Se non comprendi le cifre significative, potresti incontrare problemi come:

• Risultati leggermente imprecisi
• Confronti con == che non corrispondono
• Errori che si accumulano in somme o medie

Tutto ciò deriva dal fatto che double è un tipo che gestisce valori approssimativi.

D’altro canto, in ambiti dove “uguaglianza perfetta” conta meno della “precisione realistica”, come:

• Rendering di grafici
• Simulazioni fisiche
• Elaborazione statistica

double è una scelta eccellente.

2.5 Comprensione corretta basata su intervallo e precisione

Per riassumere:

• double può rappresentare un intervallo di valori estremamente ampio
• Ha circa 15‑17 cifre significative
• I decimali sono gestiti come approssimazioni
• Fai attenzione quando è richiesta una precisione rigorosa

3. Differenze tra double e float (Quale dovresti usare?)

Quando si lavora con i decimali in Java, double e float sono quasi sempre confrontati.
Entrambi possono rappresentare valori frazionari, ma ci sono differenze importanti in precisione, casi d’uso e praticità.

In questa sezione, ci concentriamo su criteri decisionali chiari affinché i principianti non rimangano bloccati.

3.1 Le differenze di base tra float e double

Manteniamo il confronto semplice:

Come puoi vedere, double offre una precisione notevolmente superiore.

3.2 Perché double è lo standard in Java

In Java, i letterali decimali (come 1.23) sono trattati come double per impostazione predefinita.
Questo è principalmente perché:

• Sui CPU moderni, il costo prestazionale di double è solitamente trascurabile
• I bug causati da precisione insufficiente tendono a essere più gravi
• double è migliore per leggibilità e sicurezza nel codice tipico

Pertanto, in Java, l’approccio comune è: usa double a meno che tu non abbia una forte ragione per non farlo.

3.3 Quando dovresti usare float

Allora float è inutile?
No—può essere efficace a seconda del contesto.

Situazioni tipiche in cui si sceglie float includono:

• Quando è necessario ridurre al minimo l’uso di memoria in modo estremo
• Quando si gestiscono enormi array numerici (ad esempio, elaborazione di immagini)
• Quando si privilegia la velocità rispetto alla precisione in giochi o calcoli 3D

Tuttavia, per applicazioni aziendali o web,
raramente c’è una forte ragione per usare float.

3.4 Una regola semplice per i principianti

Se non sei sicuro di quale usare, ricorda questa regola:

• In caso di dubbio, usa double
• Usa float solo quando i vincoli di memoria/prestazioni sono rigidi

Soprattutto durante l’apprendimento, è solitamente più efficiente evitare problemi di precisione specifici per float e costruire la comprensione con double.

3.5 Perché Comprendere Questa Differenza È Importante

Conoscere la differenza aiuta in situazioni come:

• Comprendere l’intento quando si legge il codice di qualcun altro
• Prevenire perdite di precisione non necessarie
• Evitare bug nei calcoli numerici prima che accadano

4. Utilizzo Base di double (Dichiarazione, Calcolo, Output)

Ora confermiamo l’utilizzo base di double con codice reale.
Se comprendi il flusso di “dichiarare → calcolare → output”, hai coperto i fondamentali.

4.1 Dichiarare e Assegnare un double

Dichiari un double nello stesso modo degli altri tipi primitivi:

double x = 1.5;
double y = 2.0;

Quando assegni valori decimali, non hai bisogno di alcun suffisso speciale.
Puoi anche assegnare un valore intero; verrà automaticamente convertito in double.

double a = 10;   // Treated as 10.0

4.2 Le Quattro Operazioni Arithmetiche Base

Con double, puoi utilizzare direttamente l’addizione, la sottrazione, la moltiplicazione e la divisione:

double a = 5.0;
double b = 2.0;

double sum = a + b;      // addition
double diff = a - b;     // subtraction
double product = a * b;  // multiplication
double quotient = a / b; // division

Tutti i risultati sono anche double, quindi puoi gestire naturalmente i risultati decimali.

4.3 Un’Avvertenza Chiave con la Divisione

Il punto chiave è che la divisione diventa un calcolo decimale solo se almeno un lato è un double.

double result1 = 1 / 2;    // result is 0.0
double result2 = 1 / 2.0;  // result is 0.5

1 / 2 utilizza interi su entrambi i lati, quindi esegue prima la divisione intera.
Per evitare questo, fai una delle seguenti cose:

• Rendi un operando un double
• Usa un cast esplicito

  double result = (double) 1 / 2;
  

4.4 Stampare i Risultati dei Calcoli

Puoi stampare un valore double direttamente usando System.out.println():

double value = 3.14159;
System.out.println(value);

Tuttavia, stamparlo così com’è potrebbe mostrare più cifre di quante ne vuoi.

4.5 Stampare con un Numero Fisso di Cifre

Se vuoi un output più pulito, printf è comodo:

double value = 3.14159;
System.out.printf("%.2f%n", value);

Questo stampa il valore con due cifre dopo il punto decimale.

• %.2f : 2 cifre dopo il punto decimale
• %n : nuova riga

Per le visualizzazioni rivolte all’utente, è consigliato controllare sempre il numero di cifre visualizzate.

4.6 Riassunto dei Fondamenti dei Calcoli con double

Punti chiave da questa sezione:

• double supporta i calcoli decimali in modo naturale
• Fai attenzione alla divisione tra interi
• Controlla le cifre visualizzate quando stampi i risultati

5. Trappola Comune #1: Perché Si Verificano Errori di Precisione

Una delle prime esperienze confuse quando si usa double è:
“il risultato non corrisponde a ciò che mi aspettavo.”

Non si tratta di un bug di Java. È una proprietà fondamentale del tipo double.

5.1 Un Esempio Classico di Errore di Precisione

Guardiamo un esempio ben noto:

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

Molte persone si aspettano 0.3, ma potresti vedere in realtà:

0.30000000000000004

Vedendo questo, potresti pensare “c’è qualcosa che non va” o “è un bug?”.
Ma questo è il risultato corretto per double.

5.2 Perché Si Verificano Questo Tipo di Errori

Il motivo è che double rappresenta i numeri usando il binario.

Gli umani usano la base-10, ma i computer internamente usano la base-2.
Il problema chiave è:

• Molti decimali in base-10 non possono essere rappresentati con un numero finito di cifre binarie
• Quindi il sistema memorizza la approssimazione più vicina

0.1 e 0.2 non terminano in binario, quindi vengono memorizzati come valori “molto vicini” ma non identici ai valori decimali esatti.

Sommando quelle approssimazioni si ottiene un risultato come 0.30000000000000004.

5.3 Assumi Sempre che Gli Errori Possano Accadere

La mentalità più importante è:

Con double, gli errori di precisione sono inevitabili

Gli errori diventano particolarmente evidenti in casi come:

• Ripetere addizioni/sottrazioni molte volte
• Calcoli che coinvolgono la divisione
• Quando hai bisogno di correttezza rigorosa fino a molte cifre decimali

In breve, double non è progettato per “decimali perfettamente esatti.”

5.4 Quando Gli Errori Di Solito Non Importano

D’altra parte, ci sono molti casi in cui gli errori di precisione sono raramente un problema pratico.

Ad esempio:

• Grafici e animazioni
• Valori dei sensori e dati statistici
• Calcoli scientifici
• Giochi e simulazioni

In queste aree, ciò che conta più dell’uguaglianza esatta è essere in grado di calcolare con una precisione realistica.

È lì che double eccelle.

5.5 Come Dovresti Gestire Gli Errori Di Precisione

Cercare di eliminare completamente gli errori spesso rompe il tuo design.
Invece, segui questi principi:

• Accetta che gli errori “possono accadere”
• Usa metodi di confronto/giudizio appropriati
• Usa approcci diversi quando gli errori non sono accettabili

6. Pitfall Comune #2: Usare “==” per Confrontare Valori double È Pericoloso

Dopo aver capito gli errori di precisione, il problema successivo che quasi tutti incontrano è:
“Perché il confronto non funziona come previsto?”

Un errore comune tra i principianti è confrontare valori double usando ==.

6.1 Cosa Succede Quando Usi “==”

Considera il seguente codice:

double a = 0.1 + 0.2;
double b = 0.3;

System.out.println(a == b);

Intuitivamente, potresti aspettarti true, ma il risultato può essere false.
Questo è causato dall’errore di precisione spiegato in precedenza.

• a è vicino a 0.30000000000000004
• b è un’approssimazione diversa che rappresenta 0.3

Poiché questi valori non sono identici a livello di bit, == li riporta come diversi.

6.2 La Regola D’Oro per Confrontare Valori double

C’è una regola fondamentale che dovresti sempre ricordare:

Non confrontare mai valori double per uguaglianza esatta

L’operatore == verifica se le rappresentazioni interne sono esattamente le stesse, non se i valori sono “abbastanza vicini.”

Questo lo rende inadatto per i numeri a virgola mobile.

6.3 Confrontare con un Epsilon (Tolleranza)

Quando confronti valori double, dovresti definire una soglia per
“quanto vicino è abbastanza vicino.”

Questa soglia è chiamata un epsilon (tolleranza).

double a = 0.1 + 0.2;
double b = 0.3;

double epsilon = 1e-9;

if (Math.abs(a - b) < epsilon) {
    System.out.println("Approximately equal");
}

Questo approccio verifica se:

• La differenza assoluta è sufficientemente piccola
• I valori possono essere considerati uguali per scopi pratici

6.4 Come Scegli Un Epsilon?

Una domanda comune tra i principianti è:
“Quanto grande dovrebbe essere epsilon?”

L’idea è semplice. Basalo su:

• La scala dei valori che stai gestendo
• La quantità di errore che puoi tollerare

Regole empiriche tipiche includono:

• 1e-9 : sicuro per molti calcoli generali
• 1e-12 : molto rigoroso
• 1e-6 : adatto per visualizzazioni o stime approssimative

Non c’è un singolo valore corretto.
Scegli in base al tuo caso d’uso.

6.5 Come Questo Differisce da BigDecimal

Guardando un po’ avanti, nota la differenza di filosofia:

• double : lavora tollerando piccoli errori
• BigDecimal : design che non permette errori

Se il confronto sembra “troppo complicato”, potrebbe essere un segno che double non è la scelta giusta per quell’attività.

6.6 Riassunto Delle Regole Di Confronto

• Non usare ==
• Confronta usando differenze assolute
• Scegli epsilon in base al contesto
• Usa altri tipi se è richiesta accuratezza rigorosa

7. Pitfall Comune #3: La Divisione Intera Produce Zero

Anche quando usi double, potresti vedere risultati che diventano inaspettatamente 0.
Questo è uno degli errori più comuni tra i principianti.

La causa è semplice: il calcolo è eseguito usando interi.

7.1 Perché Succede La Divisione Intera

In Java, i tipi degli operandi determinano come viene eseguita un’operazione.
Considera questo codice:

double result = 1 / 2;
System.out.println(result);

L’output è:

0.0

Poiché sia 1 che 2 sono int, Java esegue prima la divisione intera, producendo 0, che viene poi convertito in double.

7.2 Come eseguire correttamente la divisione decimale

Evitare la divisione intera è facile.
Rendi almeno un operando un double.

double result1 = 1 / 2.0;
double result2 = 1.0 / 2;
double result3 = (double) 1 / 2;

Tutti questi producono:

0.5

7.3 Un errore comune nella vita reale

Questo tipo di codice è spesso visto in applicazioni reali:

int total = 5;
int count = 2;

double average = total / count;

Anche se sembra corretto, il risultato è 2.0.
Il modo corretto per calcolare la media è:

double average = (double) total / count;

7.4 Regole che i principianti dovrebbero ricordare

• Prestare sempre attenzione ai tipi nella divisione
• Intero ÷ intero produce un intero
• Ricevere il risultato come double non è sufficiente

7.5 Riepilogo della trappola della divisione intera

• La causa sono i tipi degli operandi e l’ordine di valutazione
• Usa double fin dall’inizio del calcolo
• Fai particolare attenzione a medie e rapporti

8. Conversione tra Stringhe e double (Più comune nella pratica)

Nelle applicazioni reali, raramente si codificano direttamente valori double.
Molto più spesso, è necessario convertire stringhe (String) in numeri.

Esempi tipici includono:

• Valori di input dei moduli
• File CSV o JSON
• File di configurazione
• Risposte API

Questa sezione spiega modi sicuri per convertire tra String e double.

8.1 Convertire una Stringa in double

8.1.1 Double.parseDouble()

Il metodo più comune e di base:

String text = "3.14";
double value = Double.parseDouble(text);

Se la stringa è un numero valido, la conversione ha successo.

8.1.2 Gestione delle stringhe non valide

Se la stringa non è numerica, viene lanciata un’eccezione:

String text = "abc";
double value = Double.parseDouble(text); // throws exception

Questo lancia una NumberFormatException.
Nella pratica, usa sempre try-catch:

try {
    double value = Double.parseDouble(text);
} catch (NumberFormatException e) {
    // error handling
}

8.2 Differenza tra Double.valueOf()

Double.valueOf() è un altro metodo per convertire una stringa in un valore numerico.

Double value = Double.valueOf("3.14");

La differenza tra i due metodi è:

• parseDouble → restituisce un double primitivo
• valueOf → restituisce un oggetto wrapper Double

Per calcoli numerici normali, parseDouble è sufficiente.
Quando si lavora con collezioni come List<Double>, valueOf è comunemente usato.

8.3 Convertire double in String

Convertire un double in una stringa è anche molto comune.

double value = 3.14;
String text = String.valueOf(value);

Un’altra opzione ampiamente usata è:

String text = Double.toString(value);

Entrambi gli approcci sono sicuri. Scegli in base allo stile o alle convenzioni del progetto.

8.4 Formattare sempre le stringhe per la visualizzazione

Quando si mostrano numeri agli utenti,
usa sempre output formattato.

double value = 3.14159;
String text = String.format("%.2f", value);

Questo formatta il valore a due cifre decimali.

8.5 Punti chiave per la conversione di stringhe

• Aspettati sempre input non validi e gestisci le eccezioni
• Separa i calcoli interni dalla formattazione per la visualizzazione
• Controlla sempre le cifre decimali quando visualizzi i valori

La sezione successiva spiega i valori speciali di double: NaN e Infinity.
Senza comprenderli, il debug di problemi numerici diventa molto difficile.

9. Valori speciali nella classe Double (NaN / Infinity)

Il tipo double include valori speciali che non sono numeri ordinari.
Comprenderli è essenziale per programmi robusti.

9.1 Cos’è NaN (Not a Number)?

NaN rappresenta un risultato numerico indefinito.
Si verifica in calcoli come:

double value = 0.0 / 0.0;
System.out.println(value);

L’output è:

NaN

9.2 Cos’è Infinity?

Quando il risultato di una divisione trabocca, Java produce Infinity.

double value = 1.0 / 0.0;
System.out.println(value);

L’output è:

Infinity

Se il numeratore è negativo, il risultato è -Infinity.

9.3 Come verificare NaN e Infinity

Questi valori non possono essere controllati in modo affidabile usando ==.
Usa sempre i metodi dedicati:

double value = 0.0 / 0.0;

if (Double.isNaN(value)) {
    System.out.println("Value is NaN");
}

if (Double.isInfinite(value)) {
    System.out.println("Value is infinite");
}

9.4 Perché è importante rilevare in anticipo

Se NaN o Infinity si propagano nei calcoli, possono causare:

• Tutti i risultati successivi diventano NaN
• Valori non validi mostrati nell’interfaccia utente
• Logica dell’applicazione interrotta

Rileva i valori anomali il prima possibile.

10. Usa BigDecimal per denaro e calcoli esatti

Come mostrato finora, double è molto comodo,
ma non può evitare completamente gli errori di precisione.

Perciò non è adatto a:

• Calcoli monetari
• Gestione di punti o saldi
• Requisiti di arrotondamento rigorosi

10.1 Cos’è BigDecimal?

BigDecimal è una classe che gestisce numeri decimali esattamente in base 10.
È progettata per evitare la perdita di precisione.

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");

BigDecimal result = a.add(b);
System.out.println(result); // 0.3

10.2 Regola importante quando si usa BigDecimal

Creare un BigDecimal direttamente da un double trasporta gli errori di precisione.

new BigDecimal(0.1); // Not recommended

Crea sempre da una stringa invece:

new BigDecimal("0.1"); // Correct

10.3 Scegliere tra double e BigDecimal

• Prestazioni e semplicità → double
• Precisione sopra ogni cosa → BigDecimal

Non forzare tutto in un unico tipo.
Scegli in base allo scopo.

11. Riepilogo: Usare correttamente Java double

Riassumiamo i punti chiave di questo articolo:

• double è il tipo decimale fondamentale di Java
• Gli errori di precisione fanno parte della specifica
• Usa tolleranze per il confronto
• Attento alla divisione intera
• Usa BigDecimal per calcoli esatti

Una volta compreso come funziona double,
la programmazione numerica diventa molto meno intimidatoria.

12. Domande frequenti (FAQ)

Q1. Quante cifre sono accurate in un double Java?

Circa 15–17 cifre significative. I valori decimali sono gestiti come approssimazioni.

Q2. Devo usare double o float?

Nella maggior parte dei casi, usa double a meno che non ci sia un motivo forte per scegliere float.

Q3. È sbagliato usare double per il denaro?

Sì. Non è consigliato. Usa BigDecimal per calcoli monetari sicuri.

Q4. Posso usare “==” per confrontare valori double?

No. Usa una tolleranza (epsilon) invece.

Q5. Come devo gestire NaN e Infinity?

Usa Double.isNaN() e Double.isInfinite() per rilevarli in anticipo e gestirli esplicitamente.