Java SE 8 新特性之旅：使用新的 DateTime API 计算时间间隔

使用 Java SE 8 新的 DateTime API JSR 310 进行更清晰、更易读、更强大的编码.....

Java SE 8, JSR 310

在本篇“Java SE 8 新特性导览”系列文章中，我们将深入探讨 JSR 310 规范的解释和代码，重点介绍使用新的 DateTime API 计算时间间隔，使用 Instant 和 Duration 计算时间间隔，表示日期和时间值，格式化日期和时间值，以及支持时区偏移。

在前一篇文章“使用 Streams API 处理集合”中，我深入解释和探讨了如何使用流遍历集合、从集合和数组创建流，以及最后聚合流值。

源代码托管在我的Github账户上：请在此处克隆。

目录

1. 使用 Instant 和 Duration 计算时间间隔
2. 表示日期和时间值
3. 格式化日期和时间值
4. 支持时区偏移

1. 使用 Instant 和 Duration 计算时间间隔

引言

Java SE 8 包含一个全新的 API 来管理日期和时间值。这个新 API 中实际保存数据的类都是不可变的和线程安全的。这意味着您不必担心在多线程环境中传递对象。如果您在并行流中使用它们，一切都会完美运行。此新 API 中的所有类都属于 java.time 包。我将从两个核心类 Instant 和 Duration 开始介绍。

工作原理

我将从 Java8Features 项目的 eg.com.tm.java8.features.datetime.InstDuration 包中的一个名为 InstantAndDuration 的类开始。我将把所有代码放在 main 方法中。我将描述的第一个类名为 Instant。我将输入类名并按 Ctrl + Space，然后从 java.time 包中选择该类，它会被导入。Instant 对象代表 Java 时间线上的一个瞬时点。就像旧的日期时间管理类 date 一样，Instant 对象表示毫秒数。

自 Java 纪元时间（1970 年 1 月 1 日）以来，要声明一个 instant 对象，我将声明它的类型，并给它一个名为 start 的名称。然后我将调用 Instant 类的一个静态方法 now()。这代表了代码被调用时当前机器上的那个时刻。然后我将使用标准的系统输出将其值作为字符串输出。运行代码，您将看到输出以年、月、日格式的日期开始，然后是字母 T 之后的时间。

package eg.com.tm.java8.features.datetime.InstDuration;
 
import java.time.Instant;
import static java.time.Instant.now;
/**
 *
 * @author mohamed_taman
 */
public class InstantAndDuration {
 
    public static void main(String[] args) {
 
        Instant start = now();
        System.out.println(start);
    }
}

结果

2016-08-05T21:21:59.601Z

一旦拥有一个时刻，您就可以用它来计算该时刻与另一个时刻之间的差异。所以我将创建另一个 instant，我将称之为 end。我将通过 now() 方法获取其值。然后我将使用系统输出，并输出该值。请注意，两个值之间存在微小差异，这表明处理这行代码（输出 start 值）在我的系统上花费的时间。

public static void main(String[] args) {
 
       Instant start = now();
       System.out.println(start);
 
       Instant end = now();
       System.out.println(end);
 }

结果

2016-08-05T21:33:55.971Z
2016-08-05T21:33:56.048Z

如果我将那行代码移到下面，这样在两次调用 now 方法之间我不会进行任何其他处理，那么这两个值将是相同的，或者可能会相差千分之一秒。

public static void main(String[] args) {
 
       Instant start = now();
       Instant end = now();
 
       System.out.println(start);
       System.out.println(end);
 }

结果

2016-08-05T21:34:43.365Z
2016-08-05T21:34:43.365Z

现在，我将向您展示如何计算这两个值之间的差异。当您比较两个 Instant 对象时，您将得到一个名为 duration 的对象。它由 Duration 类表示，该类也是 Java.time 的成员。我将把这个对象命名为 elapsed。我将调用 Duration 类的一个静态方法 between(Temporal startInclusive, Temporal endExclusive)。请注意，它正在寻找类型为 Temporal 的对象。Instant 类是 Temporal 的一个子类。

Instant start = now();
 
Instant end = now();
System.out.println(start);
System.out.println(end);
      
Duration elapsed = Duration.between(start, end);
System.out.println("Elapsed: "+ elapsed);

结果

Elapsed: PT0S

我将把 start 和 end 作为我的两个 temporal 值传递进去。然后我将输出差异。我将传递一个字面量标签 elapsed，然后传递我的变量。这个 duration 对象以字母 p 开始，然后是 t 表示时间。这再次是一个 ISO 格式的值。然后它显示零秒。好吧，让我们看看如果加入对 sleep 方法的调用会发生什么。我将把光标放在 start 和 end 调用之间。我将使用 Thread 类。

我将按句点，然后按 Ctrl+Space。然后我将调用 sleep() 方法并传入值 1,000。表示睡眠一秒。sleep 方法可能会抛出错误，所以我将使用快速修复，并向 main 方法的签名添加一个 throws 声明。我将保存并运行代码，我看到我的经过时间现在是 1.001 秒。您永远无法真正指望事情是精确的，这完全取决于处理计算机上正在发生的事情。

public static void main(String[] args) throws InterruptedException {
 
     Instant start = now();
      
     Thread.sleep(1000);
      
     Instant end = now();
     System.out.println(start);
     System.out.println(end);
      
     Duration elapsed = Duration.between(start, end);
     System.out.println("Elapsed: "+ elapsed);

结果

Elapsed: PT1.001S

接下来，我将把这个 printline 调用移回到原来的位置。所以现在，在获取 start 值之后，我将执行一个 printline 命令。然后我将睡眠一秒。我将运行代码。现在我的经过时间是 1.057 秒。

public static void main(String[] args) throws InterruptedException {
 
     Instant start = now();
     System.out.println(start);
      
     Thread.sleep(1000);
      
     Instant end = now();
     System.out.println(end);
      
     Duration elapsed = Duration.between(start, end);
     System.out.println("Elapsed: "+ elapsed);
   }

结果

2016-08-05T22:28:42.685Z
2016-08-05T22:28:43.769Z
Elapsed: PT1.084S

为了使它更具可读性，我将调用 duration 对象的一个方法 elapsed.to millis。这意味着获取毫秒等效值。然后我将追加毫秒，我将运行代码。

Duration elapsed = Duration.between(start, end);
   System.out.println("Elapsed: "+ elapsed.toMillis() +" milliseconds");

结果

2016-08-05T22:32:52.657Z
2016-08-05T22:32:53.731Z
Elapsed: 1074 milliseconds

结论

现在我看到一个易于阅读的值，1,054 毫秒。所以，这就是 Instant 类和 Duration 类。Java SE 8 中新的日期时间 API 的两个核心类。

2. 表示日期和时间值

引言

我之前描述了如何在新的日期时间 API 中使用 instant 类来表示 Java 时间线上的一个时刻。以下是另外三个有用的类来表示日期和时间的部分。它们称为本地日期、本地时间和本地日期时间。例如，假设您只想表示一个日期值。您不关心时间或秒或毫秒，只关心当前日期。创建一个名为 LocalDate 的类实例。

工作原理

我正在 Java8Features 项目的 eg.com.tm.java8.features.datetime.localdt 包中工作。在一个名为 LocalDateAndTime 的类代码中，带有一个 main 方法。我将从类名 LocalDate 开始。当我按 Ctrl + Space 时，我将从 java.time 包中选择该类。我将对象命名为 currentDate，并使用 localDate.now 获取其值。请注意，在处理 instant、date、time 和 date time 之间的语法是一致的。

要获取当前机器上的当前值，您始终使用 now 方法。现在，我将以默认格式输出该 date。我将保存并运行代码，它以年-月-日格式显示 date。

package eg.com.tm.java8.features.datetime.localdt;
 
import static java.time.LocalDate.now;
import java.time.LocalDate;
/**
 *
 * @author mohamed_taman
 */
public class LocalDateAndTime {
 
    public static void main(String[] args) throws InterruptedException {
 
        LocalDate currentDate = now();
        System.out.println(currentDate);
    }
}

结果

2016-08-06

您还可以使用特定的年、月和日值创建 date 对象。我将再次创建一个类型为 LocalDate 的对象。我将把这个命名为 specificDate。要获取此值，请调用 LocalDate.of。

有几个可用的版本。我将使用其中一个接受三个整数值的版本。文档中没有命名它们，但它们代表年、月和日。我将传入 2000、1 和 1 的值。现在，在旧版本的 date time API 中使用 date 类时。处理月份时，您总是需要使用从 0 开始的偏移量。所以对于一月，您使用 0，对于二月使用 1，依此类推。

这并不特别直观。在新日期时间 API 中，所有内容都是从 1 开始的。所以 1 表示一月，2 表示二月，依此类推。就像您通常期望的那样。

我将再次使用系统输出，这次我将输出新的特定日期。当我保存并运行它时，我将获得我输入的值，2000 年 1 月 1 日。

LocalDate specificDate = LocalDate.of(2016,1,1);
System.out.println(specificDate);

结果

2016-01-01

如果您只想表示一个时间值，请使用 LocalTime 类。我将输入类名并导入它。我将对象命名为 currentTime，并从 LocalTime.now 获取其值。

同样，使用与 localdate 和 instant 相同的语法。然后我将使用系统输出。我将输出当前时间。时间的默认值是 24 小时制，显示小时、分钟、秒和毫秒。

LocalTime currentTime = LocalTime.now();
System.out.println(currentTime);

结果

01:18:11.779

我将使用 LocalTime。我将把它命名为 specificTime。并且，就像 localdate 类一样，我将调用名为 of 的方法。同样，有许多不同版本接受不同数量的参数。

我将使用查找三个整数值的版本，并输入 14、0 和 45。然后我将把该值输出到控制台。结果出来了。14 点，00 分，45 秒。请注意，因为我没有提供毫秒值，所以时间的格式化版本不显示小数点后的值。

LocalTime specificTime = LocalTime.of(14,0,45);
System.out.println(specificTime);

结果

14:00:45

最后，我将展示如何使用 LocalDateTime 类。

我将输入类名并导入它。我将把这个对象命名为 currentDT。我将从 LocalDateTime.now 获取其值。当您输出日期时间值时，您将获得一个长格式的 ISO 日期时间。以日期开始，以时间结束。如果值中有毫秒，它们将被显示。最后，我将创建一个特定的日期和时间，通过组合我特定的日期和我的特定时间来完成。

代码将如下所示。我将创建一个 LocalDateTime 对象。我将把它命名为 specificDT，我将再次调用 LocalDateTime.of。这次，我将使用这个第一个接受本地 date 对象和本地 time 对象的方法。您也可以从年、月、日和时间值的组合中构造您的 date time 值。我将传入我的特定 date 和我的特定 time。然后，我将把它输出到控制台。当我运行该代码时，我的特定 date time 是我的特定 date 和我的特定 time 的组合。

LocalDateTime currentDT = LocalDateTime.now();
System.out.println(currentDT);
 
LocalDateTime specificDT = LocalDateTime.of(specificDate, specificTime);
System.out.println(specificDT);

结果

2016-08-06T01:30:46.625
2016-01-01T14:00:45

结论

所以，这些是可以在当前时区中的本地机器上表示 date 和 time 值的三个类。还有一些类可用于获取时区敏感值。我将在下一步进行介绍。

3. 格式化日期和时间值

引言

我之前描述了如何使用 LocalDate、LocalTime 和 LocalDateTime 类来表示 time 值。要将此信息呈现给用户，您需要对其进行格式化。为此，有一个名为 DateTimeFormatter 的新类。我将向您展示如何使用一些简单的语法创建格式化器。然后介绍如何使用一个名为 Daytime Formatter Builder 的类进行非常自定义的工作。

工作原理

我正在 Java8Features 项目的 eg.com.tm.java8.features.datetime.format 包中工作。在一个名为 DateTimeFormater 的类代码中，带有一个 main 方法。

首先，我将创建一个 date。我将给它一个 LocalDate 类型，确保导入该类。我将它命名为 currentDate。我将从 LocalDate.now 获取其值。接下来，我将创建一个 formatter 对象。我将输入类名 DateTimeFormatter，并从 java.time.format 包中选择它。我将这个对象命名为 df。现在有几种创建格式化器的方法。最简单的方法之一是使用 DateTimeFormatter 类的一个常量。

我将再次输入 DateTimeFormatter。然后，在我输入句点后，我将看到所有可用常量的列表。我将选择 ISO Date。这将为此对象提供默认格式。然后，我将使用 System Output。我将调用格式化对象的 format 方法，并传入 date 对象。这是结果。我以年-月-日格式输出该值，其中月份和日期都填充为两个字符。

package eg.com.tm.java8.features.datetime.format;
 
import static java.time.LocalDate.*;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
/**
 *
 * @author mohamed_taman
 */
public class DateTimeFormater {
 
    public static void main(String[] args) {
 
        LocalDate currentDate = LocalDate.now();
        DateTimeFormatter df = DateTimeFormatter.ISO_DATE;
 
        System.out.println(df.format(currentDate));
    }
}

结果

2016-08-06

我现在可以对时间进行相同的操作。我将复制上面的代码块两次并进行一些更改。在第二个版本中，我将类型从 local date 更改为 local time。对象名称更改为 current time，我使用的类名更改为 local time。我将日期时间格式化器的名称从 DF 更改为 TF（表示时间格式化器）。我将更改使用的常量为 ISO Time。然后，我将更改我格式化的对象。我将确保导入 LocalTime 类。

然后，我将对第三个版本进行类似的更改。这次我将处理的类是 LocalDateTime。我将确保导入它。我将这个对象命名为 current DT。我将更改调用 now 方法的类。我将格式化器更改为 DTF（表示 DateTimeFormatter）。我将常量更改为 ISO Date Time。然后我将格式化 current DT 对象。我将确保在代码的每个版本中使用正确的格式化器。我将保存更改并运行代码。

public static void main(String[] args) {
 
    LocalDate currentDate = LocalDate.now();
    DateTimeFormatter df = DateTimeFormatter.ISO_DATE;
    System.out.println(df.format(currentDate));
     
    LocalTime currentTime = LocalTime.now();
    DateTimeFormatter dt = DateTimeFormatter.ISO_TIME;
    System.out.println(dt.format(currentTime));
     
    LocalDateTime currentDT = LocalDateTime.now();
    DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE_TIME;
    System.out.println(dtf.format(currentDT));
}

这是三个格式化后的值。到目前为止，我并没有真正完成太多工作，因为我使用了表示默认格式的常量。但是，让我们看看一些可用的自定义格式。

结果

2016-08-09
20:37:11.535
2016-08-09T20:37:11.538

我向下滚动到现有代码下方。我将创建另一个 DateTimeFormatter，我将把它命名为 f_long（表示长日期格式），并通过调用 DateTimeFormatter 类的一个名为 Localised Date 的方法来获取其值。

请注意，有用于日期、时间和日期时间的方法，带有各种参数。我将选择这个，Localized date，并传入一个名为 FormatStyle 的类的常量。请确保导入此类。然后，在我输入句点后，您会看到有四个可用常量：full、long、medium 和 short。我将选择 long 版本，然后通过调用 F_long.format 并传入 current DT 对象来输出格式化的日期。

DateTimeFormatter f_long = DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG);
System.out.println(f_long.format(currentDT));

当我运行此代码时，我将获得 date 的 long 版本。

结果

August 9, 2016

我将通过复制这两行代码向您展示此的另一个版本，对于此版本，我将格式化器名称更改为 f_short，使用的常量也更改为 short。我将更改调用的格式化器的名称。因此，长版本是拼写的月份名称。日期后有一个逗号，然后是四位数的年份。短版本（至少对于当前区域设置）是月份和日期，没有填充，用斜杠分隔值，以及两位数的年份。

DateTimeFormatter f_short = DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT);
System.out.println(f_short.format(currentDT));

结果

8/9/16

接下来，我将向您展示如何使用区域设置。我将创建两个字符串。第一个将称为 fr_short（表示法语，短格式）。要获取该值，我将调用我的 f_short 格式化器，然后我将调用名为 withLocal() 的方法。要获取区域设置值，我将使用 Local 类，这是一个已存在的类，在以前的 Java 版本中可用。它是 Java.util 包的成员。

然后，我可以调用许多代表各种区域设置的常量之一。我将使用法语。然后，我将调用 format 方法，并传入当前日期时间。

我将复制那行代码，对于这个版本，我将使用 fr_long。我将使用长格式化器，其他代码将与之前相同。然后，我将输出这两个值 fr_short 和 fr_long。

String fr_short = f_short.withLocale(Locale.FRENCH).format(currentDT);
   String fr_long  = f_long.withLocale(Locale.FRENCH).format(currentDT);
    
   System.out.println(fr_short);
   System.out.println(fr_long);

这是结果。请注意，对于 fr_short，月份和日期与美国版本相反。这是因为在欧洲，日期先说，然后是月份，然后是年份。当我使用长版本时，我得到用法语拼写的月份。

结果

09/08/16
9 août 2016

最后，我将向您展示如何使用一个名为日期时间格式化器生成器（date time formatter builder）的类来构建完全自定义的格式化器。它使用建造者设计模式，您可以通过调用多个方法，每个方法都返回当前生成器的一个实例。

我将输入类名并确保它已被导入。我将对象命名为 b。我将使用 new 关键字和构造方法来实例化它。

现在，在代码的末尾，我不会放分号，因为我想立即调用一系列方法来从头开始构建格式化器。我将从一个名为 Append Value 的方法开始。请注意，有 Append Instant、Append Literal、Append Localized 等等。我将调用一个名为 appendValue() 的方法，该方法接受一个名为 TemporalField 的类的实例，然后我将使用一个名为 ChronoField 的枚举，它扩展自 TemporalField。

然后我将使用一个名为 month of year 的常量。接下来，我将追加一个字面量。这可以是任何字符或任何字符串。为了使其独一无二，我将放入一对管道字符。现在我将复制这两行代码，为第二个版本，我将使用 day of month 而不是 month of year。请注意，还有 day of week 和 day of year。然后我将复制那行代码并将其移下。我将用 ChronoField.year 结束表达式。

一旦创建了生成器对象，您就可以获取格式化器。我将创建一个新对象，类型为 DateTimeFormatter。我将它命名为 f（表示 Formatter）。并调用生成器对象的 to formatter 方法，然后最后，我将格式化当前日期时间值。我将使用系统输出并调用 f.format()，并传入 currentDT。

DateTimeFormatterBuilder b = new DateTimeFormatterBuilder()
               .appendValue(ChronoField.DAY_OF_YEAR)
               .appendLiteral("||")
               .appendValue(ChronoField.DAY_OF_MONTH)
               .appendLiteral("||")
               .appendValue(ChronoField.YEAR);
        
DateTimeFormatter f = b.toFormatter();
System.out.println(f.format(currentDT));

现在，当我运行我的代码时，我将获得完全自定义的格式。

结果

222||9||2016

结论

您可以使用 DateTimeFormatter 生成器来构建您喜欢的任何格式。而且因为它使用了建造者设计模式，所以创建和维护代码都很容易。

4. 支持时区偏移

引言

新的日期时间 API 提供了许多类，可以帮助您管理时区。创建相对于格林威治标准时间偏移一定小时数或特定位置的日期时间对象，并计算时区之间的差异。

工作原理

我正在 Java8Features 项目的 eg.com.tm.java8.features.datetime.zone 包中工作。在一个名为 TimeZones 的类代码中，带有一个 main 方法。

在我的 main 方法中，我创建了一个 DateTimeFormatter 和一个 LocalDateTime 对象。LocalDateTime 代表我系统上我时区中的当前日期和时间。我现在在中东，所以是埃及时间。

DateTimeFormatter dtf = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
LocalDateTime currentDT = LocalDateTime.now();
System.out.println(dtf.format(currentDT));

然后我将格式化后的值输出到控制台。我使用短格式输出值。在埃及表示法中，它是月、日和年。

结果

8/9/16 10:22 PM

为了表示基于时区的日期时间值，请使用 ZonedDateTime 类。与 LocalDateTime 一样，它是不可变的且线程安全的。我将输入类名，然后按 Control + Space 添加导入语句。我将对象命名为 gmt（表示格林威治标准时间）。

创建此对象有几种不同的方法。我将向您展示如何通过计算与格林威治标准时间的偏移来创建对象。我将再次使用 ZonedDateTime 类，在我输入句点后，我将看到有许多可用方法。我也可以再次调用 now() 来获取我所在区域的日期时间值。我可以调用 of() 方法，这些方法允许我进行各种计算。我可以解析字符串，但我将使用这个版本的 now 方法。我将传入 ZoneId 类的一个实例。

ZoneId 表示与格林威治标准时间偏移一定小时数。我将通过调用名为 ZoneId.of() 的方法来获取该值。我将传入一个字面量字符串“GMT+0”。这意味着，显示格林威治标准时间中的当前日期和时间值。

ZonedDateTime gmt = ZonedDateTime.now(ZoneId.of("GMT+0"));
System.out.println(dtf.format(gmt));

现在，我将复制将值输出到控制台的代码。我将把那个移到下面，我将把这个版本更改为输出 gmt。我将运行代码，这是结果。

结果

8/9/16 8:28 PM

我在中东埃及，现在格林威治标准时间比我这边早两个小时。

这是获取 ZonedDateTime 的另一种方法。假设您想获取纽约的 ZoneDateTime。有许多内置的字符串或常量，可以让您命名特定位置，您将获得该位置正确的 ZoneId，而无需自己进行计算。我将创建另一个 ZonedDateTime 对象，这次我将它命名为 ny（表示纽约），并通过调用 ZonedDateTime.now() 来获取其值，我将再次传入 ZoneId.of()，但这次我将传入字符串 America/New_York。

请确保将此字符串拼写得与您在此处看到的一模一样。我将创建一行代码来输出该值。我将保存更改并运行它。纽约位于东海岸时间，比太平洋时间早三个小时。

ZonedDateTime ny = ZonedDateTime.now(ZoneId.of("America/New_York"));
      System.out.println(dtf.format(ny));

结果

8/9/16 4:36 PM

要了解所有可用的字符串，您可以调用 ZoneId 类的一个名为 getAvailableZoneIds() 的方法。您将获得一个集合。我将输入 Set 并按 Control + Space，然后从 Java.util 中选择 set。

我将此集合中的项目通用类型设置为 String。我将集合命名为 zones。然后，我将调用 ZoneId.getAvailableZoneIds 方法。然后我将使用 forEach() 方法循环遍历字符串。然后我将传入一个Lambda表达式。这样我就可以依次处理每个项目。

Set<string> zones = ZoneId.getAvailableZoneIds();
zones.forEach(z -> System.out.println(z));</string>

结果

当我运行该代码时，我将看到所有可用的字符串。

Asia/Aden
America/Cuiaba
Etc/GMT+9
Etc/GMT+8
Africa/Nairobi
America/Marigot
Asia/Aqtau
Pacific/Kwajalein
America/El_Salvador
Asia/Pontianak
Africa/Cairo
Pacific/Pago_Pago
Africa/Mbabane
Asia/Kuching
Pacific/Honolulu
Pacific/Rarotonga
America/Guatemala
Australia/Hobart
Europe/London
America/Belize
America/Panama
Asia/Chungking
America/Managua
America/Indiana/Petersburg
Asia/Yerevan
Europe/Brussels
GMT
Europe/Warsaw
America/Chicago
Asia/Kashgar
Chile/Continental
Pacific/Yap
CET
Etc/GMT-1
Etc/GMT-0
Europe/Jersey
America/Tegucigalpa
Etc/GMT-5
Europe/Istanbul
America/Eirunepe
Etc/GMT-4
America/Miquelon
Etc/GMT-3
Europe/Luxembourg
Etc/GMT-2
Etc/GMT-9
America/Argentina/Catamarca
Etc/GMT-8
Etc/GMT-7
.................

现在，有太多了，可能很难找到您正在寻找的那个。所以，假设我想查找伦敦。

并使用该特定位置的时区，在一年中的这个时候。正如我在文章前面所展示的，我可以使用谓词来搜索字符串。我将创建一个谓词对象。我将通用类型设置为 String。我将对象命名为 condition。然后我将使用 lambda 表达式实现谓词。我将传入 str，然后我将用条件 str.contains 来实现谓词，并传入字符串 London。

然后我将重构我的 Lambda 表达式。我将用大括号括起 System.out.println()。然后我将展开代码，使其更容易使用。我将在 print line 的末尾添加分号，然后我将创建一个 if 语句。并将条件设置为 condition.test()，并传入 z 作为当前区域。我将把 println() 语句移到条件内部，这样我只会打印出匹配我的谓词测试的字符串。

Set<string> zones = ZoneId.getAvailableZoneIds();
Predicate<string> condition = str -> str.contains("London");
zones.forEach(z -> {
    if(condition.test(z))
    System.out.println(z);
});</string></string>

我将保存更改并运行代码，结果出来了。我发现伦敦的正确字符串是

结果

Europe/London

结论

所以，这是关于使用时区的一些内容。同样，请使用 ZonedDateTime 类而不是 LocalDateTime 来表示您可以修改和计算的值。ZoneId 表示与格林威治标准时间的偏移量。还有一个名为 Zone Offset 的类，您可以使用它来计算不同时区之间的差异。

资源

1. Java 教程，路径：日期时间
2. LocalDate API
3. JSR 310：日期和时间 API
4. JSR 337：Java SE 8 发布内容
5. OpenJDK 网站
6. Java Platform, Standard Edition 8, API 规范

希望您喜欢阅读这篇文章，就像我喜欢写作一样。如果您喜欢，请分享，传播出去。

历史

• 2016 年 8 月 14 日：初始版本

CodeProject