Calculate Number of Weekdays Between Two Dates in Java

1. Overview

In this tutorial, we’ll look at two different methods in Java for calculating the number of weekdays between two dates. We’ll look at a readable version using Streams and a less readable but more efficient option that doesn’t loop at all.

2. Full Search Using Streams

First, let’s see how we can do this with Streams. The plan is to loop over every day between our two dates and count the weekdays:

long getWorkingDaysWithStream(LocalDate start, LocalDate end){
    return start.datesUntil(end)
      .map(LocalDate::getDayOfWeek)
      .filter(day -> !Arrays.asList(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY).contains(day))
      .count();
}

To start we’ve utilized LocalDate‘s datesUntil() method. This method returns a Stream of all the dates from the start (inclusive) to the end date (exclusive).

Next, we’ve used map() and LocalDate‘s getDayOfWeek() to transform each date into a day. For example, this would change 10-01-2023 to Wednesday.

Following that, we filter out all the weekend days by checking them against the DaysOfWeek enum. Finally, we can count up the days left, as we know these will all be weekdays.

This method isn’t the quickest, as we have to look at it every single day. However, it’s easily understandable and offers the opportunity to easily put in extra checks or processing if needed.

3. Efficient Search Without Looping

The other option we have is to not loop over all the days, but instead, apply the rules we know about the days of the week. There are several steps we need here, and a few edge cases to take care of.

3.1. Setting up Initial Dates

To start, we’ll define our method signature which will be a lot like our previous one:

long getWorkingDaysWithoutStream(LocalDate start, LocalDate end)

The first step in processing these dates is to exclude any weekends at the start and end. So for the start date, if it’s a weekend we’ll take the following Monday. We’ll also track the fact that we did this with a boolean:

boolean startOnWeekend = false;
if(start.getDayOfWeek().getValue() > 5){
    start = start.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
    startOnWeekend = true;
}

We’ve used the TemporalAdjusters class here, specifically its next() method which lets us jump to the next specified day.

We can then do the same for the end date – if it’s a weekend, we take the previous Friday. This time we’ll use TemporalAdjusters.previous() to take us to the first occurrence of the day we want before the given date:

boolean endOnWeekend = false;
if(end.getDayOfWeek().getValue() > 5){
    end = end.with(TemporalAdjusters.previous(DayOfWeek.FRIDAY));
    endOnWeekend = true;
}

3.2. Accounting for Edge Cases

This already presents us with a potential edge case, if we start on Saturday and end on Sunday. In that case, our start date will now be Monday, and the end date the Friday before. It doesn’t make sense for the start to be after the end, so we can cover this potential use case with a quick check:

if(start.isAfter(end)){
    return 0;
}

We also need to cover another edge case which is why we kept track of starting and ending on a weekend. This is optional and depends on how we want to count the days. For example, if we counted between a Tuesday and Friday in the same week we’d say there are three days between them.

We’d also say there are five weekdays between a Saturday and the following Saturday. However, if we move the start and end days to Monday and Friday as we’re doing here, that now counts as four days. So to counteract that we can simply add a day if required:

long addValue = startOnWeekend || endOnWeekend ? 1 : 0;

3.3. Final Calculations

We’re now in a position to calculate the total amount of weeks between the start and end. For this, we’ll use ChronoUnit’s between() method. This method calculates the time between two Temporal objects, in the specified unit which is WEEKS in our case:

long weeks = ChronoUnit.WEEKS.between(start, end);

Finally, we can use everything we’ve gathered so far to get our final value for the number of weekdays:

return ( weeks * 5 ) + ( end.getDayOfWeek().getValue() - start.getDayOfWeek().getValue() ) + addValue;

The steps here are firstly to multiply the number of weeks by the number of weekdays per week. We haven’t accounted for non-whole weeks yet so we add on the extra days between the start day of the week and the end day of the week. To finish we add the adjustment for starting or finishing on a weekend.

4. Conclusion

In this article, we’ve looked at two options for calculating the number of weekdays between two dates.

First, we saw how to use a Stream and check each day individually. This method offers simplicity and readability at the expense of efficiency.

The second option is to apply the rules we know about the days of the week to figure it out without a loop. This offers efficiency at the expense of readability and maintainability.

As always, the full code for the examples is available over on GitHub.