如何在Java 8（Scala）中将日期时间字符串转换为long（UNIX纪元时间）

Question

I want the UNIX Epoch Time (Posix Time, Unix Time) of a string in some pattern , the string is in normal format (so UTC). Please using Java 8, not Joda or old Java.

(For milliseconds please see How to convert a date time string to long (UNIX Epoch Time) Milliseconds in Java 8 (Scala) )

So far I have the below, but I hate this for a number of reasons:

1. It's way too verbose for what is the most common thing to do with dates (convert to UNIX Epoch Time). 7 method calls for what should be 1.
2. It has to specify UTC, but surely UTC is just a default, why do I have to be explicit here?
3. It has a string literal "UTC"
4. It has a magic number ZoneOffset.ofHours(0)

My best so far:

def dateTimeStringToEpoch(s: String, pattern: String): Long = 
    LocalDateTime.parse(s, DateTimeFormatter.ofPattern(pattern))
      .atZone(ZoneId.ofOffset("UTC", ZoneOffset.ofHours(0)))
      .toInstant().getEpochSeconds

Also, bonus question, is it efficient? Is there any overhead to creating the DateTimeFormatter via DateTimeFormatter.ofPattern(pattern) ? If so why?

Answer 1

You may use the equivalent of the following Java code:

static long dateTimeStringToEpoch(String s, String pattern) {
    return DateTimeFormatter.ofPattern(pattern).withZone(ZoneOffset.UTC)
        .parse(s, p -> p.getLong(ChronoField.INSTANT_SECONDS));
}

Of course, processing DateTimeFormatter.ofPattern(pattern).withZone(ZoneOffset.UTC) implies work that could be avoided when encountering the same pattern string multiple times. Whether this amount of work is relevant for your application, depends on what is is doing beside this operation.

Answer 2

This one is more than two times shorter ( only 3 method calls ):

def dateTimeStringToEpoch(s: String, pattern: String): Long = 
     LocalDateTime.parse(s, DateTimeFormatter.ofPattern(pattern))
                  .toEpochSecond(ZoneOffset.UTC)

Btw, I would build the DateTimeFormatter outside of dateTimeStringToEpoch and pass it as a method parameter:

def dateTimeStringToEpoch(s: String, formatter: DateTimeFormatter): Long = 
     LocalDateTime.parse(s, formatter).toEpochSecond(ZoneOffset.UTC)

Having actually run a performance test, there is little difference in performance (barely a factor of 2) in initialising the DateTimeFormatter outside the method.

scala> val pattern = "yyyy/MM/dd HH:mm:ss"
pattern: String = yyyy/MM/dd HH:mm:ss

scala>   time(() => randomDates.map(dateTimeStringToEpoch(_, pattern)))
Took: 1216

scala>   time(() => randomDates.map(dateTimeStringToEpochFixed))
Took: 732

Answer 3

你可以试试这个吗，根据你所说的，解析UTC时间，所以我把它作为样本。

Instant.parse("2019-01-24T12:48:14.530Z").getEpochSecond