### Get started with Spring and Spring Boot, through the Learn Spring course:

>> CHECK OUT THE COURSE

## 1. Overview

Double and float are data types that represent decimal numbers in Java. They both differ from each other when handling decimals.

In this tutorial, we’ll discuss double and float and learn how to convert them into each other.

## 2. What Is a Double and Float in Java

float is a 32-bit single-precision floating type and can store around 7 decimal digits. This data type has an advantage when there is a need to save memory. However, using float for currencies or high-precision data calculation is not advisable.

When declaring float variables for primitive datatypes, we could use the floatÂ keyword:

``float vatRate = 14.432511f;``

For wrapper classes, we should use the Float class:

``Float localTaxRate = 20.12434f;``

Since we are dealing with float, variables should have an “f” suffix at the end. Otherwise, the compiler will consider it as a double and will complain.

On the other hand, double is a 64-bit single-precision floating type. This data type can store more decimal digits than float at approximately 17 decimal places. It is a common choice for decimal calculations because of its greater accuracy. Like float, double is also not recommended for currency calculation.

Below is the illustration of how to declare a double by using the double keyword:

``double shootingAverage = 56.00000000000001;``

Another way to declare a double is through a Double wrapper class:

``Double assistAverage = 81.123000000045;``

When deciding which data type to use, between double and float, it is essential to consider the application’s technical needs and business requirements.

## 3. Conversions Between Double and Float

It is a common technical requirement to make conversions between Double and Float. However, we should be cautious in converting them as we may lose some decimal precision. Subsequently, this may lead to unexpected behavior in our application.

### 3.1. Converting Double to Float

Let’s demonstrate how to convert a variable through casting:

``````double interestRatesYearly = 13.333333333333333;
float interest = (float) interestRatesYearly;
System.out.println(interest); //13.333333
Assert.assertEquals(13.333333f, interest, 0.000001f);``````

Since we performed a casting from double to float, our new float value lost some decimal places compared to its original value.
To test this conversion with an assertEquals(), we’re using a delta parameter with a value of 0.000001 which is sufficient for the converted value of 13.333333.

Another way to make a conversion from double to float is through wrapper classes:

``````Double monthlyRates = 2.111111111111111;
float rates = monthlyRates.floatValue();
System.out.println(rates); //2.1111112
Assert.assertEquals(2.1111111f, rates, 0.0000001f);``````

In the above example, the monthlyRates object invoked a method called floatValue()Â that returned a float.
Similarly to our first conversion example, we use a value of 0.0000001 for our delta.

### 3.2. Converting Float to Double

Next, let’s show how to convert float to double data types:

``````float gradeAverage =2.05f;
double average = gradeAverage;
System.out.println(average); //2.049999952316284
Assert.assertEquals(2.05, average, 0.01);``````

We noticed that the conversion to double came out different than what we were expecting. The issue lies in the binary representation of the Floating-Point numbers.

A different way of converting float to double is by using the Double class via doubleValue() method:

``````Float monthlyRates = 2.1111111f;
Double rates = monthlyRates.doubleValue();
System.out.println(rates); //2.1111111640930176
Assert.assertEquals(2.11111111, rates, 0.0000001);``````

Like our previous tests from the previous section, we have used delta parameters in our assertEquals() for our unit tests for this section.

## 4. Conclusion

In this article, we’ve discussed float and double data types. Each data type has its characteristics and its own precision size. A double data type has more decimal places than a float. However, the float data type has its own advantage regarding memory usage, while double has its advantages in accuracy.

All code samples used in the article are available over on GitHub.

### Get started with Spring and Spring Boot, through the Learn Spring course:

>> CHECK OUT THE COURSE