How to Find Difference Between Two Dates in Java: Methods Compared

To find the difference between two dates in Java, you can use java.time.LocalDate with ChronoUnit.DAYS.between() for modern code or java.util.Date with time calculations for legacy code. The java.time API is recommended for clearer and more accurate date differences.

Quick Comparison

This table compares key aspects of using java.util.Date and java.time.LocalDate to find date differences in Java.

Aspect	java.util.Date	java.time.LocalDate
Introduced in	Java 1.0 (legacy)	Java 8 (modern)
API Type	Mutable, less intuitive	Immutable, clear and fluent
Precision	Milliseconds	Days, months, years easily
Ease of Use	Manual time math needed	Built-in methods like ChronoUnit
Time Zone Handling	Requires extra care	Better support with ZoneId
Recommended	Legacy code only	Preferred for new code

Key Differences

The java.util.Date class is an older API that represents a specific instant in time, measured in milliseconds since the epoch. To find the difference between two dates, you typically subtract their millisecond values and convert the result to days manually. This approach can be error-prone and less readable.

In contrast, java.time.LocalDate is part of the modern Java Date and Time API introduced in Java 8. It represents a date without time and timezone, making it ideal for calculating differences in days, months, or years. The API provides built-in methods like ChronoUnit.DAYS.between() that directly return the difference, improving code clarity and reducing bugs.

Overall, java.time offers immutable objects and better design, making it the preferred choice for date calculations in modern Java applications.

Code Comparison

Here is how to find the difference between two dates using the legacy java.util.Date approach.

java

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class DateDifferenceLegacy {
    public static void main(String[] args) {
        Date date1 = new Date(122, 0, 1); // Jan 1, 2022 (year since 1900)
        Date date2 = new Date(122, 0, 10); // Jan 10, 2022

        long diffInMillies = date2.getTime() - date1.getTime();
        long diffInDays = TimeUnit.DAYS.convert(diffInMillies, TimeUnit.MILLISECONDS);

        System.out.println("Difference in days: " + diffInDays);
    }
}

Output

Difference in days: 9

java.time.LocalDate Equivalent

This example shows the modern way to find the difference between two dates using java.time.LocalDate and ChronoUnit.DAYS.between().

java

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class DateDifferenceModern {
    public static void main(String[] args) {
        LocalDate date1 = LocalDate.of(2022, 1, 1);
        LocalDate date2 = LocalDate.of(2022, 1, 10);

        long diffInDays = ChronoUnit.DAYS.between(date1, date2);

        System.out.println("Difference in days: " + diffInDays);
    }
}

Output

Difference in days: 9

When to Use Which

Choose java.time.LocalDate when working on new projects or when you need clear, readable, and reliable date calculations without time components. It handles date differences cleanly and supports various units like days, months, and years.

Use java.util.Date only when maintaining legacy code that already depends on it, or when you must interact with APIs that require it. However, consider converting to the modern API for better long-term maintainability.

Key Takeaways

Use java.time.LocalDate and ChronoUnit for clear and accurate date differences in modern Java.

java.util.Date requires manual millisecond math and is less intuitive for date differences.

java.time API is immutable and designed for better date/time handling.

Prefer java.time for new code; use java.util.Date only for legacy compatibility.

ChronoUnit.DAYS.between() directly returns the difference in days between two LocalDate objects.