java.time 无法解析秒的小数部分吗？

Question

随着 Mac OS X (Mavericks) 上 Java 8 (b132) 的第一个版本，此代码使用新的 java.time package 工作：

String input = "20111203123456"; 
DateTimeFormatter formatter = DateTimeFormatter.ofPattern( "yyyyMMddHHmmss");
LocalDateTime localDateTime = LocalDateTime.parse( input, formatter );

渲染：

2011-12-03T12:34:56

但是当我添加“SS”作为秒分数（和“55”作为输入）时，如<一href="https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html" rel="noreferrer">DateTimeFormatter 类文档，抛出异常：

java.time.format.DateTimeParseException: Text '2011120312345655' could not be parsed at index 0

该文档表示默认使用严格模式，并且需要与输入数字相同数量的格式字符。所以我很困惑为什么这段代码会失败：

String input = "2011120312345655"; 
DateTimeFormatter formatter = DateTimeFormatter.ofPattern( "yyyyMMddHHmmssSS");
LocalDateTime localDateTime = LocalDateTime.parse( input, formatter );

---

使用文档中的示例的另一个示例（“978”）（失败）：

String input = "20111203123456978"; 
DateTimeFormatter formatter = DateTimeFormatter.ofPattern( "yyyyMMddHHmmssSSS");
LocalDateTime localDateTime = LocalDateTime.parse( input, formatter );

---

此示例有效，添加小数点（但我在文档中发现没有这样的要求）：

String input = "20111203123456.978"; 
DateTimeFormatter formatter = DateTimeFormatter.ofPattern( "yyyyMMddHHmmss.SSS");
LocalDateTime localDateTime = LocalDateTime.parse( input, formatter );

渲染：

localDateTime: 2011-12-03T12:34:56.978

---

省略句点输入字符串或格式中的字符会导致失败。

失败：

String input = "20111203123456.978"; 
DateTimeFormatter formatter = DateTimeFormatter.ofPattern( "yyyyMMddHHmmssSSS");
LocalDateTime localDateTime = LocalDateTime.parse( input, formatter );

失败：

String input = "20111203123456978"; 
DateTimeFormatter formatter = DateTimeFormatter.ofPattern( "yyyyMMddHHmmss.SSS");
LocalDateTime localDateTime = LocalDateTime.parse( input, formatter );

Answer 1

Bug – 在 Java 9 中已修复

此问题已在 JDK-bug-log 中报告。 Stephen Colebourne 提到了以下解决方案作为解决方案：

DateTimeFormatter dtf = 
  new DateTimeFormatterBuilder()
  .appendPattern("yyyyMMddHHmmss")
  .appendValue(ChronoField.MILLI_OF_SECOND, 3)
  .toFormatter();

注意：此解决方案不涵盖仅两个模式符号 SS 的用例。调整可能只是使用其他字段，例如 MICRO_OF_SECOND（6 倍 SSSSSS）或 NANO_OF_SECOND（9 倍 SSSSSSSS）。对于两个小数位，请参阅下面我的更新。

@PeterLawrey关于模式符号“S”的含义请参见 this文档：

分数：将纳秒字段输出为秒分数。
纳秒值有九位数字，因此图案的计数
字母是从1到9。如果它小于9，那么纳秒
值被截断，仅保留最高有效数字
输出。在严格模式下解析时，解析的位数必须
匹配模式字母的数量。当在宽松模式下解析时，
解析的数字数量必须至少是模式字母的数量，
最多 9 位数字。

所以我们看到 S 代表秒的任何分数（包括纳秒），而不仅仅是毫秒。此外，不幸的是，小数部分目前在相邻值解析中表现不佳。

编辑：

作为背景，这里有一些关于相邻值解析的评论。只要字段由小数点或时间部分分隔符（冒号）之类的文字分隔，要解析的文本中的字段的解释并不困难，因为解析器然后很容易知道何时停止，即字段部分何时结束并且当下一个字段开始时。因此，如果指定小数点，JSR-310 解析器就可以处理文本序列。

但是，如果您有一系列跨越多个字段的相邻数字，那么就会出现一些实现困难。为了让解析器知道字段何时在文本中停止，有必要提前指示解析器给定字段由固定宽度的数字字符表示。这适用于所有采用数字表示的 appendValue(...) 方法。

不幸的是，JSR-310 也未能很好地处理小数部分 (appendFraction(...))。如果您在 DateTimeFormatterBuilder 类的 javadoc 中查找关键字“adjacent”，那么您会发现此功能只能通过 appendValue(...) 方法实现。请注意，模式字母 S 的规范略有不同，但内部委托给 appendFraction() 方法。我认为我们至少要等到 Java 9（如 JDK-bug-log 中所报告的，或更高版本？？？），直到小数部分也可以管理相邻值解析。

---

自 2015 年 11 月 25 日更新：

以下仅使用两个小数位的代码不起作用，并且会误解毫秒部分：

    DateTimeFormatter dtf =
        new DateTimeFormatterBuilder()
            .appendPattern("yyyyMMddHHmmss")
            .appendValue(ChronoField.MILLI_OF_SECOND, 2)
            .toFormatter();
    String input = "2011120312345655";
    LocalDateTime ldt = LocalDateTime.parse(input, dtf);
    System.out.println(ldt); // 2011-12-03T12:34:56.055

解决方法

String input = "2011120312345655"; 
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSS");
Date d = sdf.parse(input);
System.out.println(d.toInstant()); // 2011-12-03T12:34:56.055Z

不起作用，因为 SimpleDateFormat 将小数解释为也是一种错误的方式，类似于现代示例（参见输出，55 毫秒而不是 550 毫秒）。

剩下的解决方案要么等待很长一段时间直到 Java 9（或更高版本？），要么编写自己的 hack 或使用第 3 方库作为解决方案。

基于肮脏黑客的解决方案：

String input = "2011120312345655"; 
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
int len = input.length();
LocalDateTime ldt = LocalDateTime.parse(input.substring(0, len - 2),  dtf);
int millis = Integer.parseInt(input.substring(len - 2)) * 10;
ldt = ldt.plus(millis, ChronoUnit.MILLIS);
System.out.println(ldt); // 2011-12-03T12:34:56.550

使用 Joda-Time 的解决方案 a>：

String input = "2011120312345655"; 
DateTimeFormatter dtf = DateTimeFormat.forPattern("yyyyMMddHHmmssSS");
System.out.println(dtf.parseLocalDateTime(input)); // 2011-12-03T12:34:56.550

使用我的库的解决方案Time4J：

String input = "2011120312345655"; 
ChronoFormatter<PlainTimestamp> f = 
  ChronoFormatter.ofTimestampPattern("yyyyMMddHHmmssSS", PatternType.CLDR, Locale.ROOT);
System.out.println(f.parse(input)); // 2011-12-03T12:34:56.550

---

更新自2016-04-29：

正如人们通过上面提到的 JDK 问题所看到的，它现在被标记为已解决 - 对于 Java 9。

Answer 2

DateTimeFormatterBuilder#appendFraction(ChronoField.MILLI_OF_SECOND, 0, 3, true)

像这样的事情帮助了我

Answer 3

下面是一个算法，用于调整通常从格式化日期 String 返回的尾随零的顺序。

/**
 * Takes a Date and provides the format whilst compensating for the mistaken representation of sub-second values.
 * i.e. 2017-04-03-22:46:19.000991 -> 2017-04-03-22:46:19.991000
 * @param pDate Defines the Date object to format.
 * @param pPrecision Defines number of valid subsecond characters contained in the system's response.
 * */
private static final String subFormat(final Date pDate, final SimpleDateFormat pSimpleDateFormat, final int pPrecision) throws ParseException {
    // Format as usual.
    final String lString        = pSimpleDateFormat.format(pDate);
    // Count the number of characters.
    final String lPattern       = pSimpleDateFormat.toLocalizedPattern();
    // Find where the SubSeconds are.
    final int    lStart         = lPattern.indexOf('S');
    final int    lEnd           = lPattern.lastIndexOf('S');
    // Ensure they're in the expected format.
    for(int i = lStart; i <= lEnd; i++) { if(lPattern.charAt(i) != 'S') {
        // Throw an Exception; the date has been provided in the wrong format.
       throw new ParseException("Unable to process subseconds in the provided form. (" + lPattern + ").", i);
    } }
    // Calculate the number of Subseconds. (Account for zero indexing.)
    final int lNumSubSeconds = (lEnd - lStart) + 1;
    // Fetch the original quantity.
    String lReplaceString = lString.substring(lStart + (lNumSubSeconds - pPrecision), lStart + lNumSubSeconds);
    // Append trailing zeros.
    for(int i = 0; i < lNumSubSeconds - pPrecision; i++) { lReplaceString += "0"; }
    // Return the String.
    return lString.substring(0, lStart) + lReplaceString;
}