1. Introduction
When working with date and time data in Java applications, it’s often crucial to compare dates for various purposes, such as scheduling tasks, reminders, or reporting. One common scenario is the need to identify whether a given date corresponds to yesterday relative to the current date. In this tutorial, we’ll explore various approaches for determining whether a given date object falls on yesterday.
2. Using java.util.Calendar
One common approach is to use the java.util.Calendar classes to manipulate date and time information. To compare yesterday’s date, we instantiate a Calendar object via Calendar.getInstance(). Next, we set its time to the current date using calendar.setTime(new Date()), and then subtract one day using calendar.add(Calendar.DATE, -1). This yields yesterday’s date.
Here’s a code snippet demonstrating these concepts:
Date date = new Date(System.currentTimeMillis() - (1000 * 60 * 60 * 24));
Calendar expectedCalendar = Calendar.getInstance();
expectedCalendar.setTime(date);
Calendar actualCalendar = Calendar.getInstance();
actualCalendar.add(Calendar.DATE, -1);
boolean isEqualToYesterday = expectedCalendar.get(Calendar.YEAR) == actualCalendar.get(Calendar.YEAR) &&
expectedCalendar.get(Calendar.MONTH) == actualCalendar.get(Calendar.MONTH) &&
expectedCalendar.get(Calendar.DAY_OF_MONTH) == actualCalendar.get(Calendar.DAY_OF_MONTH);
assertTrue(isEqualToYesterday);
Directly comparing dates using this method may fail due to differences in milliseconds between the two dates. This is because the Date object captures both the date and time, including milliseconds. If the time component is not precisely the same, the comparison may yield incorrect results.
To mitigate this issue, one approach is to truncate the time component of both dates before performing the comparison. We extract the year, month, and day components from both the dates using their respective get(Calendar.YEAR), get(Calendar.MONTH), and get(Calendar.DAY_OF_MONTH) methods to solely determine whether the actualCalendar is equal to yesterday.
Although these classes are considered legacy APIs, they are still widely used, especially in environments where newer Java versions are not available.
3. Using java.util.Date Milliseconds
This approach leverages the fact that Date objects internally store milliseconds since the epoch (January 1, 1970, 00:00:00 UTC). It involves calculating yesterday’s midnight in milliseconds and comparing it with the getTime() value of the Date object.
To begin, we calculate the timestamp in milliseconds representing the start of yesterday (midnight) in the system’s default time zone using the ZonedDateTime. This can be achieved by deducting one day from the current date and time, then truncating it to midnight, ultimately retrieving the timestamp.
Subsequently, we compare this calculated value with the getTime() value of the given expectedDate. By verifying if expectedDate falls within the range from yesterday’s midnight timestamp to the next midnight (yesterdayMidnightMillis + 86_400_000 milliseconds), we ascertain whether yesterdayMidnightMillis corresponds to yesterday’s date.
Let’s demonstrate this approach with a quick example:
Date expectedDate = new Date(System.currentTimeMillis() - (1000 * 60 * 60 * 24));
ZonedDateTime yesterdayMidnight = ZonedDateTime.now().minusDays(1).truncatedTo(ChronoUnit.DAYS);
long yesterdayMidnightMillis = yesterdayMidnight.toInstant().toEpochMilli();
boolean isEqualToYesterday = expectedDate.getTime() >= yesterdayMidnightMillis && expectedDate.getTime() < yesterdayMidnightMillis + 86_400_000;
assertTrue(isEqualToYesterday);
This approach offers a simple and efficient method for comparing dates using milliseconds. It’s suitable for scenarios where direct comparison with legacy Date objects is required.
4. Using java.time.LocalDate
Another approach to handling date manipulation is to use the LocalDate class along with its minusDays() method. This approach is part of the modern Date and Time API introduced in Java 8.
LocalDate offers a more straightforward and intuitive way to work with dates. It is designed to focus solely on the year, month, and day components, without a time component. This makes it ideal for date-only operations, such as recording historical dates or report date filtering.
To compare yesterday’s date using this method, we start by obtaining the current date using LocalDate.now(). Then, we simply call the minusDays(1) method on the LocalDate object to subtract one day, resulting in yesterday’s date:
Date date = new Date(System.currentTimeMillis() - (1000 * 60 * 60 * 24));
LocalDate expectedLocalDate = LocalDate.of(date.getYear() + 1900, date.getMonth() + 1, date.getDate());
LocalDate actualLocalDate = LocalDate.now().minusDays(1);
boolean isEqualToYesterday = expectedLocalDate.equals(actualLocalDate);
assertTrue(isEqualToYesterday);
In this example, we specify yesterday’s date by extracting the year, month, and day components from a Date object. However, note that the getYear() method returns the year since 1900, and getMonth() returns the month index starting from 0. Therefore, we add 1900 to getYear() and 1 to getMonth() to adjust them to the standard date representation.
Using LocalDate for date manipulation is recommended for Java versions 8 and above.
5. Using Joda-Time
Joda-Time is a popular date and time library for Java. We can use this library to check if a date object represents yesterday’s date. To compare yesterday’s date using Joda-Time, we utilize the DateTime class and its minusDays() method.
First, we obtain the current date and time using DateTime.now(). Then, we subtract one day from the current date by calling the minusDays(1) method, resulting in yesterday’s date:
Date date = new Date(System.currentTimeMillis() - (1000 * 60 * 60 * 24));
DateTime expectedDateTime = new DateTime(date).withTimeAtStartOfDay();
DateTime actualDateTime = DateTime.now().minusDays(1).withTimeAtStartOfDay();
boolean isEqualToYesterday = expectedDateTime.equals(actualDateTime);
assertTrue(isEqualToYesterday);
Similar to the Calendar class, Joda-Time’s DateTime class captures time along with the date, and thus, comparing them directly may lead to inaccuracies due to differences in milliseconds.
To resolve this, instead of breaking down the date value into year, month, and day components, we can leverage the withTimeAtStartOfDay() method provided by Joda-Time. This method sets the time component of a DateTime object to the start of the day, effectively resetting the time to midnight (00:00:00). By applying withTimeAtStartOfDay() to a DateTime object, we ensure that only the date component remains significant for comparison purposes.
6. Conclusion
In this article, we’ve explored a few approaches to determine whether a date object falls on yesterday’s date. For most modern Java applications using Java 8 or later, the LocalDate approach is generally recommended due to its clarity, immutability, and support for various date manipulations.
While Joda-Time is a mature and stable library, its future development and support may become less certain over time as more projects transition to the standard Java Date and Time API.
As always, the source code for the examples is available over on GitHub.