副作用

Question

我需要创建格式化程序来解析带有可选毫秒，微秒或纳秒分数的时间戳。

例如，根据我的需要，我看到以下机会：

DateTimeFormatter formatter = new DateTimeFormatterBuilder()
                                   .append(DateTimeFormatter.BASIC_ISO_DATE)
                                   .appendLiteral('-')
                                   .append(DateTimeFormatter.ISO_LOCAL_TIME)
                                   .appendOffset("+HH:mm", "Z")
                                   .toFormatter();

或者也可以使用appendFraction(field, minWidth, maxWidth, decimalPoint)。

但是在这些情况下，可以使用任意数量的小数（最多9或maxWidth）来解析时间戳。如何实现我们可以在逗号后解析（可选）只有3个，6个或9个数字？

应该可以解析以下时间部分：

HH:mm:ss.SSS
HH:mm:ss.SSSSSS
HH:mm:ss.SSSSSSSSS

但无法解析：HH:mm:ss.SSSS。

Answer 1

您可以使用可选的部分模式（由[]分隔），并创建3个可选部分：1个用于9位数字，另一个用于6个数字，另一个用于3个数字。

根据DateTimeFormatterBuilder docs，您可以使用S模式（相当于NANO_OF_SECOND field）：

Pattern  Count  Equivalent builder methods
-------  -----  --------------------------
S..S     1..n   appendFraction(ChronoField.NANO_OF_SECOND, n, n, false)

在旧API（SimpleDateFormat），S is the pattern used for milliseconds中，但在新API中，它已更改为纳秒。

因此格式化程序将按如下方式创建：

DateTimeFormatter formatter = new DateTimeFormatterBuilder()
    // here is the same as your code
    .append(DateTimeFormatter.BASIC_ISO_DATE).appendLiteral('-')
    // time (hour/minute/seconds)
    .appendPattern("HH:mm:ss")
    // optional nanos, with 9, 6 or 3 digits
    .appendPattern("[.SSSSSSSSS][.SSSSSS][.SSS]")
    // offset
    .appendOffset("+HH:mm", "Z")
    // create formatter
    .toFormatter();

一些测试：

// 3 digits
System.out.println(OffsetDateTime.parse("20161201-10:30:45.123Z", formatter)); // 2016-12-01T10:30:45.123Z

// 6 digits
System.out.println(OffsetDateTime.parse("20161201-10:30:45.123456Z", formatter)); // 2016-12-01T10:30:45.123456Z

// 9 digits
System.out.println(OffsetDateTime.parse("20161201-10:30:45.123456789Z", formatter)); // 2016-12-01T10:30:45.123456789Z

// 4 digits (throws DateTimeParseException: Text '20161201-10:30:45.1234Z' could not be parsed at index 21)
System.out.println(OffsetDateTime.parse("20161201-10:30:45.1234Z", formatter));

输出结果为：

2016-12-01T10：30：45.123Z
  2016-12-01T10：30：45.123456Z
  2016-12-01T10：30：45.123456789Z
  线程“main”中的异常java.time.format.DateTimeParseException：无法在索引21处解析文本“20161201-10：30：45.1234Z”

备注：

此DateTimeFormatter的实例格式，因为它打印所有可选部分（因此纳秒将被打印3次）：

// don't use it to format, it prints all optional sections // (so nanos are printed 3 times: with 9, 6 and 3 digits) OffsetDateTime odt = OffsetDateTime.parse("20161201-10:30:45.123Z", formatter); System.out.println(formatter.format(odt)); // output is 20161201Z-10:30:45.123000000.123000.123Z

因此，如果您想以其他格式显示日期，请考虑创建另一个DateTimeFormatter。

在您的代码中，您使用了DateTimeFormatter.ISO_LOCAL_TIME。根据{{3}}，在此格式化程序中，秒是可选的。如果您想拥有相同的行为，只需将时间模式更改为：

// time (hour/minute) with optional seconds .appendPattern("HH:mm[:ss]")

[]模式是制作可选部分的一个很好的快捷方式，但您也可以使用optionalStart() appendFraction()创建它们：

DateTimeFormatter formatter = new DateTimeFormatterBuilder() // here is the same as your code .append(DateTimeFormatter.BASIC_ISO_DATE).appendLiteral('-') // time (hour/minute/seconds) .appendPattern("HH:mm:ss") // optional nanos with 9 digits (including decimal point) .optionalStart() .appendFraction(ChronoField.NANO_OF_SECOND, 9, 9, true) .optionalEnd() // optional nanos with 6 digits (including decimal point) .optionalStart() .appendFraction(ChronoField.NANO_OF_SECOND, 6, 6, true) .optionalEnd() // optional nanos with 3 digits (including decimal point) .optionalStart() .appendFraction(ChronoField.NANO_OF_SECOND, 3, 3, true) .optionalEnd() // offset .appendOffset("+HH:mm", "Z") // create formatter .toFormatter();

此格式化程序的工作方式与使用[]模式创建的第一个格式化程序完全相同。

副作用

由于@SeanVanGorder注意到javadoc，此格式化程序具有接受纳秒字段的多个模式的副作用，但仅当值相同时才有效：

// side effect // multiple nanos values (accepts multiple values if they're all the same) System.out.println(OffsetDateTime.parse("20161201-10:30:45.123000.123Z", formatter)); // 2016-12-01T10:30:45.123Z System.out.println(OffsetDateTime.parse("20161201-10:30:45.123000000.123Z", formatter)); // 2016-12-01T10:30:45.123Z System.out.println(OffsetDateTime.parse("20161201-10:30:45.123000000.123000.123Z", formatter)); // 2016-12-01T10:30:45.123Z

上面的所有行都输出2016-12-01T10:30:45.123Z，但请注意它们接受所有可选值（例如.123000000.123）。由于值相同，解析完成没有错误。

但是，如果值不同，则会抛出异常：

// multiple nanos values (throws exception if values are different) System.out.println(OffsetDateTime.parse("20161201-10:30:45.123000.124Z", formatter)); // exception

如果不需要这种行为，唯一的选择是创建许多不同的格式化程序（每种情况一个）并执行for循环，直到获得有效的解析值（非常类似于in his comment }）。

首先，我创建了一个方法，接收DateTimeFormatter和TemporalQuery的列表，将解析后的字符串转换为您想要的任何对象：

// method to parse, it receives a list of DateTimeFormatter and a TemporalQuery to convert the parsed string public <T> T parse(String input, TemporalQuery<T> query, DateTimeFormatter... formatters) { for (DateTimeFormatter fmt : formatters) { try { // try to parse return fmt.parse(input, query); } catch (Exception e) {} } // none worked, throw exception throw new DateTimeParseException("Text '" + input + "' could not be parsed", input, 0); }

现在您只需要创建格式化程序并在parse方法中使用它们：

// alternative: have 3 different formatters DateTimeFormatter f1 = new DateTimeFormatterBuilder() // here is the same as your code .append(DateTimeFormatter.BASIC_ISO_DATE).appendLiteral('-') // time (hour/minute/seconds/3 digit nanos) .appendPattern("HH:mm:ss.SSS") // offset .appendOffset("+HH:mm", "Z") // create formatter .toFormatter(); DateTimeFormatter f2 = new DateTimeFormatterBuilder() // here is the same as your code .append(DateTimeFormatter.BASIC_ISO_DATE).appendLiteral('-') // time (hour/minute/seconds/6 digit nanos) .appendPattern("HH:mm:ss.SSSSSS") // offset .appendOffset("+HH:mm", "Z") // create formatter .toFormatter(); DateTimeFormatter f3 = new DateTimeFormatterBuilder() // here is the same as your code .append(DateTimeFormatter.BASIC_ISO_DATE).appendLiteral('-') // time (hour/minute/seconds/9 digit nanos) .appendPattern("HH:mm:ss.SSSSSSSSS") // offset .appendOffset("+HH:mm", "Z") // create formatter .toFormatter(); // all formatters DateTimeFormatter[] formatters = new DateTimeFormatter[] { f1, f2, f3 }; // 3 digits System.out.println(parse("20161201-10:30:45.123Z", OffsetDateTime::from, formatters)); // 2016-12-01T10:30:45.123Z // 6 digits System.out.println(parse("20161201-10:30:45.123456Z", OffsetDateTime::from, formatters)); // 2016-12-01T10:30:45.123456Z // 9 digits System.out.println(parse("20161201-10:30:45.123456789Z", OffsetDateTime::from, formatters)); // 2016-12-01T10:30:45.123456789Z // 4 digits (throws exception) System.out.println(parse("20161201-10:30:45.1234Z", OffsetDateTime::from, formatters)); // java.time.format.DateTimeParseException: Text '20161201-10:30:45.1234Z' could not be parsed // multiple values (throws exception) System.out.println(parse("20161201-10:30:45.123000.123Z", OffsetDateTime::from, formatters)); // java.time.format.DateTimeParseException: Text '20161201-10:30:45.123000.123Z' could not be parsed

请注意，我使用方法参考OffsetDateTime::from作为TemporalQuery，但您可以将其更改为您需要的任何查询。

Answer 2

def mean_squared_error(y_true, y_pred): return K.mean(K.square(y_pred - y_true), axis=-1)仅支持宽度范围，因此单个实例无法实现这一点。您可以使用DateTimeFormatter制作3个单独的格式化程序，其中＃是3,6或9.然后按顺序尝试它们，忽略任何.appendFraction(NANO_OF_SECOND, #, #, true)直到最后一个：

DateTimeParseException

另一种选择是首先使用正则表达式检查输入，例如private static TemporalAccessor parse(String text) { try { return formatter3.parse(text); } catch (DateTimeParseException e) { // ignore } try { return formatter6.parse(text); } catch (DateTimeParseException e) { // ignore } return formatter9.parse(text); // let this one throw }。

Java 8：如何创建具有毫秒，微秒或纳秒的DateTimeFormatter？

2 个答案:

副作用