double

The double keyword in Java designates a double-precision, 64-bit IEEE 754 floating-point primitive data type. It is the default type for decimal literals in Java and provides a larger range and higher precision than the 32-bit float type.

Technical Specifications

• Memory Size: 64 bits (8 bytes)
  • Sign bit: 1 bit
  • Exponent: 11 bits
  • Mantissa (Significand): 52 bits (provides 53 bits of precision due to an implicit leading bit)
• Default Value: 0.0d (for instance fields, static fields, and array elements)
• Precision: Approximately 15 to 17 significant decimal digits
• Minimum Non-Zero Value: 2^(-1074) (accessible via Double.MIN_VALUE)
• Maximum Value: (2 - 2^(-52)) · 2^1023 (accessible via Double.MAX_VALUE)

Syntax and Initialization

Because decimal literals are treated as double by default in Java, the d or D suffix is optional but can be used for explicit typing. double also supports scientific notation using e or E.

// Implicit double literal
double standardValue = 123.456;

// Explicit double literal using the 'd' or 'D' suffix
double explicitValue = 123.456d;

// Scientific notation (evaluates to 12000.0)
double scientificValue = 1.2E4; 

// Hexadecimal floating-point literal (evaluates to 15.0)
double hexValue = 0x1.ep3; 

Precision Limits and Rounding Errors

Because double represents values as base-2 fractions, it cannot exactly represent all base-10 fractions. This fundamental limitation of IEEE 754 floating-point arithmetic results in rounding errors during calculations.

double a = 0.1;
double b = 0.2;
double sum = a + b; // Evaluates to 0.30000000000000004, not exactly 0.3

Due to these precision limits, double must never be used for exact calculations, such as financial or currency computations. For exact decimal arithmetic, java.math.BigDecimal is the required alternative.

Comparing Double Values

Because of the aforementioned rounding errors, using the equality operator (==) to compare computed double values is a well-known anti-pattern. Comparisons of computed values should instead use an epsilon (a maximum acceptable tolerance).

The Double.compare() method performs an exact comparison without a tolerance, making it unsuitable for mitigating rounding errors. However, it is required for sorting and correctly handling special IEEE 754 values like NaN and -0.0.

double expected = 0.3;
double actual = 0.1 + 0.2;

// Anti-pattern: Direct equality check (evaluates to false)
boolean isExact = (actual == expected); 

// Correct approach for computed values: Epsilon (tolerance) comparison
double EPSILON = 1e-9;
boolean isClose = Math.abs(actual - expected) < EPSILON; // Evaluates to true

// Double.compare() performs exact comparison (evaluates to 1, meaning not equal)
// It is used for sorting and handling special values (NaN, -0.0), not for tolerance.
int comparison = Double.compare(actual, expected);

IEEE 754 Special Values

The double type implements standard IEEE 754 special values to handle arithmetic exceptions without throwing runtime errors. These are mapped to constants in the java.lang.Double wrapper class.

// Double.POSITIVE_INFINITY
double positiveInfinity = 1.0 / 0.0;  

// Double.NEGATIVE_INFINITY
double negativeInfinity = -1.0 / 0.0; 

// Double.NaN (Not a Number)
double notANumber = 0.0 / 0.0;        

Type Conversion

double is the widest primitive numeric type in Java. Conversions to double from other numeric primitives happen implicitly. However, while converting from long to double is an implicit widening conversion, it can result in a loss of precision. A double only has a 53-bit mantissa, meaning it cannot exactly represent all 64-bit long values.

// Widening conversion from int (exact)
int intValue = 100000;
double widenedInt = intValue; // 100000.0

// Widening conversion from long (demonstrating loss of precision)
long largeLong = 1234567890123456789L;
double widenedLong = largeLong;          // Precision is lost in the lower bits
long convertedBack = (long) widenedLong; // Evaluates to 1234567890123456768L

// Narrowing conversion (explicit cast required)
double preciseValue = 99.999;
int narrowed = (int) preciseValue; // 99 (fractional data is truncated)

The Wrapper Class

The object equivalent of the double primitive is java.lang.Double. It is used for autoboxing, generics, and provides utility methods for parsing and bit-level manipulation.

// Autoboxing primitive to Wrapper
Double wrappedDouble = 42.5;

// Parsing from a String
double parsed = Double.parseDouble("3.14159");

// Bit-level representation
long bits = Double.doubleToLongBits(12.5);

Master Java with Deep Grasping Methodology!

Learn More