Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

double — numeri in virgola mobile a doppia precisione

double è il tipo primitivo a virgola mobile a 64 bit IEEE 754 binary64 di Java. Scopri i suoi limiti di precisione, le differenze rispetto a Double e le regole per confronti, massimo e hash.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

double value = 1.5;
Double boxed = value;
double unboxed = boxed;
int order = Double.compare(value, 2.0);
double maximum = Double.max(value, 2.0);
int hash = Double.hashCode(value);

double è la parola chiave del tipo primitivo IEEE 754 binary64: 64 bit, con 53 bit di precisione del significando per i numeri normali. Comprende numeri finiti, +0.0, -0.0, infiniti e NaN. Molte frazioni decimali non hanno una rappresentazione binaria esatta: 0.1 + 0.2 produce 0.30000000000000004. Non dare per scontata l’esattezza decimale.

Double è la classe wrapper di double. Il boxing converte un valore primitivo nel suo wrapper, mentre l’unboxing esegue la conversione inversa. Una variabile Double può contenere null; l’unboxing di quel valore genera una NullPointerException. Un double primitivo non può contenere null.

Double.compare(a, b) restituisce un intero negativo, zero o un intero positivo in base all’ordine degli argomenti. Ordina -0.0 prima di +0.0 e considera uguali tra loro tutti i valori NaN, collocandoli sopra l’infinito positivo. Al contrario, l’operatore primitivo == considera uguali i due zeri, ma non considera NaN uguale nemmeno a sé stesso.

Double.max(a, b) si comporta come Math.max: restituisce il valore maggiore, restituisce NaN se uno degli argomenti è NaN e restituisce +0.0 per zeri con segno opposto. Double.hashCode(value) restituisce un hash di tipo int, compatibile con il metodo di istanza Double.hashCode(): tutte le rappresentazioni di NaN hanno lo stesso hash, mentre i due zeri hanno hash diversi. Un hash non è un identificatore univoco.

Esempi

public class DoubleDemo {
    public static void main(String[] args) {
        double sum = 0.1 + 0.2;
        Double boxed = sum;
        System.out.println(boxed);
        System.out.println(-0.0 == 0.0);
        System.out.println(Double.compare(-0.0, 0.0) < 0);
        System.out.println(Double.compare(Double.NaN, Double.NaN) == 0);
        System.out.println(Double.max(-0.0, 0.0));
        System.out.println(Double.max(1.0, Double.NaN));
        System.out.println(Double.hashCode(0.0));
        System.out.println(Double.hashCode(-0.0));
    }
}

Risultato

0.30000000000000004
true
true
true
0.0
NaN
0
-2147483648

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti