Java之日期

快乐小王子 / 2024-08-23 / 原文

日期
- java.time的API （目前多用time）
- 一、LocalDate
  - 1. 基本用法
  - 2. 日期之间的转化
  - 3. LocalDateTime 计算
  - 4. 格式化日期
- 二、Instant
  - 1. 基本应用
  - 2. 常见方法
  - 3. 时间计算
  - 4. 时间转化
- 三、DateTimeFormatter 时间格式化
  - 1. 基本用法
  - 2. 各类时间格式化
- 四、ZonedDateTime
  - 1. 基本用法
  - 2. ZonedDateTime 与LocalDateTime 之间转化
  - 3. 时区转换
- 五、时间计算

日期

介绍：

理解日期、时间和时刻

理解时区的概念

理解夏令时，同一地区使用GMT/UTC和城市表示的时区可能导致时间不同

GTM-05:00

America/New_York

理解locale用来针对当地用户习惯格式化日期、时间、数字、货币等。

Java有两套日期和时间的API

java.util.since/Calendar
java.time

java.time的API （目前多用time）

一、LocalDate

1. 基本用法

/**
     * 常见基本的用法
     */
    public static void use() {

        LocalDate localDate = LocalDate.now(); // 获取当前日期
        LocalTime localTime = LocalTime.now(); // 获取当前时间
        LocalDateTime localDateTime = LocalDateTime.now(); // 获取当前日期和时间
        System.out.println(localDate); // 严格按照ISO 8601格式打印
        System.out.println(localTime); // 严格按照ISO 8601格式打印
        System.out.println(localDateTime); // 严格按照ISO 8601格式打印

    }

2. 日期之间的转化

  /**
     * 日期之间的转化
     */
    public static void transform() {
        //  方式一：toLocalDate  toLocalTime
        LocalDateTime dt = LocalDateTime.now();
        LocalDate localDate = dt.toLocalDate(); // 转化成当前日期
        LocalTime localTime = dt.toLocalTime(); // 转化成 当前时间
        System.out.println("localDate = " + localDate);
        System.out.println("localTime = " + localTime);

        // 方式二： 固定转换为时间
        LocalDate localDate1 = LocalDate.of(2023, 11, 1);
        LocalTime localTime1 = LocalTime.of(18, 11, 22);
        LocalDateTime localDateTime = LocalDateTime.of(2029, 1, 1, 1, 1, 1);


    }

3. LocalDateTime 计算

/**
     * LocalDateTime 计算
     */
    public static void timeCalculate() {
        //加时间
        LocalDateTime plus = LocalDateTime.now().plus(Duration.ofDays(1));
        LocalDateTime localDateTime = LocalDateTime.now().plusHours(1);
        System.out.println(localDateTime);
        System.out.println(plus);
        //时间减
        LocalDateTime minus = LocalDateTime.now().minus(Duration.ofDays(1));
        System.out.println(minus);
        LocalDateTime localDateTime1 = LocalDateTime.now().minusHours(1);
        System.out.println(localDateTime1);
        //获取当前时间，并且将小时设置为1
        LocalDateTime with = LocalDateTime.now().with(LocalTime.of(1, 1, 1));
        System.out.println(with);
        LocalDateTime localDateTime2 = LocalDateTime.now().withHour(1);
        System.out.println(localDateTime2);
    }

4. 格式化日期

 /**
     * 格式化 日期
     */
    private static void format() {

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
        String format = dateTimeFormatter.format(LocalDateTime.now());
        System.out.println(format);
        String format1 = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"));
        System.out.println(format1);

    }

二、Instant

1. 基本应用

 /**
     * 时间戳类 Instant 的基本应用
     */
    public static void instantUse() {

        Instant instant = Instant.now();
        System.out.println("秒 " + instant.getEpochSecond()); // 秒
        System.out.println("毫秒 " + instant.toEpochMilli()); // 毫秒
        System.out.println("时间戳： " + System.currentTimeMillis()); // 时间戳，毫秒


    }

2. 常见方法

 /**
     * 将时间秒级别的时间戳转化为时间
     * 使用方法： Instant.ofEpochSecond()
     * 将时间毫秒级别的时间戳转化为时间，使用 Instant.ofEpochMilli()
     * 转化思路：
     * 1. 先转化为 Instant 类
     * 2. instant 设置时区，转化为 ZonedDateTime
     * 3. 格式化输出 DateTimeFormatter
     *
     * @param time 传入时间戳，秒级别
     */
    public static void methods(long time) {

        Instant instant = Instant.ofEpochSecond(time);
        // Instant instant1 = Instant.ofEpochMilli(System.currentTimeMillis());
        ZonedDateTime zonedDateTime = instant.atZone(ZoneId.systemDefault());
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = dateTimeFormatter.format(zonedDateTime);
        System.out.println("当前时间为： " + format);

    }

3. 时间计算

 /**
     * 计算时间差
     */
    public static void timeCalculate() {

        Instant begin = Instant.now();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        Instant end = Instant.now();
        // 方式一：直接减
        long difference = (end.toEpochMilli() - begin.toEpochMilli()) / 1000;
        System.out.println("耗时：" + difference);
        // 方式二：使用 Duration
        Duration duration = Duration.between(begin, end);
        System.out.println("耗时：" + duration.toMillis() + "毫秒");

        // 方式三：使用内置方法
        long until = begin.until(end, ChronoUnit.MILLIS);
        System.out.println("耗时:" + until + "毫秒");
    }

4. 时间转化

 /**
     * localDateTime 与 instant 的转换
     */
    public static void transform() {
        //转化一：instant 转 localDateTime
        LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.now(), ZoneId.systemDefault());
        System.out.println(localDateTime);
        //转化二：localDateTime 转 instant
        Instant instant = localDateTime.toInstant(ZoneOffset.of("+8"));
        System.out.println(instant);
    }

三、DateTimeFormatter 时间格式化

1. 基本用法

  /**
     * 用法
     */
    public static void classUse() {

        // 方法一：创建DateTimeFormatter时，我们仍然通过传入格式化字符串实现：
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 方法二：另一种创建DateTimeFormatter的方法是，传入格式化字符串时，同时指定Locale：
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("E,yyyy-MM-dd HH:mm:ss", Locale.CHINA);

    }

2. 各类时间格式化

 /**
     * 各类时间格式化
     */
    public static void transform() {

        ZonedDateTime zonedDateTime = ZonedDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd 'T' HH:mm ZZZZ");
        System.out.println(formatter.format(zonedDateTime));

        DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy MM dd EE  HH:mm ", Locale.CHINA);
        System.out.println(formatter1.format(zonedDateTime));
        // 按照美国习惯，输出日期和时间：
        DateTimeFormatter formater2 = DateTimeFormatter.ofPattern("E, MMMM/dd/yyyy HH:mm", Locale.US);
        System.out.println(formater2.format(ZonedDateTime.now(Clock.system(ZoneId.of("America/New_York")))));

    }

四、ZonedDateTime

1. 基本用法

 /**
     * ZonedDateTime的简单使用
     * ZoneId.of("America/New_York") 指定时区
     */
    public static void zoneDateTimeUse() {

        ZonedDateTime zbj = ZonedDateTime.now();  // 默认时区,默认时当前时间的时区
        ZonedDateTime zny = ZonedDateTime.now(ZoneId.of("America/New_York")); // 用指定时区获取当前时间
        System.out.println(zbj);
        System.out.println(zny);
    }

2. ZonedDateTime 与LocalDateTime 之间转化

/**
     * ZonedDateTime 与LocalDateTime 之间转化
     * LocalDateTime 转化为ZonedDateTime 使用的是 atZone，然后在里面指定时区
     */
    public static void transform() {

        LocalDateTime ldt = LocalDateTime.now();
        ZonedDateTime zbj = ldt.atZone(ZoneId.systemDefault());
        ZonedDateTime zny = ldt.atZone(ZoneId.of("America/New_York"));
        System.out.println(zbj);
        System.out.println(zny);

        ZonedDateTime zbj1 = ZonedDateTime.now();
        System.out.println(zbj1);
        LocalDateTime ldt1 = zbj1.toLocalDateTime();
        System.out.println(ldt1);
    }

3. 时区转换

 public static void zoneTransform() {

        // 获取中国区的时间
        ZonedDateTime zbj = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
        // 获取纽约的时间
        ZonedDateTime zny = zbj.withZoneSameInstant(ZoneId.of("America/New_York"));
        System.out.println(zbj);
        System.out.println(zny);


    }

五、时间计算

一般时间的计算主要有：Duration 类， Period 类或 ChronoUnit.between 方法。甲持续时间测量使用基于时间的值（秒，毫微秒）的时间量。Period 使用基于日期的值（年，月，日）。

 /**
     * Duration类表示秒或纳秒时间间隔，适合处理较短的时间，需要更高的精确性。我们能使用between()方法比较两个瞬间的差
     *
     */
    public static void durationDemo() {

        Instant t1 = Instant.now();
        Instant t2 = Instant.now();
        // 计算差值，并且返回毫秒  between 可以传 LocalDateTime,instant 这两个值
        Duration duration = Duration.between(LocalDateTime.of(2021,1,1,0,0,0), LocalDateTime.now());
        System.out.println("耗时" + duration.toNanos() + "纳秒");
        System.out.println("耗时" + duration.toMillis() + "毫秒");
        System.out.println("耗时" + duration.toSeconds() + "秒");
        System.out.println("耗时" + duration.toMinutes() + "分钟");
        System.out.println("耗时" + duration.toHours() + "小时");
        System.out.println("耗时" + duration.toDays() + "天");

        //     时间计算
        //    时间增加
        Duration duration1 = duration.plusDays(1);
        System.out.println(duration1.toMillis());
        Duration duration2 = duration.plusHours(1);
        System.out.println(duration2.toMillis());

        Duration duration3 = duration.plusMinutes(1);
        System.out.println(duration3.toMillis());

        Duration duration4 = duration.plusSeconds(1);
        System.out.println(duration4.toMillis());

        Duration duration5 = duration.plusNanos(1);
        System.out.println(duration5.toMillis());

        //    时间减少
        Duration duration6 = duration.minusDays(1);
        System.out.println(duration6.toMillis());

        Duration duration7 = duration.minusHours(1);
        System.out.println(duration7.toMillis());

        Duration duration8 = duration.minusMillis(1);
        System.out.println(duration8.toMillis());

        Duration duration9 = duration.minusSeconds(1);
        System.out.println(duration9.toMillis());

        Duration duration10 = duration.minusNanos(1);
        System.out.println(duration10.toMillis());


    }

 /**
     * Period 类表示一段时间的年、月、日，开使用between()方法获取两个日期之间的差作为Period 对象返回：
     */
    public static void periodDemo() {

        LocalDate startDate = LocalDate.of(2015, 2, 20);
        LocalDate endDate = LocalDate.of(2017, 1, 15);
        //计算时间差值
        Period period = Period.between(startDate, endDate);
        System.out.println(period.getYears() + "年" + period.getMonths() + "月" + period.getDays() + "天");
        //    Period类型对象是基于年、月、日和周
        Period fromUnits = Period.of(3, 10, 10);

    }