JDK8 日期，时间，日期时间

一，LocalDate基本使用

localDateTime常用API

方法名	说明
getYear、getMonthValue、getDayOfMonth、getDayOfYear getDayOfWeek、getHour、getMinute、getSecond、getNano	获取年月日、时分秒、纳秒等
withYear、withMonth、withDayOfMonth、withDayOfYear withHour、withMinute、withSecond、withNano	修改某个信息，返回新日期时间对象
plusYears、plusMonths、plusDays、plusWeeks plusHours、plusMinutes、plusSeconds、plusNanos	把某个信息加多少，返回新日期时间对象
minusYears、minusMonths、minusDays、minusWeeks minusHours、minusMinutes、minusSeconds、minusNanos	把某个信息减多少，返回新日期时间对象
equals isBefore isAfter	判断2个时间对象，是否相等，在前还是在后

1，特点

• JDK8日期时间对象都是不可变对象
  • 不可变对象：对象一旦创建不可修改，修改的话会创建另一个对象进行存储
  • 不可变对象就像文件的只读，如果想要修改只能另存为
  • 好处：可以保留最开始的信息

2，获取日期对象中的信息

获取年月日

LocalDate ld = LocalDate.now(); // 年 月 日  2023-11-13

int year = ld.getYear(); // 年 2023
int month = ld.getMonthValue(); // 月(1-12) 11
int day = ld.getDayOfMonth(); // 日 13 
int dayOfYear = ld.getDayOfYear();  // 一年中的第几天
int dayOfWeek = ld.getDayOfWeek().getValue(); // 星期几 3

3，修改某个信息JDK8一般是以with开头

 直接修改某个信息: withYear、withMonth、withDayOfMonth、withDayOfYear

// 0、获取本地日期对象(不可变对象)
LocalDate ld = LocalDate.now(); // 年 月 日  2023-11-13

LocalDate ld2 = ld.withYear(2099);    //2099-11-13
LocalDate ld3 = ld.withMonth(12);    //2023-12-13

 4，把某个信息加多少:

• plusYears、plusMonths、plusDays、plusWeeks

LocalDate ld4 = ld.plusYears(2);     //2025-11-13
LocalDate ld5 = ld.plusMonths(2);    //2024-1-13

 5，把某个信息减多少

• minusYears、minusMonths、minusDays、minusWeeks

LocalDate ld6 = ld.minusYears(2);
LocalDate ld7 = ld.minusMonths(2);

6， 获取指定日期的LocalDate对象：

• public static LocalDate of(int year, int month, int dayOfMonth)

LocalDate ld8 = LocalDate.of(2099, 12, 12);
LocalDate ld9 = LocalDate.of(2099, 12, 12);

7， 判断2个日期对象，是否相等，在前还是在后

• equals 是否相等 isBefore  在之前 isAfter 在之后    （返回值是true 和false）

System.out.println(ld8.equals(ld9));// true
System.out.println(ld8.isAfter(ld)); // true
System.out.println(ld8.isBefore(ld)); // false

二，LocalTime

public class Test2_LocalTime {
    public static void main(String[] args) {
        // 0、获取本地时间对象
        LocalTime lt = LocalTime.now(); // 时 分 秒 纳秒 不可变的
        System.out.println(lt);

        // 1、获取时间中的信息
        int hour = lt.getHour(); //时
        int minute = lt.getMinute(); //分
        int second = lt.getSecond(); //秒
        int nano = lt.getNano(); //纳秒

        // 2、修改时间：withHour、withMinute、withSecond、withNano
        LocalTime lt3 = lt.withHour(10);
        LocalTime lt4 = lt.withMinute(10);
        LocalTime lt5 = lt.withSecond(10);
        LocalTime lt6 = lt.withNano(10);

        // 3、加多少：plusHours、plusMinutes、plusSeconds、plusNanos
        LocalTime lt7 = lt.plusHours(10);
        LocalTime lt8 = lt.plusMinutes(10);
        LocalTime lt9 = lt.plusSeconds(10);
        LocalTime lt10 = lt.plusNanos(10);

        // 4、减多少：minusHours、minusMinutes、minusSeconds、minusNanos
        LocalTime lt11 = lt.minusHours(10);
        LocalTime lt12 = lt.minusMinutes(10);
        LocalTime lt13 = lt.minusSeconds(10);
        LocalTime lt14 = lt.minusNanos(10);

        // 5、获取指定时间的LocalTime对象：
        // public static LocalTime of(int hour, int minute, int second)
        LocalTime lt15 = LocalTime.of(12, 12, 12);
        LocalTime lt16 = LocalTime.of(12, 12, 12);

        // 6、判断2个时间对象，是否相等，在前还是在后： equals isBefore isAfter
        System.out.println(lt15.equals(lt16)); // true
        System.out.println(lt15.isAfter(lt)); // false
        System.out.println(lt15.isBefore(lt)); // true

    }
}

三，LocalDateTime类的基本使用

public class Test3_LocalDateTime {
    public static void main(String[] args) {
        // 0、获取本地日期和时间对象。
        LocalDateTime ldt = LocalDateTime.now(); // 年 月 日 时 分 秒 纳秒
        System.out.println(ldt);

        // 1、可以获取日期和时间的全部信息
        int year = ldt.getYear(); // 年
        int month = ldt.getMonthValue(); // 月
        int day = ldt.getDayOfMonth(); // 日
        int dayOfYear = ldt.getDayOfYear();  // 一年中的第几天
        int dayOfWeek = ldt.getDayOfWeek().getValue();  // 获取是周几
        int hour = ldt.getHour(); //时
        int minute = ldt.getMinute(); //分
        int second = ldt.getSecond(); //秒
        int nano = ldt.getNano(); //纳秒

        // 2、修改时间信息：
        // withYear withMonth withDayOfMonth withDayOfYear withHour
        // withMinute withSecond withNano
        LocalDateTime ldt2 = ldt.withYear(2029);
        LocalDateTime ldt3 = ldt.withMinute(59);

        // 3、加多少:
        // plusYears  plusMonths plusDays plusWeeks plusHours plusMinutes plusSeconds plusNanos
        LocalDateTime ldt4 = ldt.plusYears(2);
        LocalDateTime ldt5 = ldt.plusMinutes(3);

        // 4、减多少：
        // minusDays minusYears minusMonths minusWeeks minusHours minusMinutes minusSeconds minusNanos
        LocalDateTime ldt6 = ldt.minusYears(2);
        LocalDateTime ldt7 = ldt.minusMinutes(3);


        // 5、获取指定日期和时间的LocalDateTime对象：
        // public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour,
        //                                  int minute, int second, int nanoOfSecond)
        LocalDateTime ldt8 = LocalDateTime.of(2029, 12, 12, 12, 12, 12, 1222);
        LocalDateTime ldt9 = LocalDateTime.of(2029, 12, 12, 12, 12, 12, 1222);

        // 6、 判断2个日期、时间对象，是否相等，在前还是在后： equals、isBefore、isAfter
        System.out.println(ldt9.equals(ldt8));
        System.out.println(ldt9.isAfter(ldt));
        System.out.println(ldt9.isBefore(ldt));

        // 7、可以把LocalDateTime转换成LocalDate和LocalTime
        // public LocalDate toLocalDate()
        // public LocalTime toLocalTime()
        // public static LocalDateTime of(LocalDate date, LocalTime time)
        LocalDate ld = ldt.toLocalDate();
        LocalTime lt = ldt.toLocalTime();
        LocalDateTime ldt10 = LocalDateTime.of(ld, lt);

    }
}

四，DK8日期（时区）

1，ZoneId的常见方法：

• 获取系统默认的时区

ZoneId zoneId = ZoneId.systemDefault();

System.out.println(zoneId.getId());    //这两个结果是一样的
System.out.println(zoneId);    //这两个结果是一样的

• 获取Java支持的全部时区Id

ZoneId.getAvailableZoneIds()

• 获取某个时区的ZonedDateTime对象。

ZonedDateTime now = ZonedDateTime.now(zoneId1);

• 世界标准时间

ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());

• 获取系统默认时区的ZonedDateTime对象

  • 可以使用plus with minus等函数

ZonedDateTime now2 = ZonedDateTime.now();    //2022-12-xxxxxxxxxxx

2，Instant类

• 通过获取Instant的对象可以拿到此刻的时间，该时间由两部分组成：从1970-01-01 00:00:00 开始走到此刻的总秒数+不够1秒的纳秒数。

方法名	说明
public static Instant now​()	获取当前时间的Instant对象（标准时间）
public long getEpochSecond()	获取从1970-01-01T00：00：00开始记录的秒数。
public int getNano()	从时间线开始，获取从第二个开始的纳秒数
plusMillis plusSeconds plusNanos	判断系列的方法
minusMillis minusSeconds minusNanos	减少时间系列的方法
equals、isBefore、isAfter	增加时间系列的方法

3,DateTimeFormater日期格式化器

• 为什么不使用SimpleDateFormat 线程不安全 
  • 在一个系统中如果很多用户同时使用同一个SimpleDateFormat对象容易造成bug，如果不想造成bug则需要每个用户都创建一个对象这样会浪费内存。
• DataTimeFormater

方法名

public static DateTimeFormatter ofPattern(时间格式)

public String format(时间对象)

LocalDateTime提供的格式化、解析时间的方法

方法名	说明
public String format(DateTimeFormatter formatter)	格式化时间
public static LocalDateTime parse(时间字符串, DateTimeFormatter formatter)	解析时间

一），创建格式化器

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

二，格式化时间

// 1、创建一个日期时间格式化器对象出来。
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

// 2、对时间进行格式化
LocalDateTime now = LocalDateTime.now();
System.out.println(now);

String rs = formatter.format(now); // 正向格式化
System.out.println(rs);

// 3、格式化时间，其实还有一种方案。
String rs2 = now.format(formatter); // 反向格式化
System.out.println(rs2);

// 4、解析时间：解析时间一般使用LocalDateTime提供的解析方法来解析。
String dateStr = "2029年12月12日 12:12:11";
LocalDateTime ldt = LocalDateTime.parse(dateStr, formatter);
System.out.println(ldt);

2，Period类

计算两个LocalData对象间隔的年，月，日

public static Period between(LocalDate start, LocalDate end)	传入2个日期对象，得到Period对象
public int getYears()	计算隔几年，并返回
public int getMonths()	计算隔几个月，年返回
public int getDays()	计算隔多少天，并返回

3,Duration类

可以用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数；支持LocalTime、LocalDateTime、Instant等时间格式

方法名	说明
public static Duration between(开始时间对象1,截止时间对象2)	传入2个时间对象，得到Duration对象
public long toDays()	计算隔多少天，并返回
public long toHours()	计算隔多少小时，并返回
public long toMinutes()	计算隔多少分，并返回
public long toSeconds()	计算隔多少秒，并返回
public long toMillis()	计算隔多少毫秒，并返回
public long toNanos()	计算隔多少纳秒，并返回

public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2025, 11, 11, 11, 10, 10);
        LocalDateTime end = LocalDateTime.of(2025, 11, 11, 11, 11, 11);
        // 1、得到Duration对象
        Duration duration = Duration.between(start, end);

        // 2、获取两个时间对象间隔的信息
        System.out.println(duration.toDays());// 间隔多少天
        System.out.println(duration.toHours());// 间隔多少小时
        System.out.println(duration.toMinutes());// 间隔多少分
        System.out.println(duration.toSeconds());// 间隔多少秒
        System.out.println(duration.toMillis());// 间隔多少毫秒
        System.out.println(duration.toNanos());// 间隔多少纳秒

}

2

3