Java JDK8 时间 API 详解：核心类、格式化与计算

3. 代码示例

import java.time.ZoneId;
import java.util.Set;

public class ZoneIdDemo {
    public static void main(String[] args) {
        // 1. 获取系统默认时区（国内通常是 Asia/Shanghai）
        ZoneId defaultZone = ZoneId.systemDefault();
        System.out.println("系统默认时区：" + defaultZone);

        // 2. 获取指定时区
        ZoneId shanghaiZone = ZoneId.of("Asia/Shanghai");
        ZoneId tokyoZone = ZoneId.of("Asia/Tokyo");

        // 3. 查看所有支持的时区（约 600 个）
        Set<String> allZones = ZoneId.getAvailableZoneIds();
        System.out.println("Java 支持的时区总数：" + allZones.size());
    }
}

三、Instant 时间戳类 ⚡

1. 核心作用

表示时间线上的一个瞬时点，对应 JDK7 的 Date 类，底层存储的是从 1970-01-01 00:00:00 UTC 开始的毫秒/纳秒数。

2. 常用方法

3. 代码示例

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class InstantDemo {
    public static void main(String[] args) {
        // 1. 获取当前 UTC 时间戳
        Instant nowInstant = Instant.now();
        System.out.println("当前 UTC 时间戳：" + nowInstant);

        // 2. 根据毫秒值构建（0 毫秒对应 1970-01-01 00:00:00 UTC）
        Instant zeroInstant = Instant.ofEpochMilli(0L);
        System.out.println("0 毫秒对应的时间戳：" + zeroInstant);

        // 3. 为时间戳绑定时区（转换为带时区的时间）
        ZonedDateTime shanghaiTime = nowInstant.atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println("上海时区的当前时间：" + shanghaiTime);

        // 4. 时间比较
        Instant oneSecond = Instant.ofEpochSecond(1L);
        boolean isBefore = zeroInstant.isBefore(oneSecond); // true
        boolean isAfter = zeroInstant.isAfter(oneSecond); // false
        System.out.println("0 秒是否在 1 秒之前：" + isBefore);

        // 5. 时间加减
        Instant addInstant = zeroInstant.plusSeconds(3600); // 加 1 小时
        System.out.println("加 1 小时后的时间：" + addInstant);
    }
}

四、ZonedDateTime 带时区时间 🕒

1. 核心特点

• 包含完整的'日期 + 时间 + 时区'信息，是 Instant + ZoneId 的组合体
• 不可变对象：修改时间会返回新的对象，原对象保持不变
• 方法语义化，操作更直观

2. 常用方法

3. 代码示例

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class ZonedDateTimeDemo {
    public static void main(String[] args) {
        // 1. 获取当前带时区时间
        ZonedDateTime nowZoned = ZonedDateTime.now();
        System.out.println("当前带时区时间：" + nowZoned);

        // 2. 指定时间创建
        ZonedDateTime customTime = ZonedDateTime.of(2026, 10, 1,
                11, 11, 11, 0,
                ZoneId.of("Asia/Shanghai"));
        System.out.println("指定的上海时间：" + customTime);

        // 3. 通过 Instant+ 时区创建
        Instant instant = Instant.ofEpochMilli(0L);
        ZonedDateTime zeroZoned = ZonedDateTime.ofInstant(instant, ZoneId.of("Asia/Shanghai"));
        System.out.println("0 毫秒对应的上海时间：" + zeroZoned);

        // 4. 修改时间（返回新对象，原对象不变）
        ZonedDateTime modifyYear = customTime.withYear(2025);
        ZonedDateTime minusMonth = modifyYear.minusMonths(1);
        System.out.println("修改并减 1 个月后的时间：" + minusMonth);
    }
}

五、DateTimeFormatter 格式化解析 ✨

1. 核心优势

替代 JDK7 的 SimpleDateFormat，解决了线程不安全的问题，是 JDK8 推荐的时间格式化工具。

2. 常用方法

3. 格式规则（与 SimpleDateFormat 一致）

常用格式模板：

• yyyy-MM-dd：仅日期（如 2026-02-20）
• HH:mm:ss：仅时间（如 15:30:45）
• yyyy-MM-dd HH:mm:ss：日期 + 时间（如 2026-02-20 15:30:45）

4. 代码示例

import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class DateTimeFormatterDemo {
    public static void main(String[] args) {
        // 1. 获取带时区的当前时间
        ZonedDateTime now = ZonedDateTime.now();

        // 2. 创建格式化器（指定格式）
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 3. 格式化时间（时间对象 → 字符串）
        String formatTime = formatter.format(now);
        System.out.println("格式化后的时间：" + formatTime);
    }
}

六、LocalDate / LocalTime / LocalDateTime 🌟

这三个类是 JDK8 时间 API 中日常开发使用频率最高的，按功能拆分，满足不同场景需求。

1. 功能分工

2. 通用核心方法

3. LocalDate 代码示例（最常用）

import java.time.LocalDate;
import java.time.DayOfWeek;

public class LocalDateDemo {
    public static void main(String[] args) {
        // 1. 获取当前日期
        LocalDate today = LocalDate.now();
        System.out.println("今天的日期：" + today);

        // 2. 指定日期创建
        LocalDate customDate = LocalDate.of(2026, 1, 1);
        System.out.println("指定日期：" + customDate);

        // 3. 获取日期字段
        int year = customDate.getYear(); // 2026
        int month = customDate.getMonthValue(); // 1（1-12，无需 +1）
        int day = customDate.getDayOfMonth(); // 1
        DayOfWeek week = customDate.getDayOfWeek(); // 星期几
        System.out.println(year + "年" + month + "月" + day + "日 星期" + week.getValue());

        // 4. 时间比较
        boolean isBefore = today.isBefore(customDate);
        System.out.println("今天是否在 2026-01-01 之前：" + isBefore);

        // 5. 时间修改与增减
        LocalDate modifyDate = customDate.withYear(2025); // 修改年
        LocalDate addDate = modifyDate.plusMonths(3); // 加 3 个月
        System.out.println("修改并加 3 个月后的日期：" + addDate);
    }
}

4. 类之间的相互转换

LocalDateTime 可以拆分为 LocalDate 和 LocalTime：

import java.time.LocalDateTime;

public class LocalConvertDemo {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();

        // LocalDateTime → LocalDate
        LocalDate date = now.toLocalDate();

        // LocalDateTime → LocalTime
        LocalTime time = now.toLocalTime();

        System.out.println("拆分出的日期：" + date);
        System.out.println("拆分出的时间：" + time);
    }
}

七、时间间隔计算：Period / Duration / ChronoUnit ⏳

日常开发中经常需要计算两个时间的间隔，JDK8 提供了三个工具类，满足不同粒度的需求。

1. Period —— 按'年、月、日'计算日期间隔

import java.time.LocalDate;
import java.time.Period;

public class PeriodDemo {
    public static void main(String[] args) {
        // 起始日期
        LocalDate start = LocalDate.of(2020, 1, 1);
        // 结束日期
        LocalDate end = LocalDate.now();

        // 计算间隔
        Period period = Period.between(start, end);
        System.out.println("年差：" + period.getYears());
        System.out.println("月差：" + period.getMonths());
        System.out.println("日差：" + period.getDays());
        System.out.println("总月数：" + period.toTotalMonths());
    }
}

2. Duration —— 按'时、分、秒、毫秒'计算时间间隔

import java.time.LocalDateTime;
import java.time.Duration;

public class DurationDemo {
    public static void main(String[] args) {
        // 起始时间
        LocalDateTime start = LocalDateTime.of(2020, 1, 1, 0, 0);
        // 结束时间
        LocalDateTime end = LocalDateTime.now();

        // 计算间隔
        Duration duration = Duration.between(start, end);
        System.out.println("天差：" + duration.toDays());
        System.out.println("小时差：" + duration.toHours());
        System.out.println("分钟差：" + duration.toMinutes());
        System.out.println("毫秒差：" + duration.toMillis());
    }
}

3. ChronoUnit —— 支持任意时间单位的间隔计算（最灵活）

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class ChronoUnitDemo {
    public static void main(String[] args) {
        // 起始时间
        LocalDateTime start = LocalDateTime.of(2007, 8, 13, 14, 0);
        // 结束时间
        LocalDateTime end = LocalDateTime.now();

        // 计算不同单位的间隔
        long years = ChronoUnit.YEARS.between(start, end);
        long months = ChronoUnit.MONTHS.between(start, end);
        long days = ChronoUnit.DAYS.between(start, end);
        long hours = ChronoUnit.HOURS.between(start, end);

        System.out.println("年差：" + years);
        System.out.println("月差：" + months);
        System.out.println("天差：" + days);
        System.out.println("小时差：" + hours);
    }
}

📌 本篇知识回顾

1. JDK8 时间类均为不可变对象，线程安全，修改/增减时间会返回新对象；
2. 高频核心类：LocalDate（年月日）、LocalTime（时分秒）、LocalDateTime（年月日时分秒）；
3. 格式化工具：DateTimeFormatter 替代 SimpleDateFormat，解决线程安全问题；
4. 时间间隔计算：Period（年月日）、Duration（时分秒）、ChronoUnit（任意单位）。