Retrieving Unix Time in Java – 用 Java 检索 Unix 时间

1. Overview

1.概述

The Unix time is the total number of seconds that have passed since 00:00:00 UTC on January 1, 1970. This point in time is named the Unix epoch. The Unix time helps to represent date and time in programming.

Unix时间是指自1970年1月1日00:00:00 UTC起经过的总秒数。这个时间点被命名为 Unix 纪元。Unix 时间有助于在编程中表示日期和时间。

In this tutorial, we’ll learn how to use the legacy Date API, Date Time API, and Joda-Time library to retrieve Unix time values in Java.

在本教程中，我们将学习如何使用传统的 Date API、Date Time API 和 Joda-Time 库在 Java 中检索 Unix 时间值。

2. Using the Legacy Date API

2.使用传统日期 API

The Date API provides a class named Date, which provides a method to get the current time. We can get the current Unix time by dividing the current time in milliseconds by 1000L.

Date API 提供了一个名为 Date 的类，该类提供了一个获取当前时间的方法。我们可以用当前时间（毫秒）除以 1000L 来获取当前的 Unix 时间。

Let’s see an example that uses the Date class to retrieve current Unix time:

让我们来看一个使用 Date 类检索当前 Unix 时间的示例：

@Test
void givenTimeUsingDateApi_whenConvertedToUnixTime_thenMatch() {
    Date date = new Date(2023 - 1900, 1, 15, 0, 0, 0);
    long expected = 1676419200;
    long actual = date.getTime() / 1000L;
    assertEquals(expected, actual);
}

Here, we create a new Date object and initialize it with a fixed date and time. Next, we invoke the getTime() on the Date object to get the time in milliseconds. Then, we divide the time in milliseconds by 1000L to get the Unix time.

在此，我们创建一个新的 Date 对象，并用固定的日期和时间对其进行初始化。接下来，我们调用 Date 对象上的 getTime() 来获取以毫秒为单位的时间。然后，我们用毫秒时间除以 1000L 得到 Unix 时间。

Notably, the standard Unix time timestamp is in seconds since epoch and not milliseconds.

值得注意的是，标准 Unix 时间戳的单位是秒，而不是毫秒。

Finally, we assert that the result is equal to the expected Unix time.

最后，我们断言结果等于预期的 Unix 时间。

3. Using the Date Time API

3.使用日期时间应用程序接口

The new Date Time API from Java 8 provides the LocalDate and Instant classes to manipulate date and time. We can get the current Unix time by invoking getEpochSecond() on the Instant object:

Java 8 中新的日期时间 API 提供了 LocalDate 和 Instant 类来操作日期和时间。我们可以通过调用 Instant 对象上的 getEpochSecond() 来获取当前的 Unix 时间：

@Test
void givenTimeUsingLocalDate_whenConvertedToUnixTime_thenMatch() {
    LocalDate date = LocalDate.of(2023, Month.FEBRUARY, 15);
    Instant instant = date.atStartOfDay().atZone(ZoneId.of("UTC")).toInstant();
    long expected = 1676419200;
    long actual = instant.getEpochSecond();
    assertEquals(expected, actual);
}

Here, we create a LocalDate object to represent a fixed time. Next, we pass the LocalDate object to the Instant object to indicate the start of a day.

在这里，我们创建一个 LocalDate 对象来表示一个固定的时间。接下来，我们将 LocalDate 对象传递给 Instant 对象，以表示一天的开始。

Furthermore, we invoke the getEpochSecond() on the Instant object to get the Unix time value of the specified time.

此外，我们还会调用 Instant 对象上的 getEpochSecond() 来获取指定时间的 Unix 时间值。

Finally, we assert that the return Unix time value is equal to the expected Unix time timestamp.

最后，我们断言返回的 Unix 时间值等于预期的 Unix 时间戳。

4. Using Joda-Time Library

4.使用 Joda-Time 库

The Joda-Time library provides a DateTime class to get the current time. After getting the current time, we can easily compute the Unix time. To use Joda Time, let’s add it’s dependency to the pom.xml:

Joda-Time 库提供了一个 DateTime 类来获取当前时间。获取当前时间后，我们可以轻松计算 Unix 时间。要使用 Joda Time，让我们将其 依赖关系添加到 pom.xml 中：

<dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.12.5</version>
</dependency>

Here’s an example code that uses the DateTime class from the Joda-Time library to retrieve a Unix time:

下面是一个使用 Joda-Time 库中的 DateTime 类来获取 Unix 时间的示例代码：

@Test
void givenTimeUsingJodaTime_whenConvertedToUnixTime_thenMatch() {
    DateTime dateTime = new DateTime(2023, 2, 15, 00, 00, 00, 0);
    long expected = 1676419200;
    long actual = dateTime.getMillis() / 1000L;
    assertEquals(expected, actual);
}

In the code above, we create an instance of DateTime with a fixed date and time and invoke the getMillis() method. Next, we divide it by 1000L to get the Unix time timestamp.

在上面的代码中，我们创建了一个具有固定日期和时间的 DateTime 实例，并调用了 getMillis() 方法。然后，我们将其除以 1000L 得到 Unix 时间的时间戳。

5. Avoiding the Year 2038 Problem

5.避免 2038 年问题

Typically, Unix time is stored in signed 32-bit integers in many systems and programming languages. However, the maximum value that can be stored in a 32-bit integer is 2 147 483 647.

在许多系统和编程语言中，Unix 时间通常以有符号的 32 位整数存储。不过，32 位整数可存储的最大值是 2 147 483 647。

This creates an issue for Unix time because, at 03:14:07 UTC on 19 January 2038, the Unix time value will reach its limit. The next seconds will roll over to a negative number which may cause faulty behavior in a system, application failures, crashes, and malfunction of a system.

这将给 Unix 时间带来问题，因为在 2038 年 1 月 19 日 03:14:07 UTC 时，Unix 时间值将达到极限。接下来的秒数将滚动为负数，这可能会导致系统行为错误、应用程序故障、崩溃和系统故障。

We can avoid this limitation by storing the Unix time in 64-bit long integers rather than 32-bit integers in Java.

我们可以将 Unix 时间存储为 64 位长整数，而不是 Java 中的 32 位整数，从而避免这一限制。

6. Conclusion

6.结论

In this article, we learned how to use the legacy Data API, the Date Time API, and the Joda-Time library to retrieve Unix time. Storing the Unix time value in 64-bit long integers avoids any limitations or overflow issues for future dates.

在本文中，我们学习了如何使用传统数据 API、日期时间 API 和 Joda-Time 库检索 Unix 时间。以 64 位长整数存储 Unix 时间值可避免未来日期的限制或溢出问题。

As always, the complete source code for the examples is available over on GitHub.

与往常一样，这些示例的完整源代码可在 GitHub 上获取。