时间戳转日期在Java中怎么实现？完整指南 – wiki基地

---

Java时间戳转日期完整指南：从传统API到现代java.time

时间戳（Timestamp）是计算机领域中表示时间的一种常见方式，通常是一个数字，代表自特定参考点（通常是Unix纪元，即1970年1月1日00:00:00 UTC）以来经过的秒数或毫秒数。在Java开发中，我们经常需要将这种数字形式的时间戳转换为人类可读的日期和时间格式，反之亦然。

Java提供了多种API来处理日期和时间，主要分为两类：

1. 传统API (Legacy API): 主要包括 java.util.Date, java.util.Calendar, 和 java.text.SimpleDateFormat。这些类在早期Java版本中广泛使用，但在设计上存在一些问题，如可变性、非线程安全（SimpleDateFormat）以及处理时区和夏令时较为复杂。
2. 现代API (java.time): 自Java 8引入，位于 java.time 包下。这是一套全新设计的API，提供了更好的可读性、可维护性和健壮性。它解决了传统API的许多痛点，是目前官方推荐的日期和时间处理方式。

本指南将详细介绍如何使用这两种API进行时间戳到日期的转换，并重点推荐现代API的使用。

理解时间戳

在深入代码之前，首先要明确你所处理的时间戳的单位。最常见的两种是：

• 毫秒级时间戳 (Milliseconds): 这是Java标准库（如 System.currentTimeMillis()）和许多系统默认使用的时间戳单位。它表示自Unix纪元以来经过的毫秒数。这是一个 long 类型的值。
• 秒级时间戳 (Seconds): 这是Unix/Linux系统中常用的时间戳单位，表示自Unix纪元以来经过的秒数。同样通常是 long 类型的值。

转换时，务必区分这两种单位，否则将导致错误的结果（差1000倍）。

方法一：使用现代java.time API (推荐)

java.time 包提供了丰富且易于使用的类来处理日期、时间、瞬间（Instant）、时长（Duration）等。对于时间戳转换，核心类是 Instant。Instant 代表时间线上的一个瞬间点，精确到纳秒，但不包含时区信息。

从时间戳到日期/时间对象的转换步骤通常是：

1. 将时间戳（毫秒或秒）转换为 Instant 对象。
2. 根据需要，将 Instant 转换为包含时区信息的日期/时间对象（如 ZonedDateTime）或不含时区信息的日期/时间对象（如 LocalDateTime）。
3. 如果需要特定格式的字符串输出，使用 DateTimeFormatter 进行格式化。

1.1 毫秒级时间戳转日期/时间

假设你有一个毫秒级时间戳 long timestampMillis。

步骤 1: 转换为 Instant

使用 Instant.ofEpochMilli() 方法：

“`java
long timestampMillis = 1678886400000L; // 例如：2023-03-15 08:00:00 UTC

Instant instant = Instant.ofEpochMilli(timestampMillis);
System.out.println(“Instant: ” + instant); // 输出如：2023-03-15T08:00:00Z (Z表示UTC)
“`

步骤 2: 转换为包含时区信息的日期/时间 (ZonedDateTime)

如果你想知道这个时间点在特定时区对应的具体日期和时间，可以使用 Instant 的 atZone() 方法，并指定一个 ZoneId。

“`java
// 获取系统默认时区
ZoneId defaultZone = ZoneId.systemDefault();
ZonedDateTime zonedDateTimeDefault = instant.atZone(defaultZone);
System.out.println(“ZonedDateTime (Default Zone): ” + zonedDateTimeDefault);
// 输出如：2023-03-15T16:00+08:00[Asia/Shanghai] (假设系统时区是上海)

// 指定特定时区，例如东八区 (Asia/Shanghai)
ZoneId shanghaiZone = ZoneId.of(“Asia/Shanghai”);
ZonedDateTime zonedDateTimeShanghai = instant.atZone(shanghaiZone);
System.out.println(“ZonedDateTime (Asia/Shanghai): ” + zonedDateTimeShanghai);
// 输出如：2023-03-15T16:00+08:00[Asia/Shanghai]

// 指定UTC时区
ZoneId utcZone = ZoneId.of(“UTC”);
ZonedDateTime zonedDateTimeUtc = instant.atZone(utcZone);
System.out.println(“ZonedDateTime (UTC): ” + zonedDateTimeUtc);
// 输出如：2023-03-15T08:00Z[UTC]
“`

ZonedDateTime 是处理时区的首选类，它完整地记录了时间点、时区和时区偏移量。

步骤 3: 转换为不含时区信息的日期/时间 (LocalDateTime)

如果你只需要日期和时间部分，而忽略时区，可以从 ZonedDateTime 中提取 LocalDateTime，或者直接从 Instant 通过指定时区转换为 LocalDateTime（虽然本质上也是先通过时区处理）。

“`java
// 从 ZonedDateTime 提取 LocalDateTime
LocalDateTime localDateTime = zonedDateTimeDefault.toLocalDateTime();
System.out.println(“LocalDateTime from ZonedDateTime: ” + localDateTime);
// 输出如：2023-03-15T16:00

// 更直接的方式：通过指定时区从 Instant 转换为 LocalDateTime
// 注意：这实际上是 Instant.atZone(zone).toLocalDateTime() 的简写
LocalDateTime localDateTimeDirect = LocalDateTime.ofInstant(instant, defaultZone);
System.out.println(“LocalDateTime direct from Instant: ” + localDateTimeDirect);
// 输出如：2023-03-15T16:00
“`

请注意，LocalDateTime 不包含时区信息。这意味着 2023-03-15T16:00 可以指代上海的下午4点，也可以指代纽约的下午4点，它们是不同的时间瞬间。只有结合时区，LocalDateTime 才能确定唯一的 Instant。因此，在涉及时间点比较或跨时区计算时，优先使用 Instant 或 ZonedDateTime。

步骤 4: 格式化输出

使用 DateTimeFormatter 将日期/时间对象格式化为字符串。

“`java
// 使用预定义的标准格式
DateTimeFormatter isoFormatter = DateTimeFormatter.ISO_DATE_TIME;
String formattedIso = zonedDateTimeDefault.format(isoFormatter);
System.out.println(“Formatted ISO: ” + formattedIso);
// 输出如：2023-03-15T16:00:00+08:00[Asia/Shanghai]

// 使用自定义格式
DateTimeFormatter customFormatter = DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”);
String formattedCustom = zonedDateTimeDefault.format(customFormatter);
System.out.println(“Formatted Custom: ” + formattedCustom);
// 输出如：2023-03-15 16:00:00

// 格式化 LocalDateTime
String formattedLocalDateTime = localDateTime.format(customFormatter);
System.out.println(“Formatted LocalDateTime: ” + formattedLocalDateTime);
// 输出如：2023-03-15 16:00:00

// 包含中文星期几等
DateTimeFormatter chineseFormatter = DateTimeFormatter.ofPattern(“yyyy年MM月dd日 HH:mm:ss E”, java.util.Locale.CHINA);
String formattedChinese = zonedDateTimeDefault.format(chineseFormatter);
System.out.println(“Formatted Chinese: ” + formattedChinese);
// 输出如：2023年03月15日 16:00:00 星期三
“`

DateTimeFormatter 是线程安全的，推荐使用。

1.2 秒级时间戳转日期/时间

如果你的时间戳是秒级的 long timestampSeconds，使用 Instant.ofEpochSecond() 方法。

“`java
long timestampSeconds = 1678886400L; // 例如：2023-03-15 08:00:00 UTC

Instant instantFromSeconds = Instant.ofEpochSecond(timestampSeconds);
System.out.println(“Instant from seconds: ” + instantFromSeconds); // 输出如：2023-03-15T08:00:00Z
“`

后续转换为 ZonedDateTime 或 LocalDateTime 以及格式化的步骤与毫秒级时间戳完全相同。

1.3 java.sql.Timestamp 转 java.time

java.sql.Timestamp 是JDBC API中用于数据库交互的类，它继承自 java.util.Date，但包含纳秒信息。在现代Java中，建议将 java.sql.Timestamp 转换为 java.time 对象进行处理。

java.sql.Timestamp 提供了一个方便的方法 toInstant()。

“`java
java.sql.Timestamp sqlTimestamp = new java.sql.Timestamp(1678886400000L); // 从毫秒创建

Instant instantFromSql = sqlTimestamp.toInstant();
System.out.println(“Instant from java.sql.Timestamp: ” + instantFromSql); // 输出如：2023-03-15T08:00:00Z
“`

得到 Instant 后，同样可以转换为 ZonedDateTime 或 LocalDateTime 并进行格式化。

1.4 处理字符串形式的时间戳

如果时间戳是以字符串形式给定的（例如从配置文件或JSON中读取），需要先将其解析为 long 类型。

“`java
String timestampString = “1678886400000”; // 毫秒级字符串

try {
long timestampMillisFromString = Long.parseLong(timestampString);
Instant instantFromString = Instant.ofEpochMilli(timestampMillisFromString);
ZonedDateTime zonedDateTimeFromString = instantFromString.atZone(ZoneId.systemDefault());
System.out.println(“ZonedDateTime from String timestamp: ” + zonedDateTimeFromString);
} catch (NumberFormatException e) {
System.err.println(“Invalid timestamp string format: ” + timestampString);
e.printStackTrace();
}
“`

如果时间戳是秒级字符串，使用 Instant.ofEpochSecond(Long.parseLong(timestampString)).

方法二：使用传统API (java.util.Date, java.util.Calendar, java.text.SimpleDateFormat)

尽管现代API更优，但在维护老代码或与只接受传统API的库交互时，了解传统API的使用仍然是必要的。

传统API的核心是 java.util.Date。Date 对象内部存储的是自Unix纪元以来的毫秒数。

2.1 毫秒级时间戳转 java.util.Date

这是最直接的转换。

“`java
long timestampMillis = 1678886400000L; // 毫秒级时间戳

java.util.Date date = new java.util.Date(timestampMillis);
System.out.println(“java.util.Date: ” + date);
// 默认输出格式受系统Locale和时区影响，如：Wed Mar 15 16:00:00 CST 2023
“`

2.2 秒级时间戳转 java.util.Date

需要先将秒转换为毫秒，即乘以 1000。注意要使用 long 类型的乘法，避免溢出。

“`java
long timestampSeconds = 1678886400L; // 秒级时间戳

java.util.Date dateFromSeconds = new java.util.Date(timestampSeconds * 1000L);
System.out.println(“java.util.Date from seconds: ” + dateFromSeconds);
// 默认输出格式如：Wed Mar 15 16:00:00 CST 2023
“`

2.3 格式化 java.util.Date

使用 java.text.SimpleDateFormat 将 Date 对象格式化为字符串。重要提示：SimpleDateFormat 是非线程安全的！ 在多线程环境中使用时，需要为每个线程创建一个实例，或者使用 ThreadLocal，或者使用线程安全的包装。

“`java
java.util.Date date = new java.util.Date(1678886400000L);

// 创建 SimpleDateFormat 对象，指定格式
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

// 设置时区 (可选，默认为系统默认时区)
// sdf.setTimeZone(java.util.TimeZone.getTimeZone(“UTC”));
// sdf.setTimeZone(java.util.TimeZone.getTimeZone(“Asia/Shanghai”));

String formattedDate = sdf.format(date);
System.out.println(“Formatted java.util.Date: ” + formattedDate);
// 输出如：2023-03-15 16:00:00 (取决于系统时区)

// 包含中文星期几
SimpleDateFormat sdfChinese = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss EEEE”, java.util.Locale.CHINA);
String formattedChineseDate = sdfChinese.format(date);
System.out.println(“Formatted java.util.Date Chinese: ” + formattedChineseDate);
// 输出如：2023年03月15日 16:00:00 星期三
“`

常见的日期格式模式字母：
* y: 年
* M: 月 (1-12)
* d: 月中的天 (1-31)
* H: 小时 (0-23)
* h: 小时 (1-12, AM/PM)
* m: 分钟 (0-59)
* s: 秒 (0-59)
* S: 毫秒
* E: 星期几 (短格式如 Wed，长格式如 Wednesday)
* a: AM/PM 标记
* Z: 时区偏移量 (如 +0800)
* X: ISO 8601 时区 (如 +08, Z)

2.4 java.sql.Timestamp 的处理

java.sql.Timestamp 继承自 java.util.Date，因此可以直接当作 java.util.Date 使用，包括用 SimpleDateFormat 格式化。

“`java
java.sql.Timestamp sqlTimestamp = new java.sql.Timestamp(1678886400000L);

SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss.SSS”);
String formattedSqlTimestamp = sdf.format(sqlTimestamp);
System.out.println(“Formatted java.sql.Timestamp: ” + formattedSqlTimestamp);
// 输出如：2023-03-15 16:00:00.000 (取决于系统时区)
“`

需要注意的是，java.sql.Timestamp 比 java.util.Date 精度更高（到纳秒），但 SimpleDateFormat 只能处理到毫秒。如果需要纳秒精度，应使用 java.time API (Instant 支持纳秒)。

2.5 java.util.Calendar 的使用

java.util.Calendar 是一个抽象基类，提供了日期和时间字段之间的转换以及对日期字段进行操作的方法。它可以从 Date 对象创建，也可以用来获取 Date 对象。虽然它不像 SimpleDateFormat 那样直接用于格式化，但它可以用于构建或解析日期，或进行日期字段的计算。

“`java
long timestampMillis = 1678886400000L;

java.util.Calendar calendar = java.util.Calendar.getInstance(); // 获取基于系统默认时区和Locale的Calendar
calendar.setTimeInMillis(timestampMillis); // 设置时间戳

// 从 Calendar 获取日期字段
int year = calendar.get(java.util.Calendar.YEAR);
int month = calendar.get(java.util.Calendar.MONTH); // 注意：月份是 0-11
int day = calendar.get(java.util.Calendar.DAY_OF_MONTH);
int hour = calendar.get(java.util.Calendar.HOUR_OF_DAY); // 24小时制
int minute = calendar.get(java.util.Calendar.MINUTE);
int second = calendar.get(java.util.Calendar.SECOND);

System.out.println(“From Calendar: ” + year + “-” + (month + 1) + “-” + day + ” ” + hour + “:” + minute + “:” + second);
// 输出如：From Calendar: 2023-3-15 16:0:0

// 从 Calendar 获取 Date 对象
java.util.Date dateFromCalendar = calendar.getTime();
System.out.println(“Date from Calendar: ” + dateFromCalendar);
“`

Calendar 的主要问题在于其复杂性和可变性，以及处理时区和夏令时的细微之处。

总结与最佳实践

特性/API	java.util.Date/Calendar/SimpleDateFormat (传统)	java.time (现代 Java 8+)
时间戳处理	new Date(long), Calendar.setTimeInMillis(long)	Instant.ofEpochMilli(long), Instant.ofEpochSecond(long)
时区处理	TimeZone, 复杂且易出错	ZoneId, ZonedDateTime, 清晰且健壮
格式化	SimpleDateFormat (非线程安全)	DateTimeFormatter (线程安全)
可变性	Date, Calendar 是可变的	大部分类 (如 Instant, ZonedDateTime) 是不可变的
线程安全	SimpleDateFormat 不是	大部分类 (如 DateTimeFormatter) 是线程安全的
精度	Date 到毫秒, Timestamp 到纳秒 (SimpleDateFormat 只能到毫秒)	Instant 等到纳秒, DateTimeFormatter 支持纳秒格式化
推荐程度	不推荐新代码使用，主要用于兼容旧系统	强烈推荐，是Java处理日期时间的标准

最佳实践：

1. 优先使用 java.time API: 对于新的开发项目，或者有机会重构旧代码时，毫不犹豫地选择 java.time 包中的类。它们设计更合理，使用更方便，而且线程安全。
2. 理解 Instant 和 ZonedDateTime 的区别: Instant 是时间线上的一个点（不带时区），而 ZonedDateTime 是带时区的特定时间点。在处理需要考虑用户所在时区的场景时，使用 ZonedDateTime。如果只是表示一个通用的时间点（如日志记录时间、事件发生时间），Instant 通常足够。
3. 正确处理时间戳单位: 务必确认时间戳是毫秒还是秒，并使用对应的方法 (ofEpochMilli 或 ofEpochSecond)。
4. 指定时区: 在将 Instant 转换为人类可读的日期/时间（如 ZonedDateTime 或 LocalDateTime for display）时，明确指定时区非常重要，避免依赖系统默认时区可能带来的问题。
5. DateTimeFormatter 的线程安全: 放心在多线程环境中共享同一个 DateTimeFormatter 实例。

总结代码示例 (使用现代API)

将毫秒级时间戳转换为系统默认时区下的日期时间字符串：

“`java
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class TimestampToDateExample {

public static void main(String[] args) {
    long timestampMillis = 1678886400000L; // 示例毫秒时间戳

    // 1. 转换为 Instant
    Instant instant = Instant.ofEpochMilli(timestampMillis);

    // 2. 转换为 ZonedDateTime (使用系统默认时区)
    ZoneId defaultZone = ZoneId.systemDefault();
    ZonedDateTime zonedDateTime = instant.atZone(defaultZone);

    // 3. 格式化输出
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    String formattedDateTime = zonedDateTime.format(formatter);

    System.out.println("Timestamp (millis): " + timestampMillis);
    System.out.println("Instant: " + instant);
    System.out.println("ZonedDateTime (" + defaultZone + "): " + zonedDateTime);
    System.out.println("Formatted Date/Time: " + formattedDateTime);

    System.out.println("\n--- Handling Seconds Timestamp ---");

    long timestampSeconds = 1678886400L; // 示例秒时间戳

    // 1. 转换为 Instant
    Instant instantFromSeconds = Instant.ofEpochSecond(timestampSeconds);

    // 2. 转换为 ZonedDateTime (使用指定时区，例如 UTC)
    ZoneId utcZone = ZoneId.of("UTC");
    ZonedDateTime zonedDateTimeUtc = instantFromSeconds.atZone(utcZone);

    // 3. 格式化输出
    DateTimeFormatter utcFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z"); // z表示时区缩写
    String formattedUtcDateTime = zonedDateTimeUtc.format(utcFormatter);

    System.out.println("Timestamp (seconds): " + timestampSeconds);
    System.out.println("Instant: " + instantFromSeconds);
    System.out.println("ZonedDateTime (" + utcZone + "): " + zonedDateTimeUtc);
    System.out.println("Formatted Date/Time: " + formattedUtcDateTime);
}

}
“`

通过本指南，你应该能够掌握在Java中将时间戳转换为日期/时间对象的各种方法，并理解不同API之间的优劣，从而选择最适合你场景的方案。强烈建议在新项目或重构时采用 java.time API。

---