The double data type is used to store decimal or fractional numbers when greater precision is required. It is a 64-bit double-precision floating-point type and is the default choice for decimal literals in Java.
Compared with float, double provides significantly greater precision and is therefore the more common choice for general-purpose floating-point calculations.
What Is the double Data Type?
The double data type stores floating-point values using 64 bits and follows the IEEE 754 double-precision format.
double price = 99.99; double temperature = 36.75; double distance = 12345.6789;
Unlike float, a normal decimal literal does not require a suffix when assigned to a double.
Key Point: double is a 64-bit floating-point type that provides approximately 15 to 16 decimal digits of precision.
Why Is double Commonly Used?
Most everyday calculations involving decimal values need more precision than float provides. Java therefore makes double the default type for decimal literals.
double average = 87.625; double radius = 7.5; double speed = 72.45;
This makes double convenient for scientific calculations, measurements, mathematical operations, graphics, statistics, and many other applications.
Syntax of double
double variableName = value;
For example:
double salary = 45000.75; double percentage = 82.5; double weight = 68.45;
Size and Precision of double
| Property | Value |
|---|---|
| Data Type | double |
| Category | Floating-point |
| Size | 64 bits |
| Precision | Approximately 15 to 16 decimal digits |
| Default Value for a Field | 0.0d |
| Literal Suffix | d or D, usually optional |
double Literals
Decimal literals are treated as double by default.
double value = 25.75;
You can also explicitly use the d suffix:
double value = 25.75d;
Both forms are valid. In normal Java code, the suffix is usually omitted because double is already the default type for decimal literals.
Remember: A decimal literal such as 10.5 is a double by default.
double Arithmetic
Arithmetic operations involving double values produce floating-point results.
double a = 20.5; double b = 10.25; double sum = a + b; double difference = a - b; double product = a * b; double quotient = a / b;
The result can contain a fractional component, making double suitable for calculations involving measurements and decimal values.
double Division
When floating-point arithmetic is involved, division preserves the fractional portion.
double result = 10.0 / 3.0; System.out.println(result);
The result is approximately 3.3333333333333335. The exact displayed value reflects the fact that many decimal fractions cannot be represented perfectly in binary floating-point.
double and int Conversion
An int can be automatically converted to double because double has a much larger floating-point representation.
int number = 100; double value = number;
The reverse conversion requires an explicit cast.
double value = 25.75; int number = (int) value;
The resulting integer is 25. Casting removes the fractional portion; it does not perform normal rounding.
double vs float
| Feature | float | double |
|---|---|---|
| Size | 32 bits | 64 bits |
| Precision | Approximately 6 to 7 digits | Approximately 15 to 16 digits |
| Default Decimal Type | No | Yes |
| Suffix | f or F | d or D, optional |
| Typical Use | Memory-sensitive floating-point data | General-purpose decimal calculations |
Floating-Point Precision
A common misconception is that double stores every decimal value exactly. It does not. Like float, it uses binary floating-point representation, so some decimal values are represented only approximately.
double result = 0.1 + 0.2; System.out.println(result);
The result may appear as 0.30000000000000004 rather than exactly 0.3. This is a consequence of binary floating-point representation, not a failure of Java arithmetic.
Practical Insight: Do not assume that floating-point values are always exact. For exact decimal calculations such as financial amounts, use a decimal-oriented approach such as BigDecimal when appropriate.
Special double Values
The double type can represent special values such as positive infinity, negative infinity, and NaN.
double positiveInfinity = Double.POSITIVE_INFINITY; double negativeInfinity = Double.NEGATIVE_INFINITY; double notANumber = Double.NaN;
These values are useful when calculations can produce results outside ordinary finite floating-point values.
Common Uses of double
- Scientific and engineering calculations.
- Mathematical operations involving decimal values.
- Measurements and statistical calculations.
- Graphics and simulations.
- Applications requiring more precision than float.
- General-purpose floating-point calculations.
When Should You Use double?
For most general-purpose calculations involving decimal numbers, double is the practical default. It offers considerably more precision than float and does not require a suffix for ordinary decimal literals.
However, greater precision does not mean exact decimal arithmetic. If your application handles currency or other values where exact decimal representation is essential, choose an appropriate decimal arithmetic type instead of assuming double is exact.
Common Beginner Mistakes
- Assuming double stores every decimal number exactly.
- Using double for financial calculations without understanding floating-point precision.
- Assuming casting a double to int rounds the value.
- Confusing double precision with unlimited precision.
- Using float when the application actually requires greater precision.
Best Practices
- Prefer double for general-purpose floating-point calculations.
- Remember that floating-point arithmetic can contain small representation errors.
- Use an appropriate decimal arithmetic type for exact monetary calculations.
- Avoid unnecessary casts between floating-point and integer types.
- Choose float only when its lower precision and smaller size are actually useful.
Interview Insights
Question: What is the size of double in Java?
Answer: double is a 64-bit double-precision floating-point type.
Question: Is double more precise than float?
Answer: Yes. double provides approximately 15 to 16 decimal digits of precision, while float provides approximately 6 to 7.
Question: Why does 0.1 + 0.2 sometimes produce 0.30000000000000004?
Answer: Many decimal fractions cannot be represented exactly in binary floating-point, so the stored values are approximations.
double Data Type: Quick Revision
| Property | Details |
|---|---|
| Type | double |
| Category | Floating-point |
| Size | 64 bits |
| Precision | Approximately 15 to 16 decimal digits |
| Default Field Value | 0.0d |
| Decimal Literal Default | double |
| Literal Suffix | d or D, optional |
| Example | double price = 99.99; |
The double data type is Java's standard choice for general-purpose floating-point calculations. Its 64-bit representation provides much more precision than float, but it is still an approximation-based binary floating-point type. Once you understand that distinction, choosing between float, double, and exact decimal arithmetic becomes much easier.