如何用LocalDateTime解析/格式化日期?(Java 8)

Java 8添加了一个新的< em > java.time < / em > API，用于处理日期和时间(JSR 310)。

我将日期和时间作为字符串(例如，"2014-04-08 12:30")。如何从给定的字符串中获取LocalDateTime实例?

在处理完LocalDateTime对象后:如何将LocalDateTime实例转换回与上面显示的格式相同的字符串?

813701 次浏览
小开
最佳答案

解析日期和时间

要从字符串创建LocalDateTime对象，可以使用静态LocalDateTime.parse()方法。它接受一个字符串和DateTimeFormatter作为参数。DateTimeFormatter用于指定日期/时间模式。

String str = "1986-04-08 12:30";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
LocalDateTime dateTime = LocalDateTime.parse(str, formatter);

格式化日期和时间

要从LocalDateTime对象中创建格式化字符串，可以使用format()方法。

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
LocalDateTime dateTime = LocalDateTime.of(1986, Month.APRIL, 8, 12, 30);
String formattedDateTime = dateTime.format(formatter); // "1986-04-08 12:30"

注意，在DateTimeFormatter中有一些常用的日期/时间格式预定义为常量。例如:使用DateTimeFormatter.ISO_DATE_TIME来格式化上面的LocalDateTime实例将会得到字符串"1986-04-08T12:30:00"。

parse()和format()方法可用于所有与日期/时间相关的对象(例如LocalDate或ZonedDateTime)

小开

如果String在ISO 8601格式中，你也可以在不提供模式的情况下对String使用LocalDate.parse()或LocalDateTime.parse()。

例如,

String strDate = "2015-08-04";
LocalDate aLD = LocalDate.parse(strDate);
System.out.println("Date: " + aLD);


String strDatewithTime = "2015-08-04T10:11:30";
LocalDateTime aLDT = LocalDateTime.parse(strDatewithTime);
System.out.println("Date with Time: " + aLDT);

输出,

Date: 2015-08-04
Date with Time: 2015-08-04T10:11:30

并且仅在必须处理其他日期模式时才使用DateTimeFormatter。

例如，在下面的例子中，dd MMM uuuu表示月份的日期(两位数字)，月份名称的三个字母(Jan, Feb, Mar，…)，以及一个四位数的年份:

DateTimeFormatter dTF = DateTimeFormatter.ofPattern("dd MMM uuuu");
String anotherDate = "04 Aug 2015";
LocalDate lds = LocalDate.parse(anotherDate, dTF);
System.out.println(anotherDate + " parses to " + lds);

输出

04 Aug 2015 parses to 2015-08-04

还要记住DateTimeFormatter对象是双向的;它既可以解析输入，也可以格式化输出。

String strDate = "2015-08-04";
LocalDate aLD = LocalDate.parse(strDate);
DateTimeFormatter dTF = DateTimeFormatter.ofPattern("dd MMM uuuu");
System.out.println(aLD + " formats as " + dTF.format(aLD));

输出

2015-08-04 formats as 04 Aug 2015

(参见完整的格式化和解析DateFormatter的模式列表。)

  Symbol  Meaning                     Presentation      Examples
------  -------                     ------------      -------
G       era                         text              AD; Anno Domini; A
u       year                        year              2004; 04
y       year-of-era                 year              2004; 04
D       day-of-year                 number            189
M/L     month-of-year               number/text       7; 07; Jul; July; J
d       day-of-month                number            10


Q/q     quarter-of-year             number/text       3; 03; Q3; 3rd quarter
Y       week-based-year             year              1996; 96
w       week-of-week-based-year     number            27
W       week-of-month               number            4
E       day-of-week                 text              Tue; Tuesday; T
e/c     localized day-of-week       number/text       2; 02; Tue; Tuesday; T
F       week-of-month               number            3


a       am-pm-of-day                text              PM
h       clock-hour-of-am-pm (1-12)  number            12
K       hour-of-am-pm (0-11)        number            0
k       clock-hour-of-am-pm (1-24)  number            0


H       hour-of-day (0-23)          number            0
m       minute-of-hour              number            30
s       second-of-minute            number            55
S       fraction-of-second          fraction          978
A       milli-of-day                number            1234
n       nano-of-second              number            987654321
N       nano-of-day                 number            1234000000


V       time-zone ID                zone-id           America/Los_Angeles; Z; -08:30
z       time-zone name              zone-name         Pacific Standard Time; PST
O       localized zone-offset       offset-O          GMT+8; GMT+08:00; UTC-08:00;
X       zone-offset 'Z' for zero    offset-X          Z; -08; -0830; -08:30; -083015; -08:30:15;
x       zone-offset                 offset-x          +0000; -08; -0830; -08:30; -083015; -08:30:15;
Z       zone-offset                 offset-Z          +0000; -0800; -08:00;


p       pad next                    pad modifier      1


'       escape for text             delimiter
''      single quote                literal           '
[       optional section start
]       optional section end
#       reserved for future use
{       reserved for future use
}       reserved for future use
小开

Sufiyan Ghori的和 米莎回答的都很好地解释了关于字符串模式的问题。然而，以防你正在使用ISO 8601，没有任何必要应用DateTimeFormatter，因为LocalDateTime已经为它准备好了:

将LocalDateTime转换为时区ISO 8601字符串

LocalDateTime ldt = LocalDateTime.now();
ZonedDateTime zdt = ldt.atZone(ZoneOffset.UTC); // You might use a different zone
String iso8601 = zdt.toString();

从ISO8601字符串转换回LocalDateTime

String iso8601 = "2016-02-14T18:32:04.150Z";
ZonedDateTime zdt = ZonedDateTime.parse(iso8601);
LocalDateTime ldt = zdt.toLocalDateTime();
小开

将带有日期和时间的字符串解析为特定的时间点(Java称之为"Instant")是相当复杂的。Java已经在几次迭代中解决了这个问题。最新的java.time和java.time.chrono几乎涵盖了所有需求(除了时间膨胀:))。

然而，这种复杂性带来了很多困惑。

理解日期解析的关键是:

为什么Java有这么多解析日期的方法?

    有几种测量时间的系统。例如，历史上的日本历法是从各自皇帝或王朝统治的时间范围中衍生出来的。然后是，例如，Unix时间戳。 幸运的是，整个(商业)世界设法使用相同的。
  1. 历史上，对于各种原因，系统从/切换到。例如，从1582年的公历到公历;因此，在此之前的“西方”日期需要区别对待。
  2. 当然，这种变化不是一下子发生的。因为日历来自一些宗教的总部，而欧洲其他地区相信其他神，例如德国直到1700年才改变了日历。

.．.以及为什么LocalDateTime， ZonedDateTime等如此复杂

  1. 有时区。 时区基本上是地球表面的一个“条纹”，它的权威遵循同样的规则，即什么时候有哪个时间偏移。

    不同地区的时区随着时间的推移而变化，主要是基于谁征服了谁。还有一个时区的规则随时间变化。

  2. 有时间偏移。这与时区不同，因为一个时区可能是，例如，“布拉格”，但它有夏季时间偏移和冬季时间偏移。

    如果您获得一个带有时区的时间戳，偏移量可能会有所不同，这取决于它所在的年份。在闰时期间，时间戳可能表示两个不同的时间，因此如果没有额外的信息，就不能可靠地进行转换。

    注意:时间戳的意思是“包含日期和/或时间的字符串，可选带有时区和/或时间偏移量。”

  3. 几个时区可能在某些时间段内共享相同的时间偏移量。例如，GMT/UTC时区与“伦敦”时区相同。时区时，夏季时间偏移不生效。

为了让它更复杂一点(但这对你的用例来说并不太重要):

  1. 科学家们观察地球的动态，它随时间而变化;在此基础上，他们在每个年份的末尾加上秒数。(因此2040-12-31 24:00:00可能是一个有效的日期-时间。)这需要定期更新系统用于正确进行日期转换的元数据。例如，在Linux上，您可以定期更新Java包，包括这些新数据。

  2. 对于历史时间戳和未来时间戳，更新并不总是保持以前的行为。因此，当在不同版本的软件上运行时，可能会发生围绕某个时区的变化解析两个时间戳时比较它们可能会得到不同的结果。这也适用于在受影响的时区和其他时区之间进行比较。

    如果这会导致你的软件出现错误，可以考虑使用一些没有这么复杂规则的时间戳，比如Unix时间戳。

  3. 因为7，对于未来的日期，我们不能准确地转换日期。因此，例如，当前解析的8524-02-17 12:00:00可能会比未来的解析中断几秒钟。

JDK的api是随着当代需求而发展的

  • 早期的Java版本只有java.util.Date，它的方法有点天真，假设只有年、月、日和时间。这很快就不够了。
  • 此外，数据库的需求是不同的，所以很早就引入了java.sql.Date，但有其自身的局限性。
  • 因为它们都没有很好地涵盖不同的日历和时区，所以引入了Calendar API。
  • 这还不包括时区的复杂性。然而，上述api的混合使用确实很麻烦。因此，当Java开发人员开始致力于全球web应用程序时，针对大多数用例的库，如JodaTime，迅速流行起来。JodaTime在大约十年的时间里一直是事实上的标准。
  • 但是JDK没有与JodaTime集成，所以使用它有点麻烦。因此，在对如何处理这个问题进行了很长时间的讨论之后，jsr - 310被创建了主要基于JodaTime。

如何处理它在Java的java.time

确定要解析时间戳的类型

当您使用时间戳字符串时，您需要知道它包含什么信息。这是关键的一点。如果你没有做到这一点，你最终会得到一个神秘的例外，如“不能创建即时”，“区域偏移丢失”，“未知区域id”等。

它包含日期和时间吗?

  1. 是否有时间偏移? 时间偏移量是+ hh: mm部分。有时，+ 00:00可以用Z替换为“祖鲁时间”，UTC替换为协调世界时，格林尼治时间替换为格林威治标准时间。这些还可以设置时区。 对于这些时间戳，使用OffsetDateTime.

  2. 有没有时区? 对于这些时间戳，使用ZonedDateTime。 Zone指定为

    • 名称(“布拉格”，“太平洋标准时间”，“PST")，或
    • “区ID"(“;美国/洛杉矶”，“;欧洲/伦敦”)，由java.time.ZoneId代表。

    时区列表由“TZ database"编译，并由ICAAN支持。

    根据ZoneId的javadoc，区域id也可以以某种方式指定为Z和offset。我不知道这是怎么映射到真实区域的。

    如果只有一个TZ的时间戳落入一个闰时的时间偏移量变化，那么它是模糊的，并且解释是ResolverStyle的主题，见下文。

  3. 如果两者都没有，则假定或忽略缺失的上下文。消费者必须做出决定。所以它需要被解析为LocalDateTime，并通过添加缺少的信息转换为OffsetDateTime:

    • 你可以假设它是一个UTC时间。添加0小时的UTC偏移量。
    • 你可以假设它是发生转换的地方的时间。通过添加系统的时区进行转换。
    • 你可以忽视并按原样使用它。这是很有用的，例如比较或减去两次(参见Duration)，或者当你不知道并且真的不重要的时候(例如，当地的公共汽车时刻表)。

部分时间信息

  • 根据时间戳所包含的内容，你可以从中提取LocalDate、LocalTime、OffsetTime、MonthDay、Year或YearMonth。

如果你有完整的信息，你可以得到java.time.Instant。它也在内部用于在OffsetDateTime和ZonedDateTime之间进行转换。

弄清楚如何解析它

有一个关于DateTimeFormatter的广泛文档，它既可以解析时间戳字符串，也可以格式化为字符串。

预先创建DateTimeFormatters应该或多或少涵盖所有标准时间戳格式。例如，ISO_INSTANT可以解析2011-12-03T10:15:30.123457Z。

如果你有一些特殊的格式，那么你可以创建自己的DateTimeFormatter(它也是一个解析器)。

private static final DateTimeFormatter TIMESTAMP_PARSER = new DateTimeFormatterBuilder()
.parseCaseInsensitive()
.append(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SX"))
.toFormatter();

我建议查看DateTimeFormatter的源代码，并获得如何使用DateTimeFormatterBuilder构建一个的灵感。当你在那里时，也要看看ResolverStyle，它控制了解析器对于格式和模糊信息是LENIENT、SMART还是STRICT。

TemporalAccessor

现在，常见的错误是深入到TemporalAccessor的复杂性。这来自于开发人员使用SimpleDateFormatter.parse(String)的方式。对，DateTimeFormatter.parse("...")给你TemporalAccessor。

// No need for this!
TemporalAccessor ta = TIMESTAMP_PARSER.parse("2011-... etc");

但是，有了上一节的知识，你可以方便地解析成你需要的类型:

OffsetDateTime myTimestamp = OffsetDateTime.parse("2011-12-03T10:15:30.123457Z", TIMESTAMP_PARSER);

你实际上也不需要DateTimeFormatter。你想要解析的类型有parse(String)方法。

OffsetDateTime myTimestamp = OffsetDateTime.parse("2011-12-03T10:15:30.123457Z");

关于TemporalAccessor，如果你对字符串中有什么信息有一个模糊的概念，并且想在运行时决定，你可以使用它。

我希望我能给你的灵魂带来一些理解:)

注意:有一个java.time到Java 6和7的后端口:ThreeTen-Backport。对于Android，它有ThreeTenABP。

不仅因为它们不是条纹，而且还有一些奇怪的极端。例如，一些邻近的太平洋岛屿有+14:00和-11:00时区。这意味着，在一个岛屿上，现在是5月1日下午3点，在另一个不远处的岛屿上，现在仍然是4月30日下午12点(如果我没数错:))

小开

我发现像这样涵盖日期时间格式的多种变体非常棒:

final DateTimeFormatterBuilder dtfb = new DateTimeFormatterBuilder();
dtfb.appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSSSSS"))
.appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSSSS"))
.appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSSS"))
.appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSS"))
.appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSS"))
.appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSS"))
.appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"))
.appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SS"))
.appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.S"))
.parseDefaulting(ChronoField.HOUR_OF_DAY, 0)
.parseDefaulting(ChronoField.MINUTE_OF_HOUR, 0)
.parseDefaulting(ChronoField.SECOND_OF_MINUTE, 0);
小开

获取所需格式的当前UTC时间

// Current the UTC time
OffsetDateTime utc = OffsetDateTime.now(ZoneOffset.UTC);


// Get LocalDateTime
LocalDateTime localDateTime = utc.toLocalDateTime();
System.out.println("*************" + localDateTime);


// Formatted UTC time
DateTimeFormatter dTF = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
System.out.println(" formats as " + dTF.format(localDateTime));


// Get the UTC time for the current date
Date now = new Date();
LocalDateTime utcDateTimeForCurrentDateTime = Instant.ofEpochMilli(now.getTime()).atZone(ZoneId.of("UTC")).toLocalDateTime();
DateTimeFormatter dTF2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
System.out.println(" formats as " + dTF2.format(utcDateTimeForCurrentDateTime));
小开

让我们回答两个问题，以字符串"2014-04-08 12:30"为例

如何从给定的字符串获得LocalDateTime实例?

import java.time.format.DateTimeFormatter
import java.time.LocalDateTime


final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")


// Parsing or conversion
final LocalDateTime dt = LocalDateTime.parse("2014-04-08 12:30", formatter)

dt应该允许你所有的日期时间相关的操作

然后如何将LocalDateTime实例转换回具有相同格式的字符串?

final String date = dt.format(formatter)
小开

所有的答案都是好的。Java 8+版本有这些解析和格式化时区的模式:V， z， O， X， x， Z。

根据文档中的规则，对于解析，它们是:

   Symbol  Meaning                     Presentation      Examples
------  -------                     ------------      -------
V       time-zone ID                zone-id           America/Los_Angeles; Z; -08:30
z       time-zone name              zone-name         Pacific Standard Time; PST
O       localized zone-offset       offset-O          GMT+8; GMT+08:00; UTC-08:00;
X       zone-offset 'Z' for zero    offset-X          Z; -08; -0830; -08:30; -083015; -08:30:15;
x       zone-offset                 offset-x          +0000; -08; -0830; -08:30; -083015; -08:30:15;
Z       zone-offset                 offset-Z          +0000; -0800; -08:00;

但是格式化呢?

下面是一个日期示例(假设ZonedDateTime)，它显示了不同格式化模式的这些模式行为:

// The helper function:
static void printInPattern(ZonedDateTime dt, String pattern) {
System.out.println(pattern + ": " + dt.format(DateTimeFormatter.ofPattern(pattern)));
}


// The date:
String strDate = "2020-11-03 16:40:44 America/Los_Angeles";
DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss zzzz");
ZonedDateTime dt = ZonedDateTime.parse(strDate, format);
// 2020-11-03T16:40:44-08:00[America/Los_Angeles]


// Rules:
// printInPattern(dt, "V");     // exception!
printInPattern(dt, "VV");       // America/Los_Angeles
// printInPattern(dt, "VVV");   // exception!
// printInPattern(dt, "VVVV");  // exception!
printInPattern(dt, "z");        // PST
printInPattern(dt, "zz");       // PST
printInPattern(dt, "zzz");      // PST
printInPattern(dt, "zzzz");     // Pacific Standard Time
printInPattern(dt, "O");        // GMT-8
// printInPattern(dt, "OO");    // exception!
// printInPattern(dt, "OO0");   // exception!
printInPattern(dt, "OOOO");     // GMT-08:00
printInPattern(dt, "X");        // -08
printInPattern(dt, "XX");       // -0800
printInPattern(dt, "XXX");      // -08:00
printInPattern(dt, "XXXX");     // -0800
printInPattern(dt, "XXXXX");    // -08:00
printInPattern(dt, "x");        // -08
printInPattern(dt, "xx");       // -0800
printInPattern(dt, "xxx");      // -08:00
printInPattern(dt, "xxxx");     // -0800
printInPattern(dt, "xxxxx");    // -08:00
printInPattern(dt, "Z");        // -0800
printInPattern(dt, "ZZ");       // -0800
printInPattern(dt, "ZZZ");      // -0800
printInPattern(dt, "ZZZZ");     // GMT-08:00
printInPattern(dt, "ZZZZZ");    // -08:00

在正偏移量的情况下，+符号字符在任何地方都被使用(现在有-的地方)，并且永远不会被省略。

这适用于新的java.time类型。如果你打算在java.util.Date或java.util.Calendar中使用这些类型，并不是所有类型都能工作，因为这些类型是坏的(因此被标记为已弃用，请不要使用它们)。

小开

关于LocalDateTime.parse要注意的另一件事是，你不能将它用于只有日期格式化器字符的自定义格式化程序，比如uuuuMMdd。在这种情况下，你应该使用LocalDate.parse。例如:

String s = "20210223";
        

// ok
LocalDate.parse(s, DateTimeFormatter.ofPattern("uuuuMMdd"));
        

// java.time.format.DateTimeParseException
LocalDateTime.parse(s, DateTimeFormatter.ofPattern("uuuuMMdd"));
小开

普遍的方法如下所示。它适用于:

  • < p > yyyy-MM-dd HH: mm: ss。瑞士

  • < p > yyyy-MM-dd HH: mm: ss。年代

  • < p > yyyy-MM-dd HH: mm: ss

  • < p > yyyy-MM-dd HH: mm

  • < p > yyyy-MM-dd HH

  • < p > yyyy-MM-dd

    public static final String DATE_FORMAT_YYYY_MM_DD_HH_MM_SS_SSS = "yyyy-MM-dd HH:mm:ss.SSS";


public LocalDateTime stringToLocalDateTime(String s){
return LocalDateTime.parse(s, DateTimeFormatter.ofPattern(DATE_FORMAT_YYYY_MM_DD_HH_MM_SS_SSS.substring(0, s.length())));
}

提交答案