• LocalDateTime用法

    一.背景

    本文主要介绍Java 8中时间的操作方法

    • java.util.Date是用于表示一个日期和时间的对象（注意与java.sql.Date区分，后者用在数据库中没有格式化的Date），它打印出的日期可读性差，可以使用SimpleDateFormat对时间进行格式化，但SimpleDateFormat又是线程不安全，包括format和parse方法，而在时间的计算方面不是很方便。
    • java.util.Canlendar 可以用于获取并设置年、月、日、时、分、秒，它和Date比，主要多了一个可以做简单的日期和时间运算的功能，Canlendar 变量是全局变量，会导致脏变量情况产生，并且这个共享变量没有做线程安全控制，也就是多线程的情况下是线程不安全的。
    • Java8出的新的时间日期API都是线程安全的比如LocalDate、LocalTime、LocalDateTime这三个类，计算功能强大，并且性能更好，代码更简洁。
    • 进行相关实例时，请先确保已安装JDK8，本文采用的版本是：jdk1.8.0_111

    二.简介 

    • LocalDate ：表示当前日期，相当于：yyyy-MM-dd
    • LocalTime ：表示当前时间，相当于：HH:mm:ss (24小时制) 或者 hh:mm:ss(12小时制)
    • LocalDateTime ：表示当前日期时间，相当于：yyyy-MM-ddTHH:mm:ss ,是前两者的结合
    • DateTimeFormatter ：表示格式化类型，可以取代SimpleDateFormat
    • Instant ：表示时刻，用来表示时间线上的一个点（瞬时），也可以说是时间戳
    • ZoneId、ZoneOffset ：表示时区
    • ZonedDateTime ：表示带时区的日期和时间，是前两者的结合
    • Duration ：表示两个时刻之间的时间间隔
    • Period ：表示两个日期之间的天数

    三.实战

    3.1 LocalDate的创建与使用

    3.1.1、LocalDate的创建

    1.     /**
    2.      * LocalDate的初始化方法
    3.      * 此处单元测试的注解是采用:org.junit.Test
    4.      */
    5.     @Test
    6.     public void init(){
    7.         //1.创建LocalDate,LocalDate对象直接调用now(),获取到当前日期
    8.         LocalDate localDateNow = LocalDate.now();
    9.         System.out.println("1.直接调用now()创建：" + localDateNow);
    10.         //2.直接根据（年月日）创建,如：2021-05-20
    11.         LocalDate localDateOf = LocalDate.of(2021, 5, 20);
    12.         System.out.println("2.根据年月日创建：" + localDateOf);
    13.         //3.直接根据某一年的某一天创建,如 2021年中第200天
    14.         LocalDate localDateOfYearDay = LocalDate.ofYearDay(2021, 200);
    15.         System.out.println("3.根据某一年的某一天创建：" + localDateOfYearDay);
    16.         //4.根据java.time.temporal.TemporalAccessor创建(包括LocalDate,LocalDateTime等等)
    17.         LocalDate localDateFrom = LocalDate.from(LocalDate.now());
    18.         System.out.println("4.根据TemporalAccessor创建：" + localDateFrom);
    19.         //5.根据时间字符串转化创建,调用parse(CharSequence text)方法,此方法只支持yyyy-MM-dd格式的值
    20.         LocalDate localDateParse = LocalDate.parse("2021-05-11");
    21.         System.out.println("5.根据时间字符串转化创建:" + localDateParse);
    22.         //6.根据时间字符串转化创建,调用parse(CharSequence text, DateTimeFormatter formatter)方法,此时的text可以根据formatter多变
    23.         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
    24.         LocalDate localDateParse2 = LocalDate.parse("20210515", formatter);
    25.         System.out.println("6.根据时间字符串转化创建:" + localDateParse2);
    26.     }
    27.

    运行结果：

    1. 1.直接调用now()创建：2021-05-24
    2. 2.根据年月日创建：2021-05-20
    3. 3.根据某一年的某一天创建：2021-07-19
    4. 4.根据TemporalAccessor创建：2021-05-24
    5. 5.根据时间字符串转化创建:2021-05-11
    6. 6.根据时间字符串转化创建:2021-05-15

    3.1.2、LocalDate的常见使用方法

    1.    /**
    2.      * LocalDate的常用使用方法
    3.      * 此处单元测试的注解是采用:org.junit.Test
    4.      */
    5.     @Test
    6.     public void usage() {
    7.         //此处采用LocalDate对象直接调用now(),获取到当前日期,注意：如果使用我的实例，结果会不一样，因为LocalDate.now()是调用时的日期
    8.         LocalDate currentDate = LocalDate.now();
    9.         //1.获取年、月、日、星期几、月中天、年中天、月数
    10.         System.out.println("------------------1.获取年、月、日、星期几、月中天、年中天、月数-----------------------");
    11.         System.out.println("1.获取到的当前日期：" + currentDate);
    12.         System.out.println("1.获取到的年：" + currentDate.getYear());
    13.         System.out.println("1.获取到的月：" + currentDate.getMonthValue());
    14.         System.out.println("1.获取到的一月中的哪一天：" + currentDate.getDayOfMonth());
    15.         System.out.println("1.获取到的一周中的星期几：" + currentDate.getDayOfWeek().getValue());
    16.         System.out.println("1.获取到的一年的第多少天：" + currentDate.getDayOfYear());
    17.         System.out.println("1.获取到的一年有多少天：" + currentDate.lengthOfYear());
    18.         System.out.println("1.获取到的一年有多少月：" + currentDate.lengthOfMonth());
    19.         //2.时间的计算
    20.         System.out.println("-----------------2.时间的计算,主要是加减法------------------------");
    21.         System.out.println("2.获取到的当前日期：" + currentDate);
    22.         System.out.println("2.加法，当前日期上加2年：" + currentDate.plusYears(2));
    23.         System.out.println("2.加法，当前日期上加3个月：" + currentDate.plusMonths(3));
    24.         System.out.println("2.加法，当前日期上加20天：" + currentDate.plusDays(20));
    25.         System.out.println("2.加法，当前日期上加一周：" + currentDate.plusWeeks(1));
    26.         System.out.println("2.减法，当前日期上减2年：" + currentDate.minusYears(2));
    27.         System.out.println("2.减法，当前日期上减3个月：" + currentDate.minusMonths(3));
    28.         System.out.println("2.减法，当前日期上减20天：" + currentDate.minusDays(20));
    29.         System.out.println("2.减法，当前日期上减一周：" + currentDate.minusWeeks(1));
    30.         //3.时间的判断及转化
    31.         System.out.println("-----------------3.时间的判断及格式化(格式化的类型很多)------------------------");
    32.         //新建一个格式化类型
    33.         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
    34.         //新创建一个LocalDate日期进行比较
    35.         LocalDate localDateOf = LocalDate.of(2020, 5, 20);
    36.         System.out.println("3.当前日期转成yyyyMMdd型的字符串：" + currentDate.format(formatter));
    37.         System.out.println("3.当前日期是否在一个日期之后：" + currentDate.isAfter(localDateOf));
    38.         System.out.println("3.当前日期是否在一个日期之前：" + currentDate.isBefore(localDateOf));
    39.         System.out.println("3.当前日期是否是闰年：" + currentDate.isLeapYear());
    40.         System.out.println("3.2020-05-20是否是闰年：" + localDateOf.isLeapYear());
    41.         //4.根据指定数据获取日期或者时间(LocalTime)
    42.         System.out.println("-----------------4.根据指定数据获取日期或者时间(LocalTime)------------------------");
    43.         System.out.println("4.获取到的当前日期：" + currentDate);
    44.         System.out.println("4.修改年数为1999年：" + currentDate.withYear(1999));
    45.         System.out.println("4.修改月数为10月：" + currentDate.withMonth(10));
    46.         System.out.println("4.修改天数为当月12日：" + currentDate.withDayOfMonth(12));
    47.         System.out.println("4.获取到的当前日期的开始时间：" + currentDate.atStartOfDay());
    48.         System.out.println("4.根据指定的时、分、秒获取时间：" + currentDate.atTime(12, 23, 45));
    49.         System.out.println("4.根据时间LocalTime对象获取时间：" + currentDate.atTime(LocalTime.now()));
    50.     }

    运行结果：

    1. ------------------1.获取年、月、日、星期几、月中天、年中天、月数-----------------------
    2. 1.获取到的当前日期：2021-05-24
    3. 1.获取到的年：2021
    4. 1.获取到的月：5
    5. 1.获取到的一月中的哪一天：24
    6. 1.获取到的一周中的星期几：1
    7. 1.获取到的一年的第多少天：144
    8. 1.获取到的一年有多少天：365
    9. 1.获取到的一年有多少月：31
    10. -----------------2.时间的计算,主要是加减法------------------------
    11. 2.获取到的当前日期：2021-05-24
    12. 2.加法，当前日期上加2年：2023-05-24
    13. 2.加法，当前日期上加3个月：2021-08-24
    14. 2.加法，当前日期上加20天：2021-06-13
    15. 2.加法，当前日期上加一周：2021-05-31
    16. 2.减法，当前日期上减2年：2019-05-24
    17. 2.减法，当前日期上减3个月：2021-02-24
    18. 2.减法，当前日期上减20天：2021-05-04
    19. 2.减法，当前日期上减一周：2021-05-17
    20. -----------------3.时间的判断及格式化(格式化的类型很多)------------------------
    21. 3.当前日期转成yyyyMMdd型的字符串：20210524
    22. 3.当前日期是否在一个日期之后：true
    23. 3.当前日期是否在一个日期之前：false
    24. 3.当前日期是否是闰年：false
    25. 3.2020-05-20是否是闰年：true
    26. -----------------4.根据指定数据获取日期或者时间(LocalTime)------------------------
    27. 4.获取到的当前日期：2021-05-24
    28. 4.修改年数为1999年：1999-05-24
    29. 4.修改月数为10月：2021-10-24
    30. 4.修改天数为当月12日：2021-05-12
    31. 4.获取到的当前日期的开始时间：2021-05-24T00:00
    32. 4.根据指定的时、分、秒获取时间：2021-05-24T12:23:45
    33. 4.根据时间LocalTime对象获取时间：2021-05-24T19:49:04.468

    3.2 LocalTime的创建与使用

    3.2.1、LocalTime创建

    1.     /**
    2.      * LocalTime的初始化方法
    3.      * 此处单元测试的注解是采用:org.junit.Test
    4.      */
    5.     @Test
    6.     public void init() {
    7.         //1.LocalTime,LocalTime对象直接调用now(),获取到当前时间
    8.         LocalTime now = LocalTime.now();
    9.         System.out.println("1.获取到的当前时间：" + now);
    10.         //2.根据指定的时分秒生成时间
    11.         LocalTime localTimeOf = LocalTime.of(23, 59, 59);
    12.         System.out.println("2.根据指定的时分秒生成时间：" + localTimeOf);
    13.         //3.根据指定的时分秒生成时间
    14.         LocalTime localTimeParse = LocalTime.parse("12:23:45");
    15.         System.out.println("3.根据指定的时分秒生成时间：" + localTimeParse);
    16.         //4.根据指定的时分秒和格式化类型生成时间
    17.         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HHmmss");//注意：HH是24小时制，hh是12小时制，时间类型的不要出现年月日如：yyyyMMdd
    18.         LocalTime localTimeParseWithFormatter = LocalTime.parse("102008", formatter);
    19.         System.out.println("4.根据指定的时分秒和格式化类型生成时间：" + localTimeParseWithFormatter);
    20.         //5.根据时间对象TemporalAccessor生成
    21.         LocalTime initTime = LocalTime.of(11, 59, 59);
    22.         System.out.println("5.根据时间对象TemporalAccessor生成:" + LocalTime.from(initTime));
    23.     }

    运行结果：

    1. 1.获取到的当前时间：11:36:05.740
    2. 2.根据指定的时分秒生成时间：23:59:59
    3. 3.根据指定的时分秒生成时间：12:23:45
    4. 4.根据指定的时分秒和格式化类型生成时间：10:20:08
    5. 5.根据时间对象TemporalAccessor生成:11:59:59

    3.2.2、LocalTime的常见使用方法

    1. /**
    2.      * LocalTime的常用使用方法
    3.      * 此处单元测试的注解是采用:org.junit.Test
    4.      * 和LocalDate的操作方法差不多
    5.      */
    6.     @Test
    7.     public void usage() {
    8.         //此处采用LocalTime对象直接调用now(),获取到当前时间,注意：如果使用我的实例，结果会不一样，因为LocalTime.now()是调用时的时间
    9.         LocalTime currentTime = LocalTime.now();
    10.         //1.获取时、分、秒
    11.         System.out.println("------------------1.获取时、分、秒-----------------------");
    12.         System.out.println("1.获取到的当前时间：" + currentTime);
    13.         System.out.println("1.获取当前时间的小时：" + currentTime.getHour());
    14.         System.out.println("1.获取当前时间的分钟：" + currentTime.getMinute());
    15.         System.out.println("1.获取当前时间的秒：" + currentTime.getSecond());
    16.         System.out.println("1.获取当前时间的秒：" + currentTime.getNano());
    17.         //2.时间的加减
    18.         System.out.println("------------------2.时间的加减-----------------------");
    19.         System.out.println("2.获取到的当前时间：" + currentTime);
    20.         System.out.println("2.加法：当前时间上增加1小时" + currentTime.plusHours(1));
    21.         System.out.println("2.加法：当前时间上增加10分钟" + currentTime.plusMinutes(10));
    22.         System.out.println("2.加法：当前时间上增加20秒" + currentTime.plusSeconds(20));
    23.         System.out.println("2.减法：当前时间上减加2小时" + currentTime.minusHours(2));
    24.         System.out.println("2.减法：当前时间上减加30分钟" + currentTime.minusMinutes(30));
    25.         System.out.println("2.减法：当前时间上减加5秒" + currentTime.minusSeconds(5));
    26.         System.out.println("------------------3.时间的判断及转化-----------------------");
    27.         //初始化一个新的时间
    28.         LocalTime initTime = LocalTime.of(13, 59, 59);
    29.         System.out.println("3.获取到的当前时间：" + currentTime);
    30.         System.out.println("3.新初始化的时间：" + initTime);
    31.         System.out.println("3.判断当前时间是否是一个时间之后：" + currentTime.isAfter(initTime));
    32.         System.out.println("3.判断当前时间是否是一个时间之前：" + currentTime.isBefore(initTime));
    33.         System.out.println("3.修改小时数为12：" + currentTime.withHour(12));
    34.         System.out.println("3.修改分钟数为12：" + currentTime.withMinute(12));
    35.         System.out.println("3.修改秒数为12：" + currentTime.withSecond(12));
    36.         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
    37.         LocalTime parseTime = LocalTime.parse("11:45:28", formatter);
    38.         System.out.println("3.根据指定的时分秒和格式化类型生成时间：" + parseTime);
    39.     }

    运行结果：

    1. ------------------1.获取时、分、秒-----------------------
    2. 1.获取到的当前时间：19:50:14.612
    3. 1.获取当前时间的小时：19
    4. 1.获取当前时间的分钟：50
    5. 1.获取当前时间的秒：14
    6. 1.获取当前时间的秒：612000000
    7. ------------------2.时间的加减-----------------------
    8. 2.获取到的当前时间：19:50:14.612
    9. 2.加法：当前时间上增加1小时20:50:14.612
    10. 2.加法：当前时间上增加10分钟20:00:14.612
    11. 2.加法：当前时间上增加20秒19:50:34.612
    12. 2.减法：当前时间上减加2小时17:50:14.612
    13. 2.减法：当前时间上减加30分钟19:20:14.612
    14. 2.减法：当前时间上减加5秒19:50:09.612
    15. ------------------3.时间的判断及转化-----------------------
    16. 3.获取到的当前时间：19:50:14.612
    17. 3.新初始化的时间：13:59:59
    18. 3.判断当前时间是否是一个时间之后：true
    19. 3.判断当前时间是否是一个时间之前：false
    20. 3.修改小时数为12：12:50:14.612
    21. 3.修改分钟数为12：19:12:14.612
    22. 3.修改秒数为12：19:50:12.612
    23. 3.根据指定的时分秒和格式化类型生成时间：11:45:28

    3.3 LocalDateTime的创建与使用

    3.3.1、LocalDateTime创建

    1. /**
    2.      * LocalDateTime的初始化方法
    3.      * 此处单元测试的注解是采用:org.junit.Test
    4.      */
    5.     @Test
    6.     public void init() {
    7.         //1.LocalDateTime对象直接调用now(),获取到当前时间
    8.         LocalDateTime localDateTime = LocalDateTime.now();
    9.         System.out.println("1.LocalDateTime对象直接调用now()获取到的时间：" + localDateTime);
    10.         //2.根据年月日时分秒构造（此处方法比较多，不一一介绍）
    11.         LocalDateTime localDateTimeOf = LocalDateTime.of(2021, 5, 10, 18, 30, 26);
    12.         System.out.println("2.根据年月日时分秒构造获取到的时间：" + localDateTimeOf);
    13.         //3.根据LocalDate和LocalTime得到(在有日期和时间的情况下可以使用)
    14.         LocalDateTime of = LocalDateTime.of(LocalDate.now(), LocalTime.now());
    15.         System.out.println("3.根据LocalDate和LocalTime得到:" + of);
    16.         //4.LocalDate指定一个LocalTime(LocalDate只有年月日)
    17.         LocalTime localTimeInit = LocalTime.of(14, 25, 25);
    18.         LocalDateTime localDateWithLocalTime = LocalDate.now().atTime(localTimeInit);
    19.         System.out.println("4.LocalDate指定一个LocalTime:" + localDateWithLocalTime);
    20.         //5.LocalTime指定一个LocalDate(LocalTime只有时分秒)
    21.         LocalDate localDateInit = LocalDate.of(1998, 10, 1);
    22.         LocalDateTime localTimeWithLocalDate = LocalTime.now().atDate(localDateInit);
    23.         System.out.println("5.LocalTime指定一个LocalDate:" + localTimeWithLocalDate);
    24.     }

    运行结果：

    1. 1.LocalDateTime对象直接调用now()获取到的时间：2021-05-24T19:51:15.237
    2. 2.根据年月日时分秒构造获取到的时间：2021-05-10T18:30:26
    3. 3.根据LocalDate和LocalTime得到:2021-05-24T19:51:15.238
    4. 4.LocalDate指定一个LocalTime:2021-05-24T14:25:25
    5. 5.LocalTime指定一个LocalDate:1998-10-01T19:51:15.238

    3.3.2、LocalDateTime的常见使用方法

    1.     /**
    2.      * LocalDateTime的常用使用方法
    3.      * 此处单元测试的注解是采用:org.junit.Test
    4.      */
    5.     @Test
    6.     public void usage() {
    7.         //1.根据LocalDateTime获取LocalDate
    8.         LocalDateTime currentTime = LocalDateTime.now();
    9.         System.out.println("1.根据LocalDateTime获取LocalDate: " + currentTime.toLocalDate());
    10.         //2.根据LocalDateTime获取LocalTime
    11.         System.out.println("2.根据LocalDateTime获取LocalTime: " + currentTime.toLocalTime());
    12.         System.out.println("------------------3.时间的加减法及修改-----------------------");
    13.         //3.LocalDateTime的加减法包含了LocalDate和LocalTime的所有加减,上面说过,这里就只做简单介绍
    14.         System.out.println("3.当前时间：" + currentTime);
    15.         System.out.println("3.当前时间加5年：" + currentTime.plusYears(5));
    16.         System.out.println("3.当前时间加2个月：" + currentTime.plusMonths(2));
    17.         System.out.println("3.当前时间减2天：" + currentTime.minusDays(2));
    18.         System.out.println("3.当前时间减5个小时：" + currentTime.minusHours(5));
    19.         System.out.println("3.当前时间加5分钟：" + currentTime.plusMinutes(5));
    20.         System.out.println("3.当前时间加20秒：" + currentTime.plusSeconds(20));
    21.         //还可以灵活运用比如：向后加一年，向前减一天，向后加2个小时，向前减5分钟，可以进行连写
    22.         System.out.println("3.同时修改(向后加一年，向前减一天，向后加2个小时，向前减5分钟)：" + currentTime.plusYears(1).minusDays(1).plusHours(2).minusMinutes(5));
    23.         System.out.println("3.修改年为2025年：" + currentTime.withYear(2025));
    24.         System.out.println("3.修改月为12月：" + currentTime.withMonth(12));
    25.         System.out.println("3.修改日为27日：" + currentTime.withDayOfMonth(27));
    26.         System.out.println("3.修改小时为12：" + currentTime.withHour(12));
    27.         System.out.println("3.修改分钟为12：" + currentTime.withMinute(12));
    28.         System.out.println("3.修改秒为12：" + currentTime.withSecond(12));
    29.         System.out.println("------------------4.时间的转化及其他-----------------------");
    30.         //4.时间的格式化及其他
    31.         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    32.         LocalDateTime parse = LocalDateTime.parse("2020-09-18 14:55:44", formatter);
    33.         System.out.println("4.时间字符串转为时间：" + parse);
    34.         LocalDate localDate = LocalDate.now();
    35.         System.out.println("4.所属年份的第一天：" + localDate.with(firstDayOfYear()));
    36.         System.out.println("4.所属年份的最后一天：" + localDate.with(lastDayOfYear()));
    37.         System.out.println("4.所属年份的下一年的第一天：" + localDate.with(firstDayOfNextYear()));
    38.         System.out.println("4.所属月份的第一天：" + localDate.with(firstDayOfMonth()));
    39.         System.out.println("4.所属月份的最后一天：" + localDate.with(lastDayOfMonth()));
    40.         System.out.println("4.所属月份的下个月的第一天：" + localDate.with(firstDayOfNextMonth()));
    41.     }

    运行结果：

    1. 1.根据LocalDateTime获取LocalDate: 2021-05-24
    2. 2.根据LocalDateTime获取LocalTime: 19:57:46.316
    3. ------------------3.时间的加减法及修改-----------------------
    4. 3.当前时间：2021-05-24T19:57:46.316
    5. 3.当前时间加5年：2026-05-24T19:57:46.316
    6. 3.当前时间加2个月：2021-07-24T19:57:46.316
    7. 3.当前时间减2天：2021-05-22T19:57:46.316
    8. 3.当前时间减5个小时：2021-05-24T14:57:46.316
    9. 3.当前时间加5分钟：2021-05-24T20:02:46.316
    10. 3.当前时间加20秒：2021-05-24T19:58:06.316
    11. 3.同时修改(向后加一年，向前减一天，向后加2个小时，向前减5分钟)：2022-05-23T21:52:46.316
    12. 3.修改年为2025年：2025-05-24T19:57:46.316
    13. 3.修改月为12月：2021-12-24T19:57:46.316
    14. 3.修改日为27日：2021-05-27T19:57:46.316
    15. 3.修改小时为12：2021-05-24T12:57:46.316
    16. 3.修改分钟为12：2021-05-24T19:12:46.316
    17. 3.修改秒为12：2021-05-24T19:57:12.316
    18. ------------------4.时间的转化及其他-----------------------
    19. 4.时间字符串转为时间：2020-09-18T14:55:44
    20. 4.所属年份的第一天：2021-01-01
    21. 4.所属年份的最后一天：2021-12-31
    22. 4.所属年份的下一年的第一天：2022-01-01
    23. 4.所属月份的第一天：2021-05-01
    24. 4.所属月份的最后一天：2021-05-31
    25. 4.所属月份的下个月的第一天：2021-06-01

  • 相关阅读:
    记录：unity脚本的编写6.0
    springboot 核心技术---配置文件
    SpringCloudAlibaba中篇(Sentinel,Seata)(超级无敌认真好用，万字收藏篇!!!!)
    【TypeScript】深入学习TypeScript装饰器
    java计算机毕业设计高铁在线购票系统MyBatis+系统+LW文档+源码+调试部署
    React 中的 useCallback 钩子函数
    软件工程毕业设计课题（16）基于python的毕业设计python新闻信息管理系统毕设作品源码
    智安网络|面临日益增长的安全威胁：云安全和零信任架构的重要性
    定位进阶(HTML)
    2.吴恩达机器学习--逻辑回归
  • 原文地址：https://blog.csdn.net/qq_58148854/article/details/127711117