两个日期之间的小数月差（Scala 或 Java）

Question

I'm trying to find how many months are between 2 dates. My code is something like this right now

ChronoUnit.MONTHS.between(d1, d2)

The problem is that the result is a long. For example if the dates differ only in a few days I should get a result something like 0.34 instead of 0.

Also I need my code to account for the calendar, I cant assume each month has 31 days.

Diff between 1999-05-12 and 1999-08-24
Assuming all months have 31 days for simplicity

result = (19/31 + 31/31 + 31/31 + 24/31) = 2.793
According to the calendar we replace the 31s with the correct number of days for that specific year and month

Answer 1

Here is my solution:

public static double monthsBetween(LocalDate start, LocalDate end) {
    if (start.isAfter(end)) throw new IllegalArgumentException("Start must be before end!");

    var lastDayOfStartMonth = start.with(TemporalAdjusters.lastDayOfMonth());
    var firstDayOfEndMonth = end.with(TemporalAdjusters.firstDayOfMonth());
    var startMonthLength = (double)start.lengthOfMonth();
    var endMonthLength = (double)end.lengthOfMonth();
    if (lastDayOfStartMonth.isAfter(firstDayOfEndMonth)) { // same month
        return ChronoUnit.DAYS.between(start, end) / startMonthLength;
    }
    long months = ChronoUnit.MONTHS.between(lastDayOfStartMonth, firstDayOfEndMonth);
    double startFraction = ChronoUnit.DAYS.between(start, lastDayOfStartMonth.plusDays(1)) / startMonthLength;
    double endFraction = ChronoUnit.DAYS.between(firstDayOfEndMonth, end) / endMonthLength;
    return months + startFraction + endFraction;
}

The idea is that you find the last day of start 's month ( lastDayOfStartMonth ), and the first day of end 's month ( firstDayOfEndMonth ) using temporal adjusters. These two dates are very important. The number you want is the sum of:

• the fractional number of a month between start and lastDayOfStartMonth
• the whole number of months between lastDayOfStartMonth and firstDayOfEndMonth .
• the fractional number of a month between firstDayOfEndMonth and end .

Then there is the edge case of when both dates are within the same month, which is easy to handle.

By using this definition, the nice property that the number of months between the first day of any two months is always a whole number is maintained.

Note that in the first calculation, you have to add one day to lastDayOfStartMonth , because ChronoUnit.between treats the upper bound as exclusive, but we actually want to count it as one day here.

Answer 2

To approach this problem, you need to consider the following cases:

• dates belong to the same year and month;

• dates belong to different year and/or month;

• dates are invalid.

When dates belong to the same year and month, then the result would be the difference in days between the two dates divided by the number of days in this month, which can be found using LocalDate.lengthOfMonth() .

In the general case, the range of dates can be split into three parts:

• two fractional parts at the beginning and at the end of the given range of dates (both could be evaluated using the approach for the simplest case when both data belong to the same year/month )
• the whole part , we can use ChronoUnit.MONTHS.between() to calculate it.

Here's how implementation might look like ( d1 - inclusive, d2 - exclusive):

public static double getFractionalMonthDiff(LocalDate d1, LocalDate d2) {
    if (d1.isAfter(d2)) throw new IllegalArgumentException(); // or return a value like -1
    
    if (d1.getYear() == d2.getYear() && d1.getMonth() == d2.getMonth()) { // dates belong to same month and year
        
        return getFractionalPartOfMonth(d2.getDayOfMonth() - d1.getDayOfMonth(), d1.lengthOfMonth());
    }
    
    int monthLen1 = d1.lengthOfMonth();
    
    return getFractionalPartOfMonth(monthLen1 - (d1.getDayOfMonth() - 1), monthLen1) // from the given day of month of the First Date d1 Inclusive to the Last day of month
        + getFractionalPartOfMonth(d2.getDayOfMonth() - 1, d2.lengthOfMonth())       // from the First day of month to given day of month of the Second Date d2 Exclusive (for that reason 1 day was subtracted, and similarly on the previous line 1 day was added)
        + ChronoUnit.MONTHS.between(d1.withDayOfMonth(monthLen1), d2.withDayOfMonth(1));
}

public static double getFractionalPartOfMonth(int daysInterval, int monthLength) {
    return daysInterval / (double) monthLength;
}