如何以兼容未来的方式在Java中获取区域特定日期/时间模式

问题背景 #

Java中获取区域特定的日期格式模式一直没有完美的原生支持：

• JDK8+引入的DateTime API（java.time包）没有暴露内部格式模式的直接访问方式；
• 传统的SimpleDateFormat方案依赖强转实现类，属于特定实现依赖，稳定性不足且不符合未来兼容趋势。

需求场景是在UI中展示日期输入提示（比如Locale.US显示start date (M/d/yy)，Locale.GERMANY显示Startdatum (dd.MM.yy)），需要兼容Java 8和11，也可接受升级最低版本。

兼容多版本的解决方案 #

1. Java 16+ 最优解：原生API直接获取 #

Java 16为DateTimeFormatter新增了toPattern()方法，直接返回格式化模式字符串，完全基于标准API，无实现依赖：

import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Locale;

public class DatePatternUtil {
    public static String getDatePattern(FormatStyle style, Locale locale) {
        DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDate(style)
                                                      .withLocale(locale);
        return formatter.toPattern();
    }

    public static void main(String[] args) {
        // 输出 M/d/yy
        System.out.println(getDatePattern(FormatStyle.SHORT, Locale.US));
        // 输出 dd.MM.yy
        System.out.println(getDatePattern(FormatStyle.SHORT, Locale.GERMANY));
    }
}

2. Java 8-11 兼容方案：通过格式化测试日期推导模式 #

利用DateTimeFormatter格式化已知结构的测试日期，将结果中的日期数值替换为对应的模式符号，间接推导模式：

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Locale;

public class DatePatternUtil {
    public static String getDatePattern(FormatStyle style, Locale locale) {
        DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDate(style)
                                                      .withLocale(locale);
        // 使用年4位、月1位、日2位的测试日期，便于识别模式
        LocalDate testDate = LocalDate.of(2023, 1, 2);
        String formatted = formatter.format(testDate);

        // 替换测试日期部分为模式符号
        formatted = formatted.replace("2023", "yyyy")
                            .replace("23", "yy")
                            .replace("01", "MM")
                            .replace("1", "M")
                            .replace("02", "dd")
                            .replace("2", "d");
        
        // 去重处理避免重复替换导致的错误
        return cleanPattern(formatted);
    }

    private static String cleanPattern(String pattern) {
        pattern = pattern.replaceAll("yyyy+", "yyyy");
        pattern = pattern.replaceAll("yy+", "yy");
        pattern = pattern.replaceAll("MM+", "MM");
        pattern = pattern.replaceAll("M+", "M");
        pattern = pattern.replaceAll("dd+", "dd");
        pattern = pattern.replaceAll("d+", "d");
        return pattern;
    }

    public static void main(String[] args) {
        // 输出 M/d/yy
        System.out.println(getDatePattern(FormatStyle.SHORT, Locale.US));
        // 输出 dd.MM.yy
        System.out.println(getDatePattern(FormatStyle.SHORT, Locale.GERMANY));
        // 输出 dd MMM yyyy
        System.out.println(getDatePattern(FormatStyle.MEDIUM, Locale.FRANCE));
    }
}

该方案基于java.time标准API，兼容Java8+，无需依赖内部实现，大部分主流Locale场景都能正确推导模式。

3. Java 8-11 混合兼容方案：安全强转+推导 fallback #

如果想保留旧API的兼容性，同时避免强转风险，可以先尝试安全强转SimpleDateFormat，失败则 fallback到模式推导：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Locale;

public class DatePatternUtil {
    public static String getDatePattern(int dateStyle, Locale locale) {
        DateFormat dateFormat = DateFormat.getDateInstance(dateStyle, locale);
        // 安全强转，避免ClassCastException
        if (dateFormat instanceof SimpleDateFormat) {
            return ((SimpleDateFormat) dateFormat).toPattern();
        }
        // 强转失败时使用DateTimeFormatter推导模式
        return getPatternFromDateTimeFormatter(dateStyle, locale);
    }

    private static String getPatternFromDateTimeFormatter(int dateStyle, Locale locale) {
        FormatStyle formatStyle;
        switch (dateStyle) {
            case DateFormat.SHORT:
                formatStyle = FormatStyle.SHORT;
                break;
            case DateFormat.MEDIUM:
                formatStyle = FormatStyle.MEDIUM;
                break;
            case DateFormat.LONG:
                formatStyle = FormatStyle.LONG;
                break;
            case DateFormat.FULL:
                formatStyle = FormatStyle.FULL;
                break;
            default:
                throw new IllegalArgumentException("无效的日期格式风格");
        }
        return getDatePattern(formatStyle, locale);
    }

    // 复用之前的模式推导方法
    private static String getDatePattern(FormatStyle style, Locale locale) {
        DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDate(style)
                                                      .withLocale(locale);
        LocalDate testDate = LocalDate.of(2023, 1, 2);
        String formatted = formatter.format(testDate);

        formatted = formatted.replace("2023", "yyyy")
                            .replace("23", "yy")
                            .replace("01", "MM")
                            .replace("1", "M")
                            .replace("02", "dd")
                            .replace("2", "d");
        
        return cleanPattern(formatted);
    }

    private static String cleanPattern(String pattern) {
        pattern = pattern.replaceAll("yyyy+", "yyyy");
        pattern = pattern.replaceAll("yy+", "yy");
        pattern = pattern.replaceAll("MM+", "MM");
        pattern = pattern.replaceAll("M+", "M");
        pattern = pattern.replaceAll("dd+", "dd");
        pattern = pattern.replaceAll("d+", "d");
        return pattern;
    }

    public static void main(String[] args) {
        // 输出 M/d/yy
        System.out.println(getDatePattern(DateFormat.SHORT, Locale.US));
        // 输出 dd.MM.yy
        System.out.println(getDatePattern(DateFormat.SHORT, Locale.GERMANY));
    }
}

总结 #

• 若项目可以升级到Java16+，优先使用DateTimeFormatter.toPattern()，这是最稳定且符合未来趋势的方案；
• 兼容Java8-11时，推荐使用基于DateTimeFormatter的模式推导方案，避免依赖内部实现；
• 不建议维护自定义区域模式库，不仅维护成本高，还容易跟不上JDK对Locale数据的更新。

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