Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.
Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.
In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:
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.
