Java 时间类（中）：JDK8 全新时间 API 详解

Instant 时间戳类

Instant 代表时间线上的一个瞬时点，底层存储的是从 1970-01-01 00:00:00 UTC 开始的毫秒或纳秒数。它是所有时间操作的核心基准。

常用方法

• Instant.now()：获取当前 UTC 时间戳。
• Instant.ofEpochMilli(long) / ofEpochSecond(long)：根据数值构建。
• atZone(ZoneId zone)：为时间戳绑定时区。
• isBefore / isAfter：比较时间点先后。

代码示例

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
        System.out.println("0 秒是否在 1 秒之前：" + isBefore);

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

ZonedDateTime 带时区时间

这是最完整的日期时间表示，包含了'日期 + 时间 + 时区'信息。由于是不可变对象，任何修改操作都会返回新的实例，原对象保持不变。

常用方法

• ZonedDateTime.now()：获取当前带时区时间。
• ZonedDateTime.of(...)：通过参数直接创建。
• withYear(int) / plusYears(long)：修改或增减时间。

代码示例

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 格式化解析

JDK8 推荐使用 DateTimeFormatter 替代 SimpleDateFormat。前者是线程安全的，且设计更灵活。

格式规则

常用模板与旧版类似：

• yyyy-MM-dd：仅日期
• HH:mm:ss：仅时间
• yyyy-MM-dd HH:mm:ss：日期 + 时间

代码示例

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

这三个类是日常开发中使用频率最高的，按功能拆分，职责单一。

功能分工

通用核心方法

• XXX.now()：获取当前时间。
• getYear() / getMonthValue()：获取字段（月份 1-12）。
• plusDays(long) / minusHours(long)：增减时间。
• isBefore / isAfter：比较时间。

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();
        int month = customDate.getMonthValue();
        int day = customDate.getDayOfMonth();
        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);
        System.out.println("修改并加 3 个月后的日期：" + addDate);
    }
}

类之间的相互转换

LocalDateTime 可以拆分为日期和时间部分：

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 提供了三个工具类，分别针对不同粒度。

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());
    }
}

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());
    }
}

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（任意单位）。