如何在Java中获取日期的日期模式

Question

public void parsedate(String date) {
    DateTimeFormatter formatter = null;

    formatter = new DateTimeFormatterBuilder()
            .appendOptional(DateTimeFormatter.ofPattern("yyyyMMdd"))
            .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd"))
            .appendOptional(DateTimeFormatter.ofPattern("MM/dd/yyyy")).toFormatter();
    TemporalAccessor parse = formatter.parse(date);
    System.out.println("original" + date);
    
    return LocalDateTime.parse(date, formatter);
}

    String[] strDates = new String[]{
            "20180429",
            "2018-04-29",
            "04/29/2018",
            "01/20/1999",
            "1899-12-25",
            "2020-02-29", // leap year future
            "00010101",
            "19160229" // leap year past
    };

    for(String date: strDates) {
        parsedate(date);
    }

我正在使用多种日期模式解析日期。我会将日期字符串传递给 parsedate 方法。我的日期字符串被解析。但我想得到被解析的日期的模式。

例子：

输入日期：“2018-04-29” 处理：parsedate("2018-04-29") 输出：日期解析成功

我的期望是输入日期为“yyyy-MM-dd”的模式：“2018-04-29”。如何获得？

Answer 1

我想我同意 Andreas 在评论中的观点：尝试一下日期字符串来确定其格式非常简单。

public static String getPattern(String dateString) {
    if (dateString.length() == 8) { // compact format
        return "uuuuMMdd";
    } else if (dateString.charAt(2) == '/') {
        return "MM/dd/uuuu";
    } else {
        return "uuuu-MM-dd";
    }
}

使用您问题中的示例字符串尝试一下：

    String[] strDates = new String[]{
            "20180429",
            "2018-04-29",
            "04/29/2018",
            "01/20/1999",
            "1899-12-25",
            "2020-02-29", // leap year this year
            "00010101",
            "19160229" // leap year past
    };

    for(String date: strDates) {
        String pattern = getPattern(date);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        LocalDate parsedDate = LocalDate.parse(date, formatter);
        System.out.format("%-10s pattern: %-10s parsed: %s%n", date, pattern, parsedDate);
    }

输出是：

20180429   pattern: uuuuMMdd   parsed: 2018-04-29
2018-04-29 pattern: uuuu-MM-dd parsed: 2018-04-29
04/29/2018 pattern: MM/dd/uuuu parsed: 2018-04-29
01/20/1999 pattern: MM/dd/uuuu parsed: 1999-01-20
1899-12-25 pattern: uuuu-MM-dd parsed: 1899-12-25
2020-02-29 pattern: uuuu-MM-dd parsed: 2020-02-29
00010101   pattern: uuuuMMdd   parsed: 0001-01-01
19160229   pattern: uuuuMMdd   parsed: 1916-02-29

如果您更喜欢动态、自动化和可扩展的解决方案：

private static final String[] formatPatterns = { "uuuuMMdd", "uuuu-MM-dd", "MM/dd/uuuu" };

public static String getPattern(String dateString) {
    for (String pattern : formatPatterns) {
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
            LocalDate.parse(dateString, formatter);
            // If we ended up here, using the pattern was successful
            return pattern;
        } catch (DateTimeParseException dtpe) {
            // Do nothing, try next pattern
        }
    }
    throw new IllegalArgumentException("We don’t know the format pattern string for " + dateString);
}

Answer 2

查看文档后，似乎无法查看哪种可选格式成功。因此，简单的出路是构建一组格式化程序来尝试，并按顺序使用它们，直到成功为止。但是，这很难看：您正在使用流控制异常

LocalDateTime time = null;
DateTimeFormatter goodFormatter = null;
for (DateTimeFormatter formatter : formats) {
    try {
        time = LocalDateTime.parse(date, formatter);
        goodFormatter = formatter;
        break;
    } catch (DateTimeParseException dtpe) {
        // not really exceptional - bad coding practice
    }
}
// if goodFormatter != null, there you have it

existing question on SO 处理这个问题。我建议的答案类似于one of its answers。

一个更简洁的选择可能是使用您的格式作为正则表达式（仅检查可能的候选）和实际日期格式（仅解析好的候选）。这是以可读性为代价的，并且在解析模棱两可的格式时仍然会抛出异常，因为格式到正则表达式的代码非常简单：

enum FormatCandidate {
    YMD("yyyyMMdd"),
    YMD_DASHED("yyyy-MM-dd"),
    MDY_SLASHED("MM/dd/yyyy");

    private final Pattern pattern;
    public final DateTimeFormatter formatter;  // immutable & thread safe

    FormatCandidate(String format) {
        // THIS ONLY WORKS FOR SIMPLE EXAMPLES; modify for more complex ones!
        this.pattern = Pattern.compile(format
              .replaceAll("[-/]", "\\\0")  // preserved characters
              .replaceAll("[yMd]","\\d")   // digits
        ));
        this.formatter = new DateTimeFormatterBuilder()
              .appendPattern(format).toFormatter();
    }

    // this should really be available in the DateTimeFormatter class
    public boolean canParse(String date) {
        return pattern.matcher(date).matches();
    }
}

初始代码现在可以写成：

DateTimeFormatter goodFormatter = null;
for (FormatCandidate candidate : FormatCandidate.values()) {
    if (candidate.canParse(date)) {
       goodFormatter = candidate.format;
       break;
    }
}

LocalDateTime time = null;   
try {
    time = LocalDateTime.(date, candidate.formatter);
} catch (DateTimeParseException dtpe) {
    // now we can complain, saying that date does not match this particular
    // expected output
}

在进一步复杂化之前，我可能会使用丑陋的异常作为控制流（第一个代码 sn-p）作为重新实现时间解析库的较小弊端。

免责声明：以上代码未经测试，可能无法按预期编译和/或执行