Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

double — números de coma flotante de doble precisión

double es el tipo primitivo de coma flotante de 64 bits IEEE 754 binary64 de Java. Aprende sus límites de precisión, en qué se diferencia de Double y las reglas de comparación, selección del máximo y cálculo del hash.

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

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 es la palabra clave del tipo primitivo IEEE 754 binary64: 64 bits y 53 bits de precisión de significando para los números normales. Incluye números finitos, +0.0, -0.0, infinitos y NaN. Muchas fracciones decimales no tienen una representación binaria exacta: 0.1 + 0.2 produce 0.30000000000000004. No des por sentada la exactitud decimal.

Double es la clase envoltorio de double. El boxing convierte un valor primitivo en su envoltorio, y el unboxing realiza la conversión inversa. Una variable Double puede contener null; al desempaquetar ese valor se lanza una NullPointerException. Un double primitivo no puede contener null.

Double.compare(a, b) devuelve un entero negativo, cero o un entero positivo según el orden de los argumentos. Coloca -0.0 antes de +0.0 y considera iguales todos los valores NaN, que quedan por encima del infinito positivo. En cambio, el operador primitivo == considera iguales los dos ceros, pero no considera que NaN sea igual ni siquiera a sí mismo.

Double.max(a, b) se comporta como Math.max: devuelve el valor mayor, devuelve NaN si alguno de los argumentos es NaN y devuelve +0.0 para ceros con signos opuestos. Double.hashCode(value) devuelve un hash de tipo int, compatible con el método de instancia Double.hashCode(): todas las representaciones de NaN comparten hash, mientras que los dos ceros tienen hashes distintos. Un hash no es un identificador único.

Ejemplos

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));
    }
}

Resultado

0.30000000000000004
true
true
true
0.0
NaN
0
-2147483648

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes