计算两个日期间隔天数结果异常，寻求技术解决方案

Hey Sven! Let's get your date day-count sorted out. The issue almost certainly lies in the implementation of your stringToDate and daysBetween methods—since you haven't shared those, I'll walk you through the correct, reliable way to calculate this using modern Java APIs (Java 8+), plus point out common pitfalls to avoid.

First, Let's Confirm the Expected Result #

For your example:

• Start date: 2018-03-25
• End date: 2018-04-05

Using ChronoUnit.DAYS.between(start, end) will give you 11 days (this counts the number of full days between the start and end, where March 25 to March 26 is 1 day, up to April 5). If you want the inclusive count (including both start and end), that would be 12, but your note says 10 or 11 is acceptable—11 is the standard "days between" result here.

Correct Implementation with Java 8+ LocalDate #

The old java.util.Date class is error-prone (especially with time zones and time-of-day components), so switching to java.time.LocalDate (part of the java.time API) is the best approach. Here's a complete working example:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

public class DateCalculator {
    public static void main(String[] args) {
        String startDateStr = "2018-03-25";
        String endDateStr = "2018-04-05";
        
        // Convert strings to LocalDate
        LocalDate startDate = stringToLocalDate(startDateStr);
        LocalDate endDate = stringToLocalDate(endDateStr);
        
        // Calculate days between
        long daysBetween = ChronoUnit.DAYS.between(startDate, endDate);
        
        System.out.println(daysBetween); // Outputs 11
    }
    
    private static LocalDate stringToLocalDate(String dateStr) {
        // Use DateTimeFormatter for safe parsing (matches your "yyyy-MM-dd" format)
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        return LocalDate.parse(dateStr, formatter);
    }
}

Common Pitfalls with Old Date Class #

If you have to use the old java.util.Date API (not recommended), here's what might be going wrong:

• Time zone issues: If your stringToDate method uses SimpleDateFormat without setting a time zone, it might use your system's default zone, which could shift the date by a day (e.g., if the time zone is UTC-5, a "2018-03-25" string might parse to March 24 19:00 UTC).
• Time-of-day interference: Date includes a time component. If one date is parsed to midnight and the other to a later time, subtracting milliseconds and dividing by 1000*60*60*24 could give an incorrect count (e.g., if end date is 2018-04-05 00:00:00 and start is 2018-03-25 01:00:00, the millisecond difference would be 993600000, which divides to 11.5—casting to long would give 11, but if you use integer division, it might truncate to 10).
• Incorrect millisecond calculation: If your daysBetween method uses (end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24), this can fail during daylight saving time transitions (where a day might be 23 or 25 hours long).

Fix for Old Date API (If You Must Use It) #

If you can't switch to java.time, here's a safer implementation:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;

public class OldDateCalculator {
    public static void main(String[] args) throws ParseException {
        String startDate = "2018-03-25";
        String endDate = "2018-04-05";
        
        Date start = stringToDate(startDate);
        Date end = stringToDate(endDate);
        
        long daysBetween = daysBetween(start, end);
        System.out.println(daysBetween); // Outputs 11
    }
    
    public static Date stringToDate(String dateStr) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        sdf.setTimeZone(TimeZone.getTimeZone("UTC")); // Set UTC to avoid time zone shifts
        return sdf.parse(dateStr);
    }
    
    public static long daysBetween(Date start, Date end) {
        // Convert dates to midnight UTC to eliminate time component
        long startMillis = start.getTime() / (1000 * 60 * 60 * 24) * (1000 * 60 * 60 * 24);
        long endMillis = end.getTime() / (1000 * 60 * 60 * 24) * (1000 * 60 * 60 * 24);
        
        return (endMillis - startMillis) / (1000 * 60 * 60 * 24);
    }
}

The key here is normalizing both dates to midnight UTC, so the time component doesn't mess up the calculation.

内容的提问来源于stack exchange，提问作者Sven