If you’re working with Spring, check out "REST With Spring":

>> CHECK OUT THE COURSE

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 it is using Calendar instance, running a loop and adding 1 day in each iteration using add method and Calendar.Date field unit it reaches the end date.

Here is the code demonstrating it – using Calendar instance:

public static List<Date> getDatesBetweenUsingJava7(
  Date startDate, Date endDate) {
    List<Date> datesInRange = new ArrayList<>();
    Calendar calendar = new GregorianCalendar();
    calendar.setTime(startDate);
    
    Calendar endCalendar = new GregorianCalendar();
    endCalendar.setTime(endDate);

    while (calendar.before(endCalendar)) {
        Date result = calendar.getTime();
        datesInRange.add(result);
        calendar.add(Calendar.DATE, 1);
    }
    return datesInRange;
}

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.

The new Certification Class of "REST With Spring" is finally out:

>> CHECK OUT THE COURSE