Java实现支持任意日期格式的两日期间隔计算方法需求

Great question! Handling arbitrary date formats can be tricky, but using Java's modern java.time API (introduced in Java 8) makes this manageable. Here's a step-by-step solution that parses common date formats and calculates the interval between two dates:

First, we'll use a list of pre-defined date formatters to attempt parsing input strings (covering most real-world use cases). Then we'll leverage Period to compute the year/month/day difference between parsed dates, with handling for negative intervals (when the first date is later than the second).

Step 1: Full Implementation Code #

import java.time.LocalDate;
import java.time.Period;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;

public class DateIntervalCalculator {
    // List of common date formats - add more based on your needs
    private static final List<DateTimeFormatter> DATE_FORMATTERS = Arrays.asList(
        DateTimeFormatter.ofPattern("dd/M/yyyy"),
        DateTimeFormatter.ofPattern("MM/dd/yyyy"),
        DateTimeFormatter.ofPattern("yyyy-MM-dd"),
        DateTimeFormatter.ofPattern("dd-MM-yyyy"),
        DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH), // e.g., "March 15, 2023"
        DateTimeFormatter.ofPattern("dd MMM yyyy", Locale.ENGLISH),   // e.g., "15 Mar 2023"
        DateTimeFormatter.ISO_LOCAL_DATE // Standard ISO format
    );

    // Helper method to parse date strings with any of our formatters
    private static LocalDate parseDate(String dateStr) throws DateTimeParseException {
        String trimmedDate = dateStr.trim(); // Clean up accidental whitespace
        
        for (DateTimeFormatter formatter : DATE_FORMATTERS) {
            try {
                return LocalDate.parse(trimmedDate, formatter);
            } catch (DateTimeParseException e) {
                // Ignore and try the next formatter
            }
        }
        
        // Throw error if no format matches
        throw new DateTimeParseException("Could not parse date: " + trimmedDate, trimmedDate, 0);
    }

    // Main method to calculate interval between two date strings
    public static String calculateDateInterval(String date1Str, String date2Str) {
        try {
            LocalDate date1 = parseDate(date1Str);
            LocalDate date2 = parseDate(date2Str);
            
            Period period = Period.between(date1, date2);
            
            // Handle negative intervals (date1 is later than date2)
            String sign = period.isNegative() ? "-" : "";
            Period absolutePeriod = period.abs();
            
            return String.format("%s%d years, %d months, %d days",
                sign,
                absolutePeriod.getYears(),
                absolutePeriod.getMonths(),
                absolutePeriod.getDays()
            );
        } catch (DateTimeParseException e) {
            return "Error: " + e.getMessage();
        }
    }

    // Test the calculator
    public static void main(String[] args) {
        // Example test cases
        System.out.println(calculateDateInterval("15/03/2020", "05-06-2023"));
        // Output: 3 years, 2 months, 21 days
        
        System.out.println(calculateDateInterval("December 25, 2022", "25 Dec 2023"));
        // Output: 1 years, 0 months, 0 days
        
        System.out.println(calculateDateInterval("2023-01-01", "01/01/2022"));
        // Output: -1 years, 0 months, 0 days
        
        // Invalid date test
        System.out.println(calculateDateInterval("invalid-date", "2023-01-01"));
        // Output: Error: Could not parse date: invalid-date
    }
}

Key Notes & Customizations #

• Extend Format Support: Add more DateTimeFormatter entries to handle region-specific formats (e.g., DateTimeFormatter.ofPattern("yyyy年MM月dd日", Locale.CHINESE) for Chinese dates).
• Handle Time Components: If your input includes time (e.g., "15/03/2020 14:30"), switch to LocalDateTime and add time-aware formats like DateTimeFormatter.ofPattern("dd/M/yyyy HH:mm").
• Exact Day Count: For total days between dates (ignoring years/months), use ChronoUnit.DAYS.between(date1, date2) instead of Period.
• Ambiguous Formats: For formats like "01/02/2023" (could be Jan 2 or Feb 1), place more commonly used formats at the top of the DATE_FORMATTERS list to prioritize them.

内容的提问来源于stack exchange，提问作者Christina Isac Anil