JDK8 新特性：新时间日期API

本文目录：

前言

1.旧版日期时间API存在的问题

2.新日期时间 API 介绍

3.用法介绍

 1.JDK8 日期和时间类

 2.JDK8 日期时间格式化与解析

 3.JDK8 Instant 类

 4.JDK8 计算日期时间差类

 5.JDK8 日期时间调整器

 6.JDK8 设置日期时间的时区

前言

       在 JDK8 之前，我们经常使用到的时间API包括(Date、Calendar)，Date 与字符串之间的转换使用 SimpleDateFormat 进行转换（parse()、format() 方法），然而 SimpleDateFormat 不是线程安全的。在设计上也是存在一些缺陷的，比如有两个 Date 类，一个在 java.util 包中，一个在 java.sql 包中。

      在JDK8 中，引入了一套全新的时间日期API，这套 API 在设计上比较合理，使用时间操作也变得更加方便。并且支持多线程安全操作。

1.旧版日期时间API存在的问题

1.设计很差：在 java.util 和 java.sql 的包中都有日期类。java.util.Date 同时包含日期和时间，而java.sql.Date仅包含日期，此外用于格式化和解析的类又在 java.text 包中定义；

2.非线程安全：java.util.Date 是非线程安全的,所有的日期类都是可变的，这是 java 日期类最大的问题之一；

3.时区处理麻烦：日期类并不提供国际化，没有时区支持。因此 java 引入了 java.util.Calendar 和 java.util.TimeZone 类,但他们同样存在上述所有的问题

  1. /**
  2.  * TODO JDK8之前日期存在的问题
  3.  *
  4.  * @author liuzebiao
  5.  * @Date 2020-1-13 11:28
  6.  */
  7. public class DateDemo01 {
  8.  
  9.     public static void main(String[] args) {
  10.         //旧版日期时间 API 存在的问题
  11.         //1.设计不合理(JDK8 Date类已经 @Deprecated 注释,不推荐使用)
  12.         Date now =new Date(1985,9,23);
  13.         System.out.println(now);
  14.  
  15.         //2.时间格式化和解析是线程不安全的
  16.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  17.         for (int i = 0; i < 50; i++) {
  18.             new Thread(()->{
  19.                 try {
  20.                     Date date = sdf.parse("2019-09-09");
  21.                     System.out.println("date:"+date);
  22.                 } catch (ParseException e) {
  23.                     e.printStackTrace();
  24.                 }
  25.             }).start();
  26.         }
  27.     }
  28. }

 多线程测试结果：(会有日期格式化错误的，还有直接报错的，说明线程是不安全)

  1. date:Tue Jun 09 00:00:00 CST 2026
  2. date:Tue Sep 09 00:00:00 CST 990
  3. date:Tue Sep 09 00:00:00 CST 990
  4. date:Tue Sep 09 00:00:00 CST 990
  5. date:Sun Dec 01 00:00:00 CST 2019
  6. date:Mon Sep 09 00:00:00 CST 2019(这个才是正确的)
  7. date:Mon Sep 09 00:00:00 CST 2019
  8. date:Mon Sep 09 00:00:00 CST 2019
  9. Exception in thread "Thread-35" Exception in thread "Thread-37" java.lang.NumberFormatException: For input string: "1909E.21909"
  10. 	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2043)
  11. 	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
  12. 	at java.lang.Double.parseDouble(Double.java:538)

2.新日期时间 API 介绍

      JDK8 中增加了一套全新的日期时间 API，这套 API 设计合理，是线程安全的。新的日期及时间 API 位于 java.time 包下，如下是一些该包下的关键类：

  • LocalDate：表示日期，包含：年月日。格式为：2020-01-13
  • LocalTime：表示时间，包含：时分秒。格式为：16:39:09.307
  • LocalDateTime：表示日期时间，包含：年月日 时分秒。格式为：2020-01-13T16:40:59.138
  • DateTimeFormatter：日期时间格式化类
  • Instant：时间戳类
  • Duration：用于计算 2 个时间(LocalTime，时分秒)之间的差距
  • Period：用于计算 2 个日期(LocalDate，年月日)之间的差距
  • ZonedDateTime：包含时区的时间

       Java 中使用的历法是 ISO-8601 日历系统，他是世界民用历法，也就是我们所说的公里。平年有365天，闰年是366天。此外 Java8 还提供了 4 套其他历法，分别是：

  • ThaiBuddhistDate：泰国佛教历
  • MinguoDate：中华民国历
  • JapaneseDate：日本历
  • HijrahDate：伊斯兰历

3.用法介绍

 1.JDK8 日期和时间类

        LocalDate、LocalTime、LocalDateTime类的实例是不可变的对象，分别表示使用 ISO-8601 日历系统的日期、时间、日期和时间。他们提供了简单的日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

        对日期时间的修改，就是对已经存在的 LocalDate对象，根据需求创建它的修改版，最简单的方式是使用 withAttribute() 方法。withAttribute()方法会创建对象的一个副本，并按照需要修改它的属性。

       以下所有方法都返回了一个修改属性的对象，它们并不会影响原来的日期对象。（即:修改后的日期与原来的日期不是一个对象，原日期不受影响）

  1. /**
  2.  * TODO 时间日期类
  3.  *      LocalDate、LocalTime、LocalDateTime
  4.  *
  5.  * @author liuzebiao
  6.  * @Date 2020-1-13 13:42
  7.  */
  8. public class DateDemo02 {
  9.  
  10.     /**
  11.      * LocalDate 日期类(年月日)
  12.      */
  13.     @Test
  14.     public void testLocalDate() {
  15.         //获取当前日期
  16.         LocalDate now = LocalDate.now();
  17.         System.out.println(now);
  18.         //指定日期 LocalDate.of(year,month,day)
  19.         LocalDate date = LocalDate.of(2008, 8, 8);
  20.         System.out.println(date);
  21.         //获取年
  22.         System.out.println("年:" + date.getYear());
  23.         //获取月(英文)
  24.         System.out.println("月(英文):" + date.getMonth());
  25.         //获取月(阿拉伯数字)
  26.         System.out.println("月(数字):" + date.getMonthValue());
  27.         //获取日
  28.         System.out.println("日:" + date.getDayOfMonth());
  29.         //是否是闰年
  30.         System.out.println("是否是闰年:" + date.isLeapYear());
  31.         //...其他方法,自行研究
  32.     }
  33.  
  34.     /**
  35.      * LocalDate 时间类(时分秒)
  36.      */
  37.     @Test
  38.     public void testLocalTime() {
  39.         //获取当前时间
  40.         LocalTime now = LocalTime.now();
  41.         System.out.println(now);
  42.         //指定日期 LocalTime.of(hour,minute,second)
  43.         LocalTime date = LocalTime.of(13, 26, 39);
  44.         System.out.println(date);
  45.         //获取时
  46.         System.out.println(date.getHour());
  47.         //获取分
  48.         System.out.println(date.getMinute());
  49.         //获取秒
  50.         System.out.println(date.getSecond());
  51.         //获取纳秒
  52.         System.out.println(now.getNano());
  53.         //...其他方法,自行研究
  54.  
  55.     }
  56.  
  57.     /**
  58.      * LocalDateTime 日期时间类(年月日 时分秒)
  59.      */
  60.     @Test
  61.     public void testLocalDateTime() {
  62.         //LocalDateTime: LocalDate + LocalTime,有年月日 时分秒
  63.         LocalDateTime now = LocalDateTime.now();
  64.         System.out.println("当前日期时间:"+now);
  65.         //指定日期时间 LocalDateTime.of(year,month,day,hour,minute,second)
  66.         LocalDateTime date = LocalDateTime.of(2018, 7, 23, 18, 59, 31);
  67.         System.out.println(date);
  68.         //获取年
  69.         System.out.println(date.getYear());
  70.         //获取月
  71.         System.out.println(date.getMonth());
  72.         //获取日
  73.         System.out.println(date.getDayOfMonth());
  74.         //获取时
  75.         System.out.println(date.getHour());
  76.         //获取分
  77.         System.out.println(date.getMinute());
  78.         //获取秒
  79.         System.out.println(date.getSecond());
  80.         //...其他方法,自行研究
  81.     }
  82.  
  83.     /**
  84.      * 修改时间
  85.      */
  86.     @Test
  87.     public void modifyTime() {
  88.         //以LocalDateTime为例(LocalDate、LocalTime与此类似)
  89.         LocalDateTime now = LocalDateTime.now();
  90.         //修改年[修改时间(不是JDK8之前的setXXX(),而是使用withXXX())]
  91.         System.out.println("修改年后:" + now.withYear(9102));
  92.         //增加年(减使用 minusYear()方法)
  93.         System.out.println("+2年后:" + now.plusYears(2));
  94.         //增加日(减使用 minusDays()方法)
  95.         System.out.println("47天后:" + now.plusDays(47));
  96.         //...其他方法,自行研究
  97.     }
  98.  
  99.     /**
  100.      * 时间比较
  101.      */
  102.     @Test
  103.     public void compareTime() {
  104.         //以LocalDateTime为例(LocalDate、LocalTime与此类似)
  105.         //时间1
  106.         LocalDateTime now = LocalDateTime.now();
  107.         //时间2
  108.         LocalDateTime dateTime = LocalDateTime.of(2018, 7, 12, 13, 28, 51);
  109.         //判断前面日期是否在后面日期后
  110.         System.out.println("A时间是否晚于B时间:" + now.isAfter(dateTime));
  111.         //判断前面日期是否在后面日期前
  112.         System.out.println("A时间是否早于B时间:" + now.isBefore(dateTime));
  113.         //判断两个日期时间是否相等
  114.         System.out.println("两个时间是否相等:" + now.isEqual(dateTime));
  115.         //...其他方法,自行研究
  116.     }
  117. }

 2.JDK8 日期时间格式化与解析

  1. /**
  2.  * TODO 日期时间格式化 + 解析 + 多线程执行(安全)
  3.  *
  4.  * @author liuzebiao
  5.  * @Date 2020-1-13 14:12
  6.  */
  7. public class DateDemo03 {
  8.  
  9.     @Test
  10.     public void dateFormat(){
  11.         LocalDateTime now = LocalDateTime.now();
  12.  
  13.         //格式化
  14.         //使用JDK自带的时间格式:ISO_DATE_TIME(默认提供了很多格式,请自行查看)
  15.         DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE_TIME;
  16.         String format = now.format(dtf);
  17.         System.out.println("format="+format);
  18.  
  19.         //指定时间格式(ofPattern()方法)
  20.         DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒");
  21.         String format1 = now.format(dtf1);
  22.         System.out.println(format1);
  23.  
  24.         //解析(parse()方法)
  25.         LocalDateTime parse = LocalDateTime.parse(format1, dtf1);
  26.         System.out.println("parse="+parse);
  27.  
  28.         /**
  29.          * 多线程执行(验证线程安全性)
  30.          * 1.返回结果正确   2.不抛异常
  31.          */
  32.         for (int i = 0; i < 50; i++) {
  33.             new Thread(()->{
  34.                 LocalDateTime parse1 = LocalDateTime.parse(format1, dtf1);
  35.                 System.out.println("parse="+parse1);
  36.             }).start();
  37.         }
  38.     }
  39. }

 3.JDK8 Instant 类

      Instant 类，就是时间戳，内部保存了从1970年1月1日 00:00:00以来的秒和纳秒。

  1. /**
  2.  * TODO JDK8的 Instant类(时间戳)
  3.  * （主要不是面向用户使用）
  4.  *
  5.  * @author liuzebiao
  6.  * @Date 2020-1-13 14:31
  7.  */
  8. public class DateDemo04 {
  9.  
  10.     @Test
  11.     public void Instant(){
  12.         //Instant 
  13.         // 内部保存了秒和纳秒，一般不是给用户使用的，而是方便程序做一些统计的(比如:统计方法耗时)
  14.         Instant now = Instant.now();
  15.         System.out.println("当前时间戳:"+now);//2020-01-13T06:48:46.267Z
  16.         //Instant类 并没有修改年月日等操作.因为 Instant 本来就不是给用户使用的
  17.         //Instant类:对 秒、纳秒等操作方便
  18.         Instant plus = now.plusSeconds(20);
  19.         System.out.println("+20秒后:"+plus);
  20.  
  21.         Instant minus = now.minusSeconds(20);
  22.         System.out.println("-20秒后:"+minus);
  23.  
  24.         //获取秒、毫秒、纳秒
  25.         long second = now.getEpochSecond();
  26.         System.out.println("秒:"+second);
  27.         int nano = now.getNano();
  28.         System.out.println("纳秒:"+nano);
  29.         //...其他方法,自行研究
  30.     }
  31. }

 4.JDK8 计算日期时间差类

     Duration/Period 类：主要用来计算日期时间差

  1. Duration：用于计算 2 个时间(LocalTime，时分秒)的差值
  2. Period：用于计算 2 个 日期(LocalDate，年月日)的差值
  1. /**
  2.  * TODO JDK8 计算日期时间差值
  3.  *
  4.  * @author liuzebiao
  5.  * @Date 2020-1-13 14:55
  6.  */
  7. public class DateDemo05 {
  8.  
  9.     /**
  10.      * Duration类:计算时间的差值
  11.      */
  12.     @Test
  13.     public void testTimeDiff(){
  14.         //时间1
  15.         LocalTime now = LocalTime.now();
  16.         //时间2
  17.         LocalTime dateTime = LocalTime.of(8, 15, 46);
  18.         //计算两个时间的差值
  19.         //计算规则:让第二个参数 减去 第一个参数(位置错误可能出现负数)
  20.         Duration duration = Duration.between(dateTime,now);
  21.         System.out.println("相差的天数:"+duration.toDays());
  22.         System.out.println("相差的小时数:"+duration.toHours());
  23.         System.out.println("相差的分钟数:"+duration.toMinutes());
  24.         System.out.println("相差的秒数:"+duration.toSeconds());//JDK 9+ 出现(JDK8会报错误)
  25.         System.out.println("相差的纳秒数:"+duration.toNanos());
  26.         //...其他方法,自行研究
  27.     }
  28.  
  29.     /**
  30.      * Period类:计算日期的差值
  31.      */
  32.     @Test
  33.     public void testDateDiff(){
  34.         //日期1
  35.         LocalDate now = LocalDate.now();
  36.         //日期2
  37.         LocalDate date = LocalDate.of(1999,5,29);
  38.         //计算两个日期的差值
  39.         //计算规则:让第二个参数 减去 第一个参数(位置错误可能出现负数)
  40.         Period period = Period.between(date,now);
  41.         System.out.println("相差的年:"+period.getYears());
  42.         System.out.println("相差的月:"+period.getMonths());
  43.         System.out.println("相差的日:"+period.getDays());
  44.         //...其他方法,自行研究
  45.     }
  46. }

 5.JDK8 日期时间调整器

   有时我们可能需要获取，例如："将日期调整到下一个月的第一天"等操作，此时我们可以通过时间调整器来进行操作。

  • TemporalAdjuster：时间调整器
  • TemporalAdjusters：工具类。该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现
  1. /**
  2.  * TODO JDK8 时间调整器
  3.  *
  4.  * @author liuzebiao
  5.  * @Date 2020-1-13 15:10
  6.  */
  7. public class DateDemo06 {
  8.  
  9.     /**
  10.      * TemporalAdjuster类:自定义调整时间
  11.      */
  12.     @Test
  13.     public void timeCorrector(){
  14.         //将日期调整到"下一个月的第一天"操作
  15.         LocalDateTime now = LocalDateTime.now();
  16.         //参数:TemporalAdjuster adjuster。TemporalAdjuster是一个接口,里面只有 Temporal adjustInto(Temporal temporal); 这一个方法,支持接入 lambda 表达式
  17.         //此处 Temporal 就是指时间(包括 LocalDate、LocalTime、LocalDateTime 都是继承自该类。继承关系：如下图所示)
  18.         TemporalAdjuster adjuster = ( Temporal temporal)->{
  19.             LocalDateTime dateTime = (LocalDateTime)temporal;
  20.             return dateTime.plusMonths(1).withDayOfMonth(1);//下一个月第一天
  21.         };
  22.         LocalDateTime newDateTime = now.with(adjuster);
  23.         System.out.println("下个月第一天:"+newDateTime);
  24.     }
  25.  
  26.     /**
  27.      * TemporalAdjusters工具类:使用JDK提供的时间调整器
  28.      */
  29.     @Test
  30.     public void JDKTimeCorrector(){
  31.         //JDK中自带了很多时间调整器,其他调整器请自行查看
  32.         //使用 TemporalAdjusters 工具类
  33.         //TemporalAdjusters.firstDayOfNextYear()--->根据内容可知:下一年第一天
  34.         TemporalAdjuster temporalAdjuster = TemporalAdjusters.firstDayOfNextYear();
  35.  
  36.         LocalDateTime now = LocalDateTime.now();
  37.         LocalDateTime newDateTime = now.with(temporalAdjuster);
  38.         System.out.println("下个月第一天:"+newDateTime);
  39.     }
  40. }

 附：继承关系（LocalDate、LocalTime、LocalDateTime、Temporal类）

 6.JDK8 设置日期时间的时区

       JDK8 中加入了对时区的支持。LocalDate、LocalTime、LocalDateTime 是不带时区的，带时区的日期时间类分别为：ZonedDate、ZonedTime、ZonedDateTime类。

       其中每个时区都有对应着的 ID，ID的格式为"区域/城市"，例如：Asia/Shanghai 等。

       ZoneId类：该类中包含了所有的时区信息。

  1. /**
  2.  * TODO JDK8设置时区(设置日期时间的时区)
  3.  *
  4.  * @author liuzebiao
  5.  * @Date 2020-1-13 15:43
  6.  */
  7. public class DateDemo07 {
  8.  
  9.     /**
  10.      * 获取时区ID
  11.      */
  12.     @Test
  13.     public void getZoneIds(){
  14.         //1.获取所有的时区ID
  15.         Set<String> zoneIds = ZoneId.getAvailableZoneIds();
  16.         zoneIds.forEach(System.out::println);//返回600来个时区
  17.     }
  18.  
  19.     /**
  20.      * 不带时区 Vs 带时区的日期时间
  21.      */
  22.     @Test
  23.     public void ZonedDemo(){
  24.         //2.操作带时区的类
  25.         //不带时间,获取计算机的当前时间
  26.         LocalDateTime now = LocalDateTime.now();
  27.         System.out.println("now:"+now);
  28.  
  29.         //中国使用的是东八区的时间，比标准时间早8个小时
  30.         //操作带时间的类
  31.         ZonedDateTime zdt = ZonedDateTime.now(Clock.systemUTC());//创建出来的时间是世界标准时间
  32.         System.out.println("世界标准时间:"+zdt);
  33.     }
  34.  
  35.     /**
  36.      * 本地时间
  37.      */
  38.     @Test
  39.     public void localTime(){
  40.         //now():使用计算机的默认的时区,创建日期时间
  41.         ZonedDateTime now = ZonedDateTime.now();
  42.         System.out.println("本地时间:"+now);//本地时间:2020-01-13T15:52:43.633+08:00[Asia/Shanghai]
  43.     }
  44.  
  45.     /**
  46.      * 使用指定的时区来创建时间
  47.      */
  48.     @Test
  49.     public void ZoneTime(){
  50.  
  51.         ZonedDateTime now = ZonedDateTime.now(ZoneId.of("America/New_York"));
  52.         System.out.println("设置指定时间:"+now);//设置指定时间:2020-01-13T02:56:24.776-05:00[America/New_York]
  53.     }
  54.  
  55.     /**
  56.      * 修改时区
  57.      */
  58.     @Test
  59.     public void modifyZone(){
  60.         ZonedDateTime now = ZonedDateTime.now(ZoneId.of("America/New_York"));
  61.  
  62.         //withZoneSameInstant():既更改时区,也更改时间
  63.         ZonedDateTime modifyTime = now.withZoneSameInstant(ZoneId.of("Asia/Shanghai"));
  64.         System.out.println("修改时区后的时间:"+modifyTime);
  65.  
  66.         //withZoneSameLocal():只更改时区,不更改时间
  67.         ZonedDateTime modifyTime2 = now.withZoneSameLocal(ZoneId.of("Asia/Shanghai"));
  68.         System.out.println("修改时区后的时间:"+modifyTime2);
  69.     }
  70.     //...其他方法,自行研究
  71. }
作者：Binge
本文版权归作者和博客园共有，转载必须给出原文链接，并保留此段声明，否则保留追究法律责任的权利。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/binbingg/p/15241732.html