Java 的时区处理主要涉及三个核心类/概念：

1. java.util.TimeZone: 表示时区，定义了某个时区与 UTC 之间的偏移量,以及夏令时规则。
2. java.util.Calendar: 代表一个特定的时间点（年、月、日、时、分、秒等）。Calendar 对象必须关联一个 TimeZone。
3. java.util.Date: 代表一个自“纪元”（epoch，即 1970-01-01 00:00:00 GMT）以来的毫秒数，它本身不包含时区信息,但它的打印和解析通常会受到系统默认时区的影响。

java.util.TimeZone (时区)

TimeZone 是时区处理的基础。

如何获取 TimeZone 对象？

// 1. 通过时区ID获取（推荐方式）
// 时区ID的格式为 "Area/City"，"Asia/Shanghai", "America/New_York"
TimeZone timeZoneShanghai = TimeZone.getTimeZone("Asia/Shanghai");
TimeZone timeZoneNewYork = TimeZone.getTimeZone("America/New_York");
// 2. 获取系统默认的时区
TimeZone defaultTimeZone = TimeZone.getDefault();
// 3. 获取所有可用的时区ID
String[] availableIDs = TimeZone.getAvailableIDs();
for (String id : availableIDs) {
    System.out.println(id);
}

TimeZone 的核心方法

• getID(): 获取时区的ID，"Asia/Shanghai"。
• getDisplayName(): 获取时区的显示名称，"中国标准时间" 或 "China Standard Time"。
• getRawOffset(): 获取该时区与 UTC 的固定偏移量（以毫秒为单位），这个值不包含夏令时的影响。
• getOffset(long date): 获取在指定日期下，该时区与 UTC 的实际偏移量（以毫秒为单位），这个值包含了夏令时的影响。
• inDaylightTime(Date date): 判断给定的日期在该时区是否处于夏令时期间。

import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
public class TimeZoneExample {
    public static void main(String[] args) {
        TimeZone tzShanghai = TimeZone.getTimeZone("Asia/Shanghai");
        TimeZone tzNewYork = TimeZone.getTimeZone("America/New_York");
        // 获取一个当前时间的 Date 对象
        Date now = new Date();
        System.out.println("上海时区 ID: " + tzShanghai.getID());
        System.out.println("上海时区显示名称: " + tzShanghai.getDisplayName());
        System.out.println("上海与 UTC 的固定偏移量 (ms): " + tzShanghai.getRawOffset()); // 永远是 +8小时
        System.out.println("上海与 UTC 的实际偏移量 (ms): " + tzShanghai.getOffset(now.getTime())); // 也是 +8小时，因为中国没有夏令时
        System.out.println("\n纽约时区 ID: " + tzNewYork.getID());
        System.out.println("纽约时区显示名称: " + tzNewYork.getDisplayName());
        System.out.println("纽约与 UTC 的固定偏移量 (ms): " + tzNewYork.getRawOffset()); // 冬令时是 -5小时
        System.out.println("纽约与 UTC 的实际偏移量 (ms): " + tzNewYork.getOffset(now.getTime())); // 可能是 -4小时 (夏令时) 或 -5小时 (冬令时)
        System.out.println("纽约当前是否处于夏令时: " + tzNewYork.inDaylightTime(now));
    }
}

java.util.Calendar 与时区

Calendar 对象在创建时就会关联一个 TimeZone，如果你没有显式指定，它会使用系统默认的 TimeZone。

创建带有特定时区的 Calendar

import java.util.Calendar;
import java.util.TimeZone;
public class CalendarTimeZoneExample {
    public static void main(String[] args) {
        // 创建一个代表“的日历，并显式设置时区为上海
        Calendar shanghaiCalendar = Calendar.getInstance(TimeZone.getTimeZone("Asia/Shanghai"));
        // 创建一个代表“的日历，并显式设置时区为纽约
        Calendar newYorkCalendar = Calendar.getInstance(TimeZone.getTimeZone("America/New_York"));
        System.out.println("上海时间 (时区: " + shanghaiCalendar.getTimeZone().getID() + "):");
        System.out.println("  年: " + shanghaiCalendar.get(Calendar.YEAR));
        System.out.println("  月: " + shanghaiCalendar.get(Calendar.MONTH)); // 0-11
        System.out.println("  日: " + shanghaiCalendar.get(Calendar.DAY_OF_MONTH));
        System.out.println("  时: " + shanghaiCalendar.get(Calendar.HOUR_OF_DAY));
        System.out.println("  分: " + shanghaiCalendar.get(Calendar.MINUTE));
        System.out.println("  秒: " + shanghaiCalendar.get(Calendar.SECOND));
        System.out.println("\n纽约时间 (时区: " + newYorkCalendar.getTimeZone().getID() + "):");
        System.out.println("  年: " + newYorkCalendar.get(Calendar.YEAR));
        System.out.println("  月: " + newYorkCalendar.get(Calendar.MONTH));
        System.out.println("  日: " + newYorkCalendar.get(Calendar.DAY_OF_MONTH));
        System.out.println("  时: " + newYorkCalendar.get(Calendar.HOUR_OF_DAY));
        System.out.println("  分: " + newYorkCalendar.get(Calendar.MINUTE));
        System.out.println("  秒: " + newYorkCalendar.get(Calendar.SECOND));
    }
}

重要提示：同一个 Date 对象，用不同时区的 Calendar 来解析，会得到完全不同的“本地时间”字段（年、月、日、时等）。

// 一个代表某个特定UTC时间的Date对象
Date utcDate = new Date(1672531200000L); // 2025-01-01 00:00:00 UTC
// 用上海时区解析
Calendar calShanghai = Calendar.getInstance(TimeZone.getTimeZone("Asia/Shanghai"));
calShanghai.setTime(utcDate);
System.out.println("上海时间: " + calShanghai.get(Calendar.YEAR) + "-" + (calShanghai.get(Calendar.MONTH)+1) + "-" + calShanghai.get(Calendar.DAY_OF_MONTH) + " " + calShanghai.get(Calendar.HOUR_OF_DAY) + ":00"); // 2025-1-1 08:00
// 用纽约时区解析
Calendar calNewYork = Calendar.getInstance(TimeZone.getTimeZone("America/New_York"));
calNewYork.setTime(utcDate);
System.out.println("纽约时间: " + calNewYork.get(Calendar.YEAR) + "-" + (calNewYork.get(Calendar.MONTH)+1) + "-" + calNewYork.get(Calendar.DAY_OF_MONTH) + " " + calNewYork.get(Calendar.HOUR_OF_DAY) + ":00"); // 2025-12-31 19:00 (冬令时)

java.util.Date 与时区

Date 对象本身是一个时间戳，它不存储时区信息,它只表示自纪元以来的毫秒数。

Date now = new Date(); // 这个 now 对象不关心是北京时间还是纽约时间，它只是一个数值

当你打印或格式化 Date 时，JVM 会使用系统默认的 TimeZone 来将其转换为可读的字符串，这就是 Date 时区问题的常见来源。

import java.util.Date;
import java.util.TimeZone;
public class DateTimeZoneExample {
    public static void main(String[] args) {
        Date now = new Date();
        // 修改系统默认时区
        TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
        System.out.println("系统默认时区设置为 'America/Los_Angeles' 后:");
        System.out.println("Date 对象的默认字符串表示: " + now); // 会按洛杉矶时间显示
        // 修改系统默认时区
        TimeZone.setDefault(TimeZone.getTimeZone("Asia/Tokyo"));
        System.out.println("\n系统默认时区设置为 'Asia/Tokyo' 后:");
        System.out.println("Date 对象的默认字符串表示: " + now); // 会按东京时间显示
    }
}

永远不要依赖 Date.toString() 的输出，因为它不可预测，依赖于系统环境，对于需要精确控制的应用，应避免使用 Date 的直接字符串表示。

最佳实践与 java.time (Java 8+)

java.util.Date 和 java.util.Calendar 是旧时代的产物，设计上有很多缺陷（Date 可变、时区处理混乱），自 Java 8 起，官方推荐使用全新的 java.time 包。

java.time 提供了更清晰、更强大、不可变的日期和时间 API。

java.time 中的时区

• ZonedDateTime: 带有时区信息的日期时间，是 java.time 中最完整的日期时间表示，类似于 Calendar。
• Instant: 代表 UTC 时间线上的一个瞬时点，类似于 java.util.Date，但它更精确（纳秒级）且不可变。
• ZoneId: java.time 中的时区表示，替代了 java.util.TimeZone。
• ZoneOffset: 代表与 UTC 的固定偏移量。

import java.time.*;
public class Java8TimeExample {
    public static void main(String[] args) {
        // 1. 获取 ZoneId
        ZoneId shanghaiZone = ZoneId.of("Asia/Shanghai");
        ZoneId newYorkZone = ZoneId.of("America/New_York");
        // 2. 使用 ZonedDateTime 获取不同时区的当前时间
        ZonedDateTime nowInShanghai = ZonedDateTime.now(shanghaiZone);
        ZonedDateTime nowInNewYork = ZonedDateTime.now(newYorkZone);
        System.out.println("上海当前时间: " + nowInShanghai);
        System.out.println("纽约当前时间: " + nowInNewYork);
        // 3. 从一个 Instant 转换到不同时区的 ZonedDateTime
        Instant instant = Instant.now(); // 获取当前 UTC 时间
        ZonedDateTime shanghaiTime = instant.atZone(shanghaiZone);
        ZonedDateTime newYorkTime = instant.atZone(newYorkZone);
        System.out.println("\n从 UTC 转换:");
        System.out.println("上海时间: " + shanghaiTime);
        System.out.println("纽约时间: " + newYorkTime);
        // 4. 时区转换
        // 假设你有一个上海时间，想把它转换成纽约时间
        ZonedDateTime aSpecificShanghaiTime = ZonedDateTime.of(2025, 10, 1, 12, 0, 0, 0, shanghaiZone);
        ZonedDateTime sameMomentInNewYork = aSpecificShanghaiTime.withZoneSameInstant(newYorkZone);
        System.out.println("\n时间点转换:");
        System.out.println("上海时间: " + aSpecificShanghaiTime);
        System.out.println("同一时刻的纽约时间: " + sameMomentInNewYork);
    }
}

java.time 的优势

1. 不可变性: 所有 java.time 类都是不可变的，线程安全,避免了多线程环境下的同步问题。
2. 清晰的 API: 设计非常直观，方法名清晰易懂（如 plusDays, withZoneSameInstant）。
3. 明确的时区处理: 时区是 API 的核心部分,而不是一个容易被忽略的属性。
4. 功能强大: 内置了日期计算、格式化、解析等丰富功能。

总结与建议

最终建议：

• 如果使用 Java 8 或更高版本：完全抛弃 java.util.Date 和 java.util.Calendar，请务必使用 java.time 包中的类来处理所有日期和时间相关的逻辑，这是现代 Java 开发的标准。
• 如果必须维护旧代码：了解 Date 和 Calendar 的时区行为至关重要。Date 是一个时间戳，Calendar 是带时区的本地时间解析器，在打印或比较时，要时刻注意系统默认时区的影响,并尽量显式地指定时区。