如何使用 LocalDateTime 解析/格式化日期？ （Java 8）

Question

Java 8 添加了新的 java.time 用于处理日期和时间的 API (JSR 310）。

我将日期和时间作为字符串（例如，“2014-04-08 12:30”）。如何获取 LocalDateTime给定字符串的 实例？

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

Answer 1

解析日期和时间

从字符串中创建 localdatetime 对象您可以使用static localdatetime.parse.parse（） 方法。它采用一个字符串和 datement formeformatter 作为参数。 DateTimeFormatter 用于指定日期/时间模式。

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

格式化日期和时间

要创建一个格式化的字符串 localDateTime 对象您可以使用 form> 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-04-08T12：30：00” 。

parse（）和格式（）方法可用于所有日期/时间相关的对象（例如 localdate 或 zoneddateTime ）

Answer 2

您也可以在 localdate.parse（） localdateTime.parse（） string> String 上使用 localdate.parse（） ，如果而无需提供模式> string 在。

例如，

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);

output ，

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

并仅当您必须处理其他日期模式时，使用 dateTimeFormatter 。

例如，在下面的示例中， dd mmm uuuu 代表本月的一天（两个数字），三个月份的字母（2月，2月，3月， ，...）和四位数的年：

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));

output

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

Answer 3

Sufiyan Ghori 和 <一href="https://stackoverflow.com/questions/22463062/how-can-i-parse-format-dates-with-localdatetime-java-8/22463063#22463063">micha的答案很好地解释了关于字符串模式的问题。但是，如果您使用 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();

Answer 4

用日期和时间在特定时间点中解析字符串（Java称其为“ 即时 ”）非常复杂。 Java在几次迭代中一直在解决这个问题。最新的一个， java.time 和 java.time.chrono ，涵盖了几乎所有需求（时间扩张 :)）。

但是，这种复杂性带来了很多混乱。

理解日期解析的关键是：

为什么Java有这么多方法来解析日期？

1. 有几个系统可以测量一段时间。例如，日本历史日历源自各自皇帝或王朝统治时期的时间范围。然后，例如，例如， unix timestamp 。
   幸运的是，整个（商业）世界设法使用了相同的使用。
2. 从历史上看，这些系统正在从/到各种原因。例如，从 julian calendar 到 Gregorian日历 1582年;因此，在此之前的“西方”日期需要有所不同。
3. 而且，当然，这种变化并没有立即发生。因为日历来自某些宗教和欧洲其他地区的总部，例如，德国直到1700年才切换

。...为什么 localdatetime ， ZonedDateTime 等。如此复杂的

4. 有时区。
   时区基本上是地球表面的“条纹”* [3] ，其当局遵循相同的规则，即何时有时间偏移。这包括夏季规则。

   时区随着时间的流逝而变化，主要是基于谁征服了谁。和一个时区的规则随着时间的流逝而更改。

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

   如果您获得了时区的时间戳，则偏移可能会有所不同，具体取决于一年中的哪一部分。在leap时，时间戳可能意味着两个不同的时间，因此没有其他信息，它可以' t可靠地转换。

   注意：由 timestamp 我的意思是“一个包含日期和/或时间的字符串，可选地使用时区和/或时间偏移。”

6. 几个时区可以共享某些时期的同一时间偏移。例如，GMT/UTC时区与夏季时间偏移无效的“伦敦”时区相同。

使其更加复杂（但这对您的用例并不重要）：

7. 科学家观察到地球的动态，随着时间的流逝而变化；基于这一点，他们在个体年代结束时增加了几秒钟。 （So 2040-12-31 24:00:00 可能是有效的日期时间。）这需要对系统用来正确具有日期转换的元数据的定期更新。例如，在Linux上，您会定期更新Java软件包，包括这些新数据。

8. 更新并不总是保留历史和未来时间戳的先前行为。因此，可能会发生在某个时区的更改周围的两个时间戳进行分析，以比较它们可能会给出不同的结果。这也适用于受影响时区和其他时区之间的比较。

   是否应该在您的软件中引起错误，请考虑使用某些没有复杂规则的时间戳，例如 Unix Timestamp 。

9. 由于有7个，对于未来的日期，我们无法确切地转换日期。因此，例如， 8524-02-17的当前解析12:00:00 可能会从未来解析的几秒钟内退出。

JDK的API随着当代的需求而发展，

• 早期的Java版本刚刚 java.util.date ，它具有有点幼稚的方法，假设只是一年，月，一天，时间和时间。这很快就不够了。
• 同样，数据库的需求是不同的，因此引入了 的早期，具有其自身的局限性。
• 由于没有很好地介绍不同的日历和时区，因此引入了日历 API。
• 这仍然没有涵盖时区的复杂性。然而，上述API的混合实际上确实很痛苦。因此，随着Java开发人员开始从事全球Web应用程序的工作，针对大多数用例的库，例如Jodatime，很快就流行了。 Jodatime是大约十年来的事实上的标准。
• 但是JDK并未与Jodatime集成，因此与之合作有点麻烦。因此，经过很长的讨论，讨论了如何处理问题， jsr-310 被创建主要基于jodatime 。

如何在Java的 Java.Time 中处理它，

解析时间戳的类型

确定要在消费时间戳字符串时 ，您需要知道它包含哪些信息。 这是关键点。如果您不正确，最终会得到一个隐秘的例外，例如“无法创建瞬间”，“ Zone Offset Misssist”，“ Unknown Zone ID”，等等

• 。
• ​ a zoneddateTime获得
• /stackoverflow.com/questions/23596530/unable-to-obtain-zoneddateTime-from-temporalaccessor-using-datetimeformatter-and-dateTimeFormatter-and？noredirect = 1＆amp;lq = 1"> quartirect = 1"> quartirect = 1“>不可能从tuermalaccessor a hreff = a hreff = a href = “ https://stackoverflow.com/questions/39978897/39978897/dateTimeParseexecception-with-localdatement-localdetime-to-obtain-to-obtain-localdatetime-from-t?noredirect = 1＆amp; lq = 1＆amp; lq = 1“>可从tuermalAlaCcessor 获得localdateTime
• a href =“ https://stackoverflow.com/questions/40279066/40279066/instant time-parsing-eror-unable-unable-unable-to-obtain-to-obtain-instant-from-temporalaccessor”

< >它包含日期和时间吗？

1. 是否有时间偏移？
   时间偏移是+hh：mm 零件。有时，+00：00 可以用 z 作为'zulu time'， utc 作为通用时间协调，或 gmt < /em>作为格林威治的平均时间。这些也设定了时区。
   对于这些时间戳，您可以使用 offsetDateTime 。

   


2. 它有时区吗？
   对于这些时间戳，您可以使用 noreferrer“ > 。
   区域是由

   指定的

   • 名称（“布拉格”，“太平洋标准时间”，“ PST”）或
   • “区域ID”（“ America/Los_angeles”，“欧洲/伦敦”），由 java.time.zoneid 。

   时区列表由a “ noreferrer”>“ noreferrer”>“ tz database” ，由 icaan 。

   根据 ZoneID 的Javadoc，可以以某种方式将区域ID指定为 Z 和Offset。我不确定这是如何映射到真实区域的。

   如果只有TZ的时间戳属于一个时间偏移的时间偏移更改，那么它是模棱两可的，解释是 resolverstyle 的主题，请参见下文。

   。

3. 如果它没有，则假定或忽略了缺失的上下文。消费者必须决定。因此，它需要以 localDateTime 进行解析，并通过添加丢失的信息来转换为 offsetDateTime ：

   • 您可以假设是UTC时间。添加UTC偏移为0小时。
   • 您可以假设是转换发生的地方的时代。通过添加系统的时区进行转换。
   • 您可以忽略，然后按原样使用它。这是有用的，例如比较或减去两次（请参阅 <代码>持续时间 ），或者当您不知道并且并不重要时（例如，本地巴士时间表）。

部分时间信息

• 基于时间戳所包含的内容，您可以采用 localdate ， localtime ， offsetTime ，月日，<代码>年，或 YearMonth 。

如果您有完整的信息，则可以获得 java.time.instant 。这也用于内部用于在 OffSetDateTime 和 ZonedDateTime 之间转换。

弄清楚如何解析它，

DateTimeFormatter 可以将时间戳字符串和格式解析为字符串。

代码> DateTimeFormatter s 应涵盖或多或少涵盖所有标准时间戳格式。例如， 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 ，它控制解析器是宽大，智能还是严格的格式和模棱两可的信息。

现在， YeaterAlaccessor

，经常出现的错误是进入 terumalaccessor 的复杂性。这来自开发人员使用 simpledateformatter.parse（string）的方式。对， datementingformatter.parse（“ ...”）给您 temeralAccessor 。

// 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");

关于 terunalAccessor ，如果您对字符串中有哪些信息有模糊的了解，并且想在运行时做出决定，则可以使用它。

我希望我对您的灵魂有所了解:)

注意： java.time 的后退到Java 6和7： threeten-backport 。对于Android，它具有 threetenabp 。

[3] 不仅是它们不是条纹，而且还有一些奇怪的极端。例如，一些邻近的太平洋岛屿和-11：00时区。这意味着，在一个岛上，在5月3日下午1日，在另一个岛屿上，它仍然是4月30日下午30点（如果我正确计数的话：））

Answer 5

使用 LocalDateTime.Parse 要注意的另一件事是，您不能将其与仅具有date formatter字符的自定义格式化器一起使用，例如 uuuuumdd 。在这种情况下，您应该改用 localdate.parse 。例如：

String s = "20210223";
        
// ok
LocalDate.parse(s, DateTimeFormatter.ofPattern("uuuuMMdd"));
        
// java.time.format.DateTimeParseException
LocalDateTime.parse(s, DateTimeFormatter.ofPattern("uuuuMMdd")); 

Answer 6

以所需格式获取当前 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));

Answer 7

所有的答案都很好。 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 - 并非所有类型都可以工作，因为这些类型已损坏（因此标记为已弃用，请不要使用它们）。

Answer 8

通用方法如下所示。它适用于：

• yyyy-MM-dd HH:mm:ss.SSS

• yyyy-MM-dd HH:mm:ss.S

• yyyy-MM-dd HH:mm:ss

• yyyy-MM-dd HH:mm

• yyyy-MM-dd HH

• yyyy-MM-dd

  public static final String DATE_FORMAT_YYYY_MM_DD_HH_MM_SS_SSS = "yyyy-MM-dd HH:mm:ss.SSS";
  
  公共 LocalDateTime stringToLocalDateTime(String s){
      return LocalDateTime.parse(s, DateTimeFormatter.ofPattern(DATE_FORMAT_YYYY_MM_DD_HH_MM_SS_SSS.substring(0, s.length())));
  }
  

Answer 9

让我们提取两个问题，示例字符串“ 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) 

Answer 10

这个问题已经有很多好的答案。此答案显示了如何使用预定义 dateTimeFormatter s构建 dateTimeFormatter ，该可以解析给定的日期时间字符串。

但是，使用此 dateTimeFormatter 将获得的 LocalDateTime 格式化将在 hh：mm：mm：ss 格式中返回字符串。要将时间字符串限制为 HH：MM 格式，我们仍然必须使用模式 uuuuu-mm-dd hh：mm ，就像其他答案所做的那样。

demo ：

class Main {
    public static void main(String[] args) {
        DateTimeFormatter dtf = new DateTimeFormatterBuilder()
                .append(DateTimeFormatter.ISO_LOCAL_DATE)
                .appendLiteral(' ')
                .append(DateTimeFormatter.ISO_LOCAL_TIME)
                .toFormatter(Locale.ENGLISH);

        String strDateTime = "2014-04-08 12:30";
        LocalDateTime ldt = LocalDateTime.parse(strDateTime, dtf);
        System.out.println(ldt);

        // However, formatting the obtained LocalDateTime using this DateTimeFormatter
        // will return a string with time in HH:mm:ss format. To restrict the time
        // string to HH:mm format, we still have to use the pattern, uuuu-MM-dd HH:mm as
        // other answers have done.
        String strDateTimeFormatted = ldt.format(dtf);
        System.out.println(strDateTimeFormatted);

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm", Locale.ENGLISH);
        strDateTimeFormatted = ldt.format(formatter);
        System.out.println(strDateTimeFormatted);
    }
}

输出：

2014-04-08T12:30
2014-04-08 12:30:00
2014-04-08 12:30

在线demo < < /a>

注意：在这里，您可以使用 y 而不是 u ，但我更喜欢 u 而不是 y 。

从 trail> trail> trail：日期时间< /a> 。

Answer 11

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

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);

Answer 12

当我有一个类型 java.time.localdatetime 的变量时，以获得理想格式的日期，我不想使用中间

LocalDateTime nowDate = LocalDateTime.now();
String nowDateInString = nowDate.toString().substring(0,16).replace("T", " ");

类-27 11:17

您可以调整“子字符串”中的值以检索所需的内容。

我想指出的是，这在每种情况下都不是合适的方法。