Calculate days between two Dates in Java 8

Accurate calculations with LocalDate and ChronoUnit

Craft precise calculations and avoid silly time errors with the LocalDate and ChronoUnit duo from Java 8 Date API:

LocalDate for clean date handling

Create LocalDate instances using the of method, and you'll be able to manage dates without pesky time issues. It's the smart way to dodge time zones or daylight savings confusion:

// Define a date, no time twaddle here 🎩
LocalDate specificDate = LocalDate.of(2023, Month.JANUARY, 1);


ChronoUnit for calendar days

ChronoUnit.DAYS.between() paves the way to a string of beautiful calendar days, elegantly sidestepping complex time handling:

// Days between start and end, easier than stealing candy from a baby 👶
long daysBetween = ChronoUnit.DAYS.between(start, end);


This method offers a consistent count of days between two dates regardless of daylight savings.

Handling corner cases with Duration and Period

Some corner cases demand not just calendar days, but also precise duration or structured date ranges.

Duration for 24-hour periods

Duration should be your go-to when dealing with continuous 24-hour-based timespans:

import java.time.Duration;
import java.time.Instant;

// Duration is key 🔑 if you're living in Jack Bauer's "24" world
Duration duration = Duration.between(Instant.now(), Instant.now().plus(Duration.ofDays(1)));
long hours = duration.toHours(); // equivalent to your screen time on weekends 🎮


Remember, Duration can introduce time-based inaccuracies over daylight savings transitions.

Period for date range representation

LocalDate.until() without a unit is a gift when you need a structured range using years, months, and days:

// Period expresses the time between two 'birthday parties' 🥳
Period period = start.until(end);
System.out.printf("Period: %d years, %d months, and %d days\n", period.getYears(), period.getMonths(), period.getDays());


Date to LocalDate conversion

Legacy code often demands conversion from java.util.Date to LocalDate. No worries, Instant and ZoneId will help you soar:

import java.util.Date;
import java.time.ZoneId;

// Convert old Date to LocalDate, like a caterpillar to a butterfly 🦋
Date oldDate = new Date();
LocalDate convertedDate = oldDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();


Tip: Always use ZoneId.systemDefault() to respect local time zone shifts.

'Gotchas' and best practices

Time zones alert!

Be mindful of time zones when handling times. Always use ZonedDateTime for inter-timezone shenanigans.

DST and leap seconds

The pint-sized leap seconds and giant DST can alter time-related calculations. LocalDate abstracts these away, but with Duration, tread with caution!

Immutable objects for the win

LocalDate and its date-time peers in Java 8 are immutable AND thread-safe. Rejoice programmers, these objects hate unpredictable side-effects as much as you!

'Date' to 'LocalDate'

java.util.Date is as deprecated as my old Nokia phone 📞, but still seen in older Java codebases. Learning to pet the old dog to perform new tricks (aka converting Date to LocalDate) can save stress and maintenance hours.