【Java 8系列】Java日期时间的新主宰者：LocalDate、LocalTime、LocalDateTime、ZonedDateTime

迷南。 2022-12-30 07:42 318阅读 0赞

热门系列：

  • 【Java 8系列】收集器Collector与工具类Collectors

  • 【Java 8系列】Stream详解，看这一篇就够啦

  • 【Java 8系列】Lambda 表达式，一看就废

  • 【Java 8系列】Java开发者的判空利器 – Optional

  • 程序人生，精彩抢先看

目录

1、前言

2、正文

2.1 LocalDate、LocalTime、LocalDateTime

2.1.1 获取当前时间

2.1.2 获取当前时间毫秒数/时间戳

2.1.3 获取年、月、日与星期几

2.1.4 设置自定义时间

2.1.5 日期/时间替换成指定的日期/时间

2.1.6 日期时间与字符串相互转换

2.1.7 Date与LocalDateTime相互转换

2.1.8 获取偏移日期时间

2.2 ZonedDateTime

2.3 ZoneId

2.4 Instant

2.5 时间工具类

3、总结

1、前言

本系列一直在分享Java8的新增特性与API，今天和大家一起扒一扒Java的新时间类库：java.time；

之前我在往期博文：【Java编程系列】Java判断世界各时区的夏令时、冬令时 中就有提到过，为什么现在不适用Date时间类，而改用java.time库中的时间类。答案很简单：就是多线程安全性问题！

2、正文

本文主要分享和举例一些常用的类，下面正式开整！！本篇的时间类，都是使用的ISO-8601日历系统时间！

ISO-8601日历系统是当今世界上大多数地方使用的现代民用日历系统。它等效于多用的格里高利历系统，该系统在今天一直适用today年的规则。对于当今编写的大多数应用程序，ISO-8601规则完全适用。但是，任何利用历史日期并要求它们准确的应用程序都将发现ISO-8601方法不合适。

2.1 LocalDate、LocalTime、LocalDateTime

注：以上3个类，在使用和功能上基本一样，只是所代表的对象不同，所以放在一起讲解！

  • LocalDate：是一个不可变的日期时间对象，代表一个日期，通常被视为年-月-日；此类是不可变的并且是线程安全的。
  • LocalTime：是一个不可变的日期时间对象，代表一个时间，通常被视为时分秒。时间以纳秒精度表示；此类是不可变的并且是线程安全的。
  • LocalDateTime：是一个不变的日期时间对象，代表一个日期时间，通常被视为年-月-日-时-分-秒。也可以访问其他日期和时间字段，例如，一年中的某天，一周中的某天和一周中的某周。时间以纳秒精度表示；此类是不可变的并且是线程安全的。

下面来看看常用的一些方法，三者取其一，咱们以LocalDateTime为例展开（举栗子一目了然，所以下面尽可能以代码形式讲解）：

2.1.1 获取当前时间

  1. public static void main(String[] args) {
  2.         //获取当前时间
  3.         LocalDateTime localDateTime = LocalDateTime.now();
  4.         System.out.println("本地当前日期时间："+localDateTime);
  5.         System.out.println();
  7.         //设置时区为美国纽约
  8.         System.out.println("美国当前日期时间："+LocalDateTime.now(ZoneId.of("America/New_York")));
  9.         System.out.println();
  11. }

输出：

  1. 本地当前日期时间：2020-12-28T15:25:20.707
  3. 美国当前日期时间：2020-12-28T02:25:20.708

2.1.2 获取当前时间毫秒数/时间戳

  1. public static void main(String[] args) {
  2.         //获取当前时间
  3.         LocalDateTime localDateTime = LocalDateTime.now();
  4.         System.out.println("本地当前日期时间："+localDateTime);
  6.         long millisecond = localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
  7.         System.out.println("获取时间戳："+millisecond/1000);
  8.         System.out.println("获取毫秒数："+millisecond);
  9.         System.out.println();
  10. }

输出：

  1. 本地当前日期时间：2020-12-28T16:43:32.971
  2. 获取时间戳：1609145012
  3. 获取毫秒数：1609145012971

2.1.3 获取年、月、日与星期几

  1. public static void main(String[] args) {
  2.         //获取当前时间
  3.         LocalDateTime localDateTime = LocalDateTime.now();
  4.         System.out.println("本地当前日期时间："+localDateTime);
  6.         //获取年、月、日、星期几
  7.         int year = localDateTime.getYear();
  8.         System.out.println("获取年份（第一种方式）："+year);
  9.         year = localDateTime.get(ChronoField.YEAR);
  10.         System.out.println("获取年份（第二种方式）："+year);
  11.         System.out.println();
  13.         int month = localDateTime.getMonthValue();
  14.         System.out.println("获取月份（第一种方式）："+month);
  15.         month = localDateTime.getMonth().getValue();
  16.         System.out.println("获取月份（第二种方式）："+month);
  17.         month = localDateTime.get(ChronoField.MONTH_OF_YEAR);
  18.         System.out.println("获取月份（第三种方式）："+month);
  19.         System.out.println();
  21.         int dayOfWeek = localDateTime.getDayOfWeek().getValue();
  22.         System.out.println("获取星期几(第一种方式)："+dayOfWeek);
  23.         dayOfWeek = localDateTime.get(ChronoField.DAY_OF_WEEK);
  24.         System.out.println("获取星期几(第二种方式)："+dayOfWeek);
  25.         System.out.println();
  27.         int dayOfMonth = localDateTime.getDayOfMonth();
  28.         System.out.println("获取本月当日(第一种方式)："+dayOfMonth);
  29.         dayOfMonth = localDateTime.get(ChronoField.DAY_OF_MONTH);
  30.         System.out.println("获取本月当日(第二种方式)："+dayOfMonth);
  31.         System.out.println();
  33.         int dayOfYear = localDateTime.getDayOfYear();
  34.         System.out.println("获取本年当日(第一种方式)："+dayOfYear);
  35.         dayOfYear = localDateTime.get(ChronoField.DAY_OF_YEAR);
  36.         System.out.println("获取本年当日(第二种方式)："+dayOfYear);
  38. }

输出：

  1. 本地当前日期时间：2020-12-29T10:32:49.698
  2. 获取年份（第一种方式）：2020
  3. 获取年份（第二种方式）：2020
  5. 获取月份（第一种方式）：12
  6. 获取月份（第二种方式）：12
  7. 获取月份（第三种方式）：12
  9. 获取星期几(第一种方式)：2
  10. 获取星期几(第二种方式)：2
  12. 获取本月当日(第一种方式)：29
  13. 获取本月当日(第二种方式)：29
  15. 获取本年当日(第一种方式)：364
  16. 获取本年当日(第二种方式)：364

2.1.4 设置自定义时间

  1. public static void main(String[] args) {
  3.         //设置自定义时间
  4.         LocalDateTime tempTime = LocalDateTime.of(2020,11,28,15,00,01);
  5.         System.out.println("自定义设置的日期时间："+tempTime);
  6.         System.out.println();
  8.         //设置自定义日期
  9.         LocalDate tempDate = LocalDate.of(2019,10,1);
  10.         System.out.println("自定义设置的日期："+tempDate);
  11.         System.out.println();
  13. }

输出：

  1. 自定义设置的日期时间：2020-11-28T15:00:01
  3. 自定义设置的日期：2019-10-01

2.1.5 日期/时间替换成指定的日期/时间

这里会用到一个方法，adjustInto（）：将指定的时间对象调整为具有与此对象相同的日期和时间

  1. public static void main(String[] args) {
  2.         //获取当前时间
  3.         LocalDateTime localDateTime = LocalDateTime.now();
  4.         System.out.println("本地当前日期时间："+localDateTime);
  5.         System.out.println();
  7.         //设置自定义时间
  8.         LocalDateTime tempTime = LocalDateTime.of(2020,11,28,15,00,01);
  9.         System.out.println("自定义设置的日期时间："+tempTime);
  10.         System.out.println();
  12. //        //设置自定义日期
  13.         LocalDate tempDate = LocalDate.of(2019,10,1);
  14.         System.out.println("自定义设置的日期："+tempDate);
  15.         System.out.println();
  17.         //通过adjustInto方法实现日期转换
  18.         //将指定的时间对象调整为具有与此对象相同的日期和时间
  19.         localDateTime = (LocalDateTime)tempDate.adjustInto(localDateTime);
  20.         tempTime = (LocalDateTime)tempDate.adjustInto(tempTime);
  21.         System.out.println("转换后的localDateTime："+localDateTime);
  22.         System.out.println("转换后的tempTime："+tempTime);
  23.         System.out.println();
  25. }

输出：

  1. 本地当前日期时间：2020-12-28T15:30:20.609
  3. 自定义设置的日期时间：2020-11-28T15:00:01
  5. 自定义设置的日期：2019-10-01
  7. 转换后的localDateTime：2019-10-01T15:30:20.609
  8. 转换后的tempTime：2019-10-01T15:00:01

2.1.6 日期时间与字符串相互转换

  1. private static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
  2. private static final String YYYYMMDD_HH_MM_SS = "yyyy/MM/dd HH:mm:ss";
  4. public static void main(String[] args) {
  5.     //获取当前时间
  6.     LocalDateTime localDateTime = LocalDateTime.now();
  7.     System.out.println("本地当前日期时间："+localDateTime);
  9.     //日期与字符串相互转换
  10.     //日期转字符串
  11.     String dateTimeStr = localDateTime.format(DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM_SS));
  12.     System.out.println("日期时间格式化成字符串后："+dateTimeStr);
  14.     //字符串转日期
  15.     String convertTime = "2020/12/12 12:12:12";
  16.     LocalDateTime convertLocalDateTime = LocalDateTime.parse(convertTime,DateTimeFormatter.ofPattern(YYYYMMDD_HH_MM_SS));
  17.     System.out.println("由字符串转换成的日期时间为："+convertLocalDateTime);
  18. }

输出：

  1. 本地当前日期时间：2020-12-29T10:43:45.295
  2. 日期时间格式化成字符串后：2020-12-29 10:43:45
  3. 由字符串转换成的日期时间为：2020-12-12T12:12:12

2.1.7 Date与LocalDateTime相互转换

  1. private static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
  2. private static final String YYYYMMDD_HH_MM_SS = "yyyy/MM/dd HH:mm:ss";
  4. public static void main(String[] args) {
  5.     //获取当前时间
  6.     LocalDateTime localDateTime = LocalDateTime.now();
  7.     System.out.println("本地当前日期时间："+localDateTime);
  9.     //Date转换成LocalDateTime
  10.     Date date = new Date();
  11.     LocalDateTime date2LocalDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
  12.     System.out.println("Date转换成LocalDateTime后>>>>"+date2LocalDateTime);
  14.     //LocalDateTime转换成Date
  15.     Date localDateTime2Date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
  16.     System.out.println("LocalDateTime转换成Date后>>>>"+localDateTime2Date);
  17.     System.out.println("格式化一下>>>>"+FastDateFormat.getInstance(YYYY_MM_DD_HH_MM_SS).format(localDateTime2Date));
  18. }

输出：

  1. 本地当前日期时间：2020-12-29T11:02:16.883
  2. Date转换成LocalDateTime后>>>>2020-12-29T11:02:16.884
  3. LocalDateTime转换成Date后>>>>Tue Dec 29 11:02:16 CST 2020
  4. 格式化一下>>>>2020-12-29 11:02:16

2.1.8 获取偏移日期时间

此处需要提一下，会常用的两个类似功能的方法：minus（）和 plus（）**，**其中还有一些类似的指定方法，如：






















































LocalDateTime minus​(long amountToSubtract, TemporalUnit unit)

返回此日期时间的副本，减去指定的数量。
LocalDateTime minus​(TemporalAmount amountToSubtract)

返回此日期时间的副本，减去指定的数量。
LocalDateTime minusDays​(long days)

返回此副本的副本，LocalDateTime其中减去指定的天数。
LocalDateTime minusHours​(long hours)

返回此副本的副本，LocalDateTime其中减去指定的小时数。
LocalDateTime minusMinutes​(long minutes)

返回此副本的副本，LocalDateTime其中减去指定的分钟数。
LocalDateTime minusMonths​(long months)

返回此副本的副本，LocalDateTime其中减去指定的月数。
LocalDateTime minusNanos​(long nanos)

返回此副本的副本，LocalDateTime其中减去指定的纳秒数。
LocalDateTime minusSeconds​(long seconds)

返回此副本的副本，LocalDateTime其中减去指定的秒数。
LocalDateTime minusWeeks​(long weeks)

返回此副本的副本，LocalDateTime其中减去指定的周数。
LocalDateTime minusYears​(long years)

返回此副本的副本，LocalDateTime其中减去指定的年数。





















































LocalDateTime plus​(long amountToAdd, TemporalUnit unit)

返回此日期时间的副本，其中添加了指定的数量。
LocalDateTime plus​(TemporalAmount amountToAdd)

返回此日期时间的副本，其中添加了指定的数量。
LocalDateTime plusDays​(long days)

返回LocalDateTime带有指定天数的副本。
LocalDateTime plusHours​(long hours)

返回LocalDateTime带有指定小时数的副本。
LocalDateTime plusMinutes​(long minutes)

返回LocalDateTime带有指定分钟数的副本。
LocalDateTime plusMonths​(long months)

返回LocalDateTime带有指定月份数的副本。
LocalDateTime plusNanos​(long nanos)

返回此副本的副本，LocalDateTime其中添加了指定的纳秒数。
LocalDateTime plusSeconds​(long seconds)

返回此副本的副本，LocalDateTime其中添加了指定的秒数。
LocalDateTime plusWeeks​(long weeks)

返回此副本的副本，LocalDateTime其中添加了指定的周数。
LocalDateTime plusYears​(long years)

返回LocalDateTime带有指定年限的副本。

下面列举几个常用栗子：

  1. public static void main(String[] args) {
  2.     //获取当前时间
  3.     LocalDateTime localDateTime = LocalDateTime.now(ZoneId.systemDefault());
  4.     System.out.println("本地当前日期时间："+localDateTime);
  6.     //获取偏移时间
  7.     //偏移天(正数：往后偏移；负数：往过去时间偏移)
  8.     System.out.println("明日此时："+localDateTime.plusDays(1));
  9.     System.out.println("明日此时1："+localDateTime.minusDays(-1));
  10.     System.out.println("前天此时："+localDateTime.plusDays(-2));
  11.     //偏移时
  12.     System.out.println("当前时间后2个小时："+localDateTime.plusHours(2));
  13.     System.out.println("当前时间前5个小时："+localDateTime.plusHours(-5));
  14.     //偏移年
  15.     System.out.println("去年此时："+localDateTime.plusYears(-1));
  16.     //偏移月
  17.     System.out.println("下月此时："+localDateTime.plusMonths(1));
  18.     //偏移周
  19.     System.out.println("上周此时："+localDateTime.plusWeeks(-1));
  20. }

输出：

  1. 本地当前日期时间：2020-12-29T11:22:24.914
  2. 明日此时：2020-12-30T11:22:24.914
  3. 明日此时1：2020-12-30T11:22:24.914
  4. 前天此时：2020-12-27T11:22:24.914
  5. 当前时间后2个小时：2020-12-29T13:22:24.914
  6. 当前时间前5个小时：2020-12-29T06:22:24.914
  7. 去年此时：2019-12-29T11:22:24.914
  8. 下月此时：2021-01-29T11:22:24.914
  9. 上周此时：2020-12-22T11:22:24.914

2.2 ZonedDateTime

ZonedDateTime其实就是含有时区的LocalDateTime，其实就是LocalDateTime+ZoneId，其对照关系可以如图：

20201229164342942.png

所以，其对应的功能基本与上述一致，因此不再赘述！

2.3 ZoneId

ZoneId是时区ID类，主要包含了各时区信息！一般对时区没有要求的情况，我们会使用：

  1. ZoneId.systemDefault()

来设置默认时区！

通过源代码查看，目前常用的时区映射关系有如下这些：

  1. public static final Map<String, String> SHORT_IDS;
  3. /** 
  4. * 当前为ZoneId源码，除了   
  5. * 以下中文注释为作者个人翻译而来，非源码注释
  6. **/
  7. static {
  8.     Map<String, String> map = new HashMap<>(64);
  10.     //"Australia/Darwin","澳洲/达尔文"
  11.     map.put("ACT", "Australia/Darwin");
  13.     //"Australia/Sydney","澳洲/悉尼"
  14.     map.put("AET", "Australia/Sydney");
  16.     //"America/Argentina/Buenos_Aires","美洲/阿根廷/布宜诺斯艾利斯"
  17.     map.put("AGT", "America/Argentina/Buenos_Aires");
  19.     //"Africa/Cairo","非洲/开罗"
  20.     map.put("ART", "Africa/Cairo");
  22.     //"America/Anchorage","美洲/安克雷奇"
  23.     map.put("AST", "America/Anchorage");
  25.     //"America/Sao_Paulo","美洲/圣保罗"
  26.     map.put("BET", "America/Sao_Paulo");
  28.     //"Asia/Dhaka","亚洲/达卡"
  29.     map.put("BST", "Asia/Dhaka");
  31.     //"Africa/Harare","非洲/哈拉雷"
  32.     map.put("CAT", "Africa/Harare");
  34.     //"America/St_Johns","美洲/圣约翰"
  35.     map.put("CNT", "America/St_Johns");
  37.     //"America/Chicago","美洲/芝加哥"
  38.     map.put("CST", "America/Chicago");
  40.     //"Asia/Shanghai","亚洲/上海"
  41.     map.put("CTT", "Asia/Shanghai");
  43.     //"Africa/Addis_Ababa","非洲/亚的斯亚贝巴"
  44.     map.put("EAT", "Africa/Addis_Ababa");
  46.     //"Europe/Paris","欧洲/巴黎"
  47.     map.put("ECT", "Europe/Paris");
  49.     //"America/Indiana/Indianapolis","美洲/印第安纳州/印第安纳波利斯"
  50.     map.put("IET", "America/Indiana/Indianapolis");
  52.     //"Asia/Kolkata","亚洲/加尔各答"
  53.     map.put("IST", "Asia/Kolkata");
  55.     //"Asia/Tokyo","亚洲/东京"
  56.     map.put("JST", "Asia/Tokyo");
  58.     //"Pacific/Apia","太平洋/阿皮亚"
  59.     map.put("MIT", "Pacific/Apia");
  61.     //"Asia/Yerevan","亚洲/埃里温"
  62.     map.put("NET", "Asia/Yerevan");
  64.     //"Pacific/Auckland","太平洋/奥克兰"
  65.     map.put("NST", "Pacific/Auckland");
  67.     //"Asia/Karachi","亚洲/卡拉奇"
  68.     map.put("PLT", "Asia/Karachi");
  70.     //"America/Phoenix","美洲/凤凰城"
  71.     map.put("PNT", "America/Phoenix");
  73.     //"America/Puerto_Rico","美洲/波多黎各"
  74.     map.put("PRT", "America/Puerto_Rico");
  76.     //"America/Los_Angeles","美洲/洛杉矶"
  77.     map.put("PST", "America/Los_Angeles");
  79.     //"Pacific/Guadalcanal","太平洋/瓜达尔卡纳尔岛"
  80.     map.put("SST", "Pacific/Guadalcanal");
  82.     //"Asia/Ho_Chi_Minh","亚洲/胡志明市"
  83.     map.put("VST", "Asia/Ho_Chi_Minh");
  85.     //"-05:00","东部标准时间"（纽约、华盛顿）
  86.     map.put("EST", "-05:00");
  88.     //"-07:00","山地标准时间"
  89.     map.put("MST", "-07:00");
  91.     //"-10:00","夏威夷-阿留申标准时区"
  92.     map.put("HST", "-10:00");
  93.     SHORT_IDS = Collections.unmodifiableMap(map);
  94. }

举个栗子：

  1. System.out.println("美国纽约当前日期时间："+LocalDateTime.now(ZoneId.of("America/New_York")));
  3. //输出：
  4. 美国纽约当前日期时间：2020-12-29T04:10:53.257

2.4 Instant

Instant类，是包含时间线上的某一个瞬时点。

举个栗子：

  1. public static void main(String[] args) {
  2.     //获取当前时间
  3.     LocalDateTime localDateTime = LocalDateTime.now(ZoneId.systemDefault());
  4.     System.out.println("本地当前日期时间戳："+localDateTime.atZone(ZoneId.systemDefault()).toEpochSecond());
  5.     System.out.println();
  7.     Instant instant = Instant.from(localDateTime.atZone(ZoneId.systemDefault()).plusHours(-1));
  8.     System.out.println("前一小时此时的时间戳："+instant.getEpochSecond());
  9.     System.out.println("前一小时此时的毫秒数："+instant.toEpochMilli());
  10. }

输出：

  1. 本地当前日期时间戳：1609235707
  3. //刚好相差3600秒
  4. 前一小时此时的时间戳：1609232107
  5. 前一小时此时的毫秒数：1609232107078

2.5 时间工具类

  1. /**
  2.  * Date工具类
  3.  * @author Yangy
  4.  */
  5. public class DateUtils {
  7.     private static final ZoneId ZONE_ID = ZoneId.systemDefault();
  9.     /**
  10.      * LocalDateTime转化为Date
  11.      * 
  12.      * @param localDateTime
  13.      * @return
  14.      */
  15.     public static Date toDate(LocalDateTime localDateTime) {
  16.         return Date.from(localDateTime.atZone(ZONE_ID).toInstant());
  17.     }
  19.     /**
  20.      * LocalDateTime转化为Date
  21.      * 
  22.      * @param localDateTime
  23.      * @return
  24.      */
  25.     public static Date toDate(LocalDate localDate) {
  26.         return Date.from(localDate.atStartOfDay(ZONE_ID).toInstant());
  27.     }
  29.     /**
  30.      * Date转化为LocalDateTime
  31.      * 
  32.      * @param date
  33.      * @return
  34.      */
  35.     public static LocalDateTime toLocalDateTime(Date date) {
  36.         return LocalDateTime.ofInstant(date.toInstant(), ZONE_ID);
  37.     }
  39.     /**
  40.      * LocalDate转化为LocalDateTime
  41.      * 
  42.      * @param localDate
  43.      * @return
  44.      */
  45.     public static LocalDateTime toLocalDateTime(LocalDate localDate) {
  46.         return LocalDateTime.of(localDate, LocalTime.MIN);
  47.     }
  49.     /**
  50.      * Date转化为LocalDate
  51.      * 
  52.      * @param date
  53.      * @return
  54.      */
  55.     public static LocalDate toLocalDate(Date date) {
  56.         return date.toInstant().atZone(ZONE_ID).toLocalDate();
  57.     }
  59.     /**
  60.      * Date转化为字符串
  61.      * 
  62.      * @param date
  63.      * @param formatter
  64.      * @return
  65.      */
  66.     public static String format(Date date, DateFormatter formatter) {
  67.         LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZONE_ID);
  68.         return formatter.getDateTimeFormatter().format(localDateTime);
  69.     }
  71.     /**
  72.      * 字符串转化为Date
  73.      * 
  74.      * @param text
  75.      * @param formatter
  76.      * @return
  77.      */
  78.     public static Date parse(String text, DateFormatter formatter) {
  79.         return formatter.parse(text);
  80.     }
  82.     public static enum DateFormatter {
  84.         /**
  85.          * 格式yyyy
  86.          *
  87.          */
  88.         YEAR_FORMATTER(DateTimeFormatter.ofPattern("yyyy", Locale.CHINA)) {
  89.             @Override
  90.             public Date parse(String text) {
  91.                 Year year = Year.parse(text, dateTimeFormatter);
  92.                 return Date.from(year.atDay(1).atStartOfDay(ZONE_ID).toInstant());
  93.             }
  94.         },
  96.         /**
  97.          * 
  98.          * 格式yyyy-MM
  99.          *
  100.          */
  101.         YEAR_MONTH_FORMATTER(DateTimeFormatter.ofPattern("yyyy-MM", Locale.CHINA)) {
  102.             @Override
  103.             public Date parse(String text) {
  104.                 YearMonth yearMonth = YearMonth.parse(text, dateTimeFormatter);
  105.                 return Date.from(yearMonth.atDay(1).atStartOfDay(ZONE_ID).toInstant());
  106.             }
  107.         },
  109.         /**
  110.          * 
  111.          * 格式yyyy-MM-dd
  112.          * 
  113.          * @author Val Song Dec 17, 2017 7:26:25 PM
  114.          *
  115.          */
  116.         DATE_FORMATTER(DateTimeFormatter.ofPattern("yyyy-MM-dd", Locale.CHINA)) {
  117.             @Override
  118.             public Date parse(String text) {
  119.                 LocalDate localDate = LocalDate.parse(text, dateTimeFormatter);
  120.                 return Date.from(localDate.atStartOfDay(ZONE_ID).toInstant());
  121.             }
  122.         },
  124.         /**
  125.          * 格式yyyy-MM-dd HH:mm:ss
  126.          *
  127.          */
  128.         DATE_TIME_FORMATTER(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss", Locale.CHINA)) {
  129.             @Override
  130.             public Date parse(String text) {
  131.                 LocalDateTime localDateTime = LocalDateTime.parse(text, dateTimeFormatter);
  132.                 return Date.from(localDateTime.atZone(ZONE_ID).toInstant());
  133.             }
  134.         },
  136.         /**
  137.          * 格式yyyyMMdd_HHmmss
  138.          *
  139.          */
  140.         YYYYMMDD_HHMMSS_FORMATTER(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss", Locale.CHINA)) {
  141.             @Override
  142.             public Date parse(String text) {
  143.                 LocalDateTime localDateTime = LocalDateTime.parse(text, dateTimeFormatter);
  144.                 return Date.from(localDateTime.atZone(ZONE_ID).toInstant());
  145.             }
  146.         };
  148.         protected DateTimeFormatter dateTimeFormatter;
  150.         private DateFormatter(DateTimeFormatter dateTimeFormatter) {
  151.             this.dateTimeFormatter = dateTimeFormatter;
  152.         }
  154.         public DateTimeFormatter getDateTimeFormatter() {
  155.             return dateTimeFormatter;
  156.         }
  158.         public abstract Date parse(String text);
  159.     }
  161. }

3、总结

1.切记，LocalDate、LocalTime、LocalDateTime这几个类，都是没有设置时区的日期时间类，所以，对时区有要求的时候，必须手动设置指定时区；否则，采用默认时区即可！

2.除了国内，世界其他很多地区都有夏冬令时的区分！所以，业务针对时区和夏冬令时有区别的，需要注意这一点！

最后，希望此文如果对你有帮助的话，请点赞、留言、关注我吧！

扫描左侧二维码，即可查看作者公众号内的更多精彩内容，先感谢各位朋友的支持啦！！！

发表评论

表情：
评论列表 （有 0 条评论，318人围观）

还没有评论，来说两句吧...

相关阅读