1. Overview
The new Time API introduced in Java 8 made it possible to process date and time without using external libraries.
In this short tutorial, we will take a look at how getting all dates between two dates become easier over the time in different versions of Java.
2. Using Java 7
In Java 7, one way to calculate this is using the Calendar instance.
First, we’ll get the start and end dates without time. Then, we’ll loop over these and add one day in each iteration using add method and Calendar.Date field, until it reaches the end date.
Here is the code demonstrating it – using Calendar instance:
public static List getDatesBetweenUsingJava7(Date startDate, Date endDate) {
List datesInRange = new ArrayList<>();
Calendar calendar = getCalendarWithoutTime(startDate);
Calendar endCalendar = getCalendarWithoutTime(endDate);
while (calendar.before(endCalendar)) {
Date result = calendar.getTime();
datesInRange.add(result);
calendar.add(Calendar.DATE, 1);
}
return datesInRange;
}
private static Calendar getCalendarWithoutTime(Date date) {
Calendar calendar = new GregorianCalendar();
calendar.setTime(date);
calendar.set(Calendar.HOUR, 0);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar;
}
3. Using Java 8
In Java 8, we can now create a continuous infinite Stream of dates and take only the relevant part. Unfortunately, there is no way of terminating an infinite Stream when a predicate gets matched – this is why we need to calculate the number of days between those two days and then simply limit() the Stream:
public static List<LocalDate> getDatesBetweenUsingJava8(
LocalDate startDate, LocalDate endDate) {
long numOfDaysBetween = ChronoUnit.DAYS.between(startDate, endDate);
return IntStream.iterate(0, i -> i + 1)
.limit(numOfDaysBetween)
.mapToObj(i -> startDate.plusDays(i))
.collect(Collectors.toList());
}
Notice how, first, we can get the difference of days between two dates using the between function – associated with DAYS constant of ChronoUnit enumeration.
Then we create a Stream of integers representing the number of days since the starting date. In the next step, we convert our integers to LocalDate objects using the plusDays() API.
Finally, we collect everything into a list instance.
4. Using Java 9
Finally, Java 9 brings dedicated methods for calculating this:
public static List<LocalDate> getDatesBetweenUsingJava9(
LocalDate startDate, LocalDate endDate) {
return startDate.datesUntil(endDate)
.collect(Collectors.toList());
}
We can get the dates between two dates with single method call using the dedicated datesUntil method of a LocalDate class. The datesUntill returns the sequentially ordered Stream of dates starting from the date object whose method is called to the date given as method argument.
5. Conclusion
In this quick article, we looked at how can we get all dates between two dates using the different versions of Java.
We discussed how Time API introduced in Java 8 release made it easier to run operations over date literals and in Java 9, it can be done by just calling datesUntil.
And, as always, the code snippets can be found over on GitHub.
