Days between two DateTime values excluding weekends

So I wrote some code to handle this recently. It is completely configurable, and as efficient as can be.

The most important thing is to set the isWorkingDay array with the right flags (index 0 is Monday) and to make sure workingDaysInWeek matches the number of true flags in the array. After that the method will return a value for you.

//array of seven boolean indicating working days, Monday is index 0
private static final List<Boolean> isWorkingDay;
//count of the number of working days in the array
private static final Integer workingDaysInWeek;
static {
    //my real implementation uses the Salesforce BusinessHours Object to populate this array
    isWorkingDay = new List<Boolean> { true, true, true, true, true, false, false };
    //You will have real problems if this number does not match the number of true flags in the array
    workingDaysInWeek = 5;
}

private static final Date monday = Date.newInstance(1900, 1, 3);
private static Integer getDayOfWeek(Date value) {
    return Math.mod(monday.daysBetween(value), 7);
}

public static Integer getWorkingDays(Date startDate, Date endDate) {
    //save some calculations when the number of working days is 0
    if(workingDaysInWeek == 0 || startDate == null || endDate == null) {
        return 0;
    } else {
        Integer difference = startDate.daysBetween(endDate);
        if(difference == 0) {
            //If the 2 dates are the same day check if the day is a working day or not
            return isWorkingDay[getDayOfWeek(startDate)] ? 1 : 0;
        } else if(workingDaysInWeek == 7) {
            //when every day is a working day return the difference
            return difference;
        } else {
            //The guts of the solution
            Integer wholeWeeks = Math.floor(difference / 7).intValue();
            Integer workingDays = wholeWeeks * workingDaysInWeek;
            Integer dayOfWeek = getDayOfWeek(endDate);
            for(Integer remainder = Math.mod(difference, 7); remainder >= 0; remainder--) {
                if(isWorkingDay[dayOfWeek]) {
                    workingDays++;
                }
                dayOfWeek--;
                if(dayOfWeek < 0) {
                    dayOfWeek = 6;
                }
            }
            return workingDays;
        }
    }
}

Here is one possibile solution. It is a bit brute force as it examines every single day between the two inputs. So the further the dates are apart the more expensive it is to compute.

Also, it assumes that the startDate is less than the endDate to start with. So it won't return negative values like Date.daysBetween() can.

public static Integer daysBetweenExcludingWeekends(Datetime startDate, Datetime endDate) {
    Integer i = 0;

    while (startDate < endDate) {
        if (startDate.format('E') != 'Sat' && startDate.format('E') != 'Sun') {
            i++;
        }
        startDate = startDate.addDays(1);
    }

    return i;
}

---

Alternative attempt using daysBetween (not tested yet). Based on a C# example by Jon Egerton.

public static Integer daysBetweenExcludingWeekends(Datetime startDate, Datetime endDate) {
    //Work out days in range
    Integer days = startDate.date().daysBetween(endDate.date());

    //Remove most weekends by removing 2 in 7 days (rounded down)
    days -= ((integer)Math.floor((days / 7)) * 2);

    if (startDate.format('E') != 'Sat') {
        days -= 1;
    } else if (startDate.format('E') != 'Sun') {
        days -= 2;
    }

    return days;
}