In Java, the float and double primitive types are used to represent floating-point numbers. Both types are used for storing numeric values with a fractional part. The main difference between the two lies in the precision and range of values they can store.
The float type is a single-precision floating-point number, while the double type is a double-precision floating-point number. Here are the key characteristics of each type:
Table2.5.1.Floating-point types, range, and memory requirements.
type
type suffix
min
max
memory
precision
float
F or f
\(~±1.4\cdot10^{-45}\)
\(~±3.4\cdot10^{38}\)
4 bytes
6-7 digits
double
D or d
\(~±4.9\cdot10^{-324}\)
\(~±1.8\cdot10^{308}\)
8 bytes
15-16 digits
Due to their larger size and higher precision, double is the preferred choice when working with floating-point numbers in Java. Use doubles unless there are specific memory or performance constraints that necessitate the use of float. double is the default floating-point number type; if you write down a floating-point number literal with no special literal type suffix character, the type of that floating-point value is double. The literal 3.14 is a double. You may add a D or d to the end of a floating-point literal to be explicit, like 3.14D, but this is not required. Adding an F or f to the end of a floating-point literal, like 3.14F, tells Java that you want the number of be of type float.
Both float and double types support standard arithmetic and mathematical operations, such as addition, subtraction, multiplication, and division. Java provides built-in mathematical functions in the Math class that can be used with float and double values.
When performing calculations involving floating-point numbers, it is important to be aware of the limitations of floating-point representation. Floating-point numbers are stored as approximations, and certain calculations can introduce rounding errors. Therefore, comparing floating-point numbers for equality is not recommended. Instead, it is recommended practice to compare the absolute value of the difference between two floating-point values to be sufficiently small.
Here’s an example in JShell showcasing the usage of float and double types.
jshell> float myFloat = 3.14F;
myFloat ==> 3.14
| created variable myFloat : float
jshell> double myDouble = 3.14;
myDouble ==> 3.14
| created variable myDouble : double
jshell> float result = myFloat * 2;
result ==> 6.28
| created variable result : float
jshell> double otherResult = myDouble / 2;
otherResult ==> 1.57
| created variable otherResult : double
jshell>
In summary, the float and double primitive types in Java are used for storing floating-point numbers. The choice between them depends on the desired precision and range of values. double provides higher precision and is the default choice, while float is used in situations where memory or performance constraints exist.
Activity2.5.1.
Declare variables of type float and double, and initialize them to starting values. Write expressions using these variables that perform addition (+), subtraction (-), multiplication (*), and division (/).
jshell> float x = 1.23F;
x ==> 1.23
| created variable x : float
jshell> double y = 3.45;
y ==> 3.45
| created variable y : double
jshell> x + y * x / y;
$3 ==> 2.4600000381469727
| created scratch variable $3 : double
Activity2.5.2.
Declare variables named A and B of type double and initialize to 0.1 and 0.2, respectively. Use these variables to compute the value 0.3.
jshell> double A = 0.1;
A ==> 0.1
| created variable A : double
jshell> double B = 0.2;
B ==> 0.2
| created variable B : double
jshell> // Add to compute a value of 0.3
jshell> A + B;
$3 ==> 0.30000000000000004
| created scratch variable $3 : double
jshell> // Wait. What?
