zoukankan      html  css  js  c++  java

  • 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
    本文版权归作者和博客园共有，转载必须给出原文链接，并保留此段声明，否则保留追究法律责任的权利。
  • 相关阅读:
    页面get请求 中文参数方法乱码问题
    java版ftp简易客户端（可以获取文件的名称及文件大小）
    文件下载
    kafka：一个分布式消息系统
    Executor的线程代码
    验证码的生成
    二维码的简单实现
    rsync实现大致流程描述
    C++中模板生成时机
    gcc虚函数表生成时机
  • 原文地址：https://www.cnblogs.com/binbingg/p/15241732.html
Copyright © 2011-2022 走看看