持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第2天，点击查看活动详情

一、概念

时区

全球一共分为24个时区，伦敦所在的时区称为标准时区，其他时区按东／西偏移的小时区分，北京所在的时区是东八区。

表示方式：以GMT或者UTC加时区偏移表示，例如：GMT+08:00或者UTC+08:00表示东八区。

GMT和UTC可以认为基本是等价的，只是UTC使用更精确的原子钟计时，每隔几年会有一个闰秒，我们在开发程序的时候可以忽略两者的误差，因为计算机的时钟在联网的时候会自动与时间服务器同步时间。

夏令时

所谓夏令时，就是夏天开始的时候，把时间往后拨1小时，夏天结束的时候，再把时间往前拨1小时。

实行夏令时的不同地区，进入和退出夏令时的时间很可能是不同的。同一个地区，根据历史上是否实行过夏令时，标准时间在不同年份换算成当地时间也是不同的。因此，计算夏令时，没有统一的公式，必须按照一组给定的规则来算，并且，该规则要定期更新。

计算夏令时请使用标准库提供的相关类，不要试图自己计算夏令时。

本地化

在计算机中，通常使用Locale表示一个国家或地区的日期、时间、数字、货币等格式。Locale由语言_国家的字母缩写构成，例如，zh_CN表示中文+中国，en_US表示英文+美国。语言使用小写，国家使用大写。

对于日期来说，不同的Locale，例如，中国和美国的表示方式如下：

• zh_CN：2016-11-30
• en_US：11/30/2016

计算机用Locale在日期、时间、货币和字符串之间进行转换。一个电商网站会根据用户所在的Locale对用户显示如下：

	中国用户	美国用户
购买价格	12000.00	12,000.00
购买日期	2016-11-30	11/30/2016

二、Date和Calendar

以下几种日期和时间：

• 2019-11-20 0:15:01 GMT+00:00
• 2019年11月20日8:15:01
• 11/19/2019 19:15:01 America/New_York

它们实际上是数据的展示格式，分别按英国时区、中国时区、纽约时区对同一个时刻进行展示。而这个“同一个时刻”在计算机中存储的本质上只是一个整数，我们称它为Epoch Time。Epoch Time是计算从1970年1月1日零点（格林威治时区／GMT+00:00）到现在所经历的秒数。因此，在计算机中，只需要存储一个整数1574208900表示某一时刻。当需要显示为某一地区的当地时间时，我们就把它格式化为一个字符串。

Epoch Time又称为时间戳，在不同的编程语言中，会有几种存储方式：

• 以秒为单位的整数：1574208900，缺点是精度只能到秒；
• 以毫秒为单位的整数：1574208900123，最后3位表示毫秒数；
• 以秒为单位的浮点数：1574208900.123，小数点后面表示零点几秒。

它们之间转换非常简单。而在Java程序中，时间戳通常是用long表示的毫秒数，即：

 long t = 1574208900123L;

要获取当前时间戳，可以使用System.currentTimeMillis()，这是Java程序获取时间戳最常用的方法。

标准库API

Java标准库有两套处理日期和时间的API：

• 一套定义在java.util这个包里面，主要包括Date、Calendar和TimeZone这几个类；
• 一套新的API是在Java 8引入的，定义在java.time这个包里面，主要包括LocalDateTime、ZonedDateTime、ZoneId等。

Date

java.util.Date是用于表示一个日期和时间的对象，注意与java.sql.Date区分，后者用在数据库中。如果观察Date的源码，可以发现它实际上存储了一个long类型的以毫秒表示的时间戳。

注意getYear()返回的年份必须加上1900，getMonth()返回的月份是011分别表示112月，所以要加1，而getDate()返回的日期范围是1~31，又不能加1。

可以使用SimpleDateFormat对一个Date进行转换。它用预定义的字符串表示格式化：

• yyyy：年
• MM：月
• dd: 日
• HH: 小时
• mm: 分钟
• ss: 秒

字母越长，输出越长。以M为例，假设当前月份是9月：

• M：输出9
• MM：输出09
• MMM：输出Sep
• MMMM：输出September

Date对象有几个严重的问题：它不能转换时区，除了toGMTString()可以按GMT+0:00输出外，Date总是以当前计算机系统的默认时区为基础进行输出。此外，我们也很难对日期和时间进行加减，计算两个日期相差多少天，计算某个月第一个星期一的日期等。

 package com.study.date;
 ​
 import java.text.NumberFormat;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Locale;
 ​
 public class DateDemo {
     public static void main(String[] args) {
         demo1();
         System.out.println("========================");
 ​
         demo2();
         System.out.println("========================");
 ​
         demo3();
     }
 ​
     // 相同的数据，展示成不同的格式
     public static void demo1() {
         int n = 123400;
         System.out.println(n); // 123400
         System.out.println(Integer.toHexString(n)); // 1e208
         System.out.println(NumberFormat.getCurrencyInstance(Locale.US).format(n)); // $123,400.00
     }
 ​
     // Date 基本用法
     public static void demo2() {
         // 获取当前时间:
         Date date = new Date();
         System.out.println(date.getYear() + 1900); // 必须加上1900
         System.out.println(date.getMonth() + 1); // 0~11，必须加上1
         System.out.println(date.getDate()); // 日期 1~31，不能加1
         System.out.println(date.getDay()); // 星期
         // 转换为String:
         System.out.println(date.toString()); // Sat Oct 08 11:57:34 CST 2022
         // 转换为GMT时区:
         System.out.println(date.toGMTString()); // 8 Oct 2022 03:57:34 GMT
         // 转换为本地时区:
         System.out.println(date.toLocaleString()); // 2022-10-8 12:04:12
     }
 ​
     public static void demo3() {
         Date date = new Date();
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 2022-10-08 12:10:39
         System.out.println(sdf.format(date));
 ​
         SimpleDateFormat sdf2 = new SimpleDateFormat("E MMM dd, yyyy"); // 星期六 十月 08, 2022
         System.out.println(sdf2.format(date));
     }
 }
 ​

Calendar

Calendar可以用于获取并设置年、月、日、时、分、秒，它和Date比，主要多了一个可以做简单的日期和时间运算的功能。

注意到Calendar获取年月日这些信息变成了get(int field)，返回的年份不必转换，返回的月份仍然要加1，返回的星期要特别注意，1~7分别表示周日，周一，……，周六。

Calendar只有一种方式获取，即Calendar.getInstance()，而且一获取到就是当前时间。如果我们想给它设置成特定的一个日期和时间，就必须先清除所有字段。

利用Calendar.getTime()可以将一个Calendar对象转换成Date对象，然后就可以用SimpleDateFormat进行格式化了。

TimeZone

Calendar和Date相比，它提供了时区转换的功能。时区用TimeZone对象表示。

时区的唯一标识是以字符串表示的ID，我们获取指定TimeZone对象也是以这个ID为参数获取，GMT+09:00、Asia/Shanghai都是有效的时区ID。要列出系统支持的所有ID，请使用TimeZone.getAvailableIDs()。

 package com.study.date;
 ​
 import java.text.SimpleDateFormat;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.TimeZone;
 ​
 public class CalendarDemo {
     public static void main(String[] args) {
         demo1();
         System.out.println("========================");
 ​
         demo2();
         System.out.println("========================");
 ​
         demo3();
         System.out.println("========================");
 ​
         demo4();
     }
 ​
     public static void demo1() {
         // 获取当前时间:
         Calendar c = Calendar.getInstance();
         int y = c.get(Calendar.YEAR);
         int m = 1 + c.get(Calendar.MONTH);
         int d = c.get(Calendar.DAY_OF_MONTH);
         int w = c.get(Calendar.DAY_OF_WEEK);
         int hh = c.get(Calendar.HOUR_OF_DAY);
         int mm = c.get(Calendar.MINUTE);
         int ss = c.get(Calendar.SECOND);
         int ms = c.get(Calendar.MILLISECOND);
         System.out.println(y + "-" + m + "-" + d + " " + w + " " + hh + ":" + mm + ":" + ss + "." + ms); // 2022-10-8 7 12:23:23.846
     }
 ​
     public static void demo2() {
         // 当前时间:
         Calendar c = Calendar.getInstance();
         // 清除所有:
         c.clear();
         // 设置2019年:
         c.set(Calendar.YEAR, 2019);
         // 设置9月:注意8表示9月:
         c.set(Calendar.MONTH, 8);
         // 设置2日:
         c.set(Calendar.DATE, 2);
         // 设置时间:
         c.set(Calendar.HOUR_OF_DAY, 21);
         c.set(Calendar.MINUTE, 22);
         c.set(Calendar.SECOND, 23);
         System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(c.getTime())); // 2019-09-02 21:22:23
     }
 ​
     // 将北京时间2019-11-20 8:15:00转换为纽约时间
     public static void demo3() {
         // 当前时间:
         Calendar c = Calendar.getInstance();
         // 清除所有:
         c.clear();
         // 设置为北京时区:
         c.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
         // 设置年月日时分秒:
         c.set(2019, 10 /* 11月 */, 20, 8, 15, 0);
         // 显示时间:
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         sdf.setTimeZone(TimeZone.getTimeZone("America/New_York"));
         System.out.println(sdf.format(c.getTime()));
         // 2019-11-19 19:15:00
     }
 ​
     // 对日期和时间进行简单的加减
     public static void demo4() {
         // 当前时间:
         Calendar c = Calendar.getInstance();
         // 清除所有:
         c.clear();
         // 设置年月日时分秒:
         c.set(2019, Calendar.NOVEMBER, 20, 8, 15, 0);
         // 加5天并减去2小时:
         c.add(Calendar.DAY_OF_MONTH, 5);
         c.add(Calendar.HOUR_OF_DAY, -2);
         // 显示时间:
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         Date d = c.getTime();
         System.out.println(sdf.format(d));
         // 2019-11-25 6:15:00
     }
 }
 ​

可见，利用Calendar进行时区转换的步骤是：

1. 清除所有字段；
2. 设定指定时区；
3. 设定日期和时间；
4. 创建SimpleDateFormat并设定目标时区；
5. 格式化获取的Date对象（注意Date对象无时区信息，时区信息存储在SimpleDateFormat中）。

因此，本质上时区转换只能通过SimpleDateFormat在显示的时候完成。

三、LocalDateTime

从Java 8开始，java.time包提供了新的日期和时间API，主要涉及的类型有：

• 本地日期和时间：LocalDateTime，LocalDate，LocalTime；
• 带时区的日期和时间：ZonedDateTime；
• 时刻：Instant；
• 时区：ZoneId，ZoneOffset；
• 时间间隔：Duration。

以及一套新的用于取代SimpleDateFormat的格式化类型DateTimeFormatter。

和旧的API相比，新API严格区分了时刻、本地日期、本地时间和带时区的日期时间，并且，提供了对日期和时间进行加减的非常简单的链式调用。

此外，新API修正了旧API不合理的常量设计：

• Month的范围用1~12表示1月到12月；
• Week的范围用1~7表示周一到周日。

最后，新API的类型几乎全部是不变类型（和String类似），可以放心使用不必担心被修改。对日期和时间进行加减，或者调整日期和时间，它总是返回新对象。

本地日期和时间通过now()获取到的总是以当前默认时区返回的，和旧API不同，LocalDateTime、LocalDate和LocalTime默认严格按照ISO 8601规定的日期和时间格式进行打印。

注意ISO 8601规定的日期和时间分隔符是T。标准格式如下：

• 日期：yyyy-MM-dd
• 时间：HH:mm:ss
• 带毫秒的时间：HH:mm:ss.SSS
• 日期和时间：yyyy-MM-dd'T'HH:mm:ss
• 带毫秒的日期和时间：yyyy-MM-dd'T'HH:mm:ss.SSS

要判断两个LocalDateTime的先后，可以使用isBefore()、isAfter()方法

注意到LocalDateTime无法与时间戳进行转换，因为LocalDateTime没有时区，无法确定某一时刻。后面我们要介绍的ZonedDateTime相当于LocalDateTime加时区的组合，它具有时区，可以与long表示的时间戳进行转换。

如果要自定义输出的格式，或者要把一个非ISO 8601格式的字符串解析成LocalDateTime，可以使用新的DateTimeFormatter。

Duration和Period

Duration表示两个时刻之间的时间间隔。另一个类似的Period表示两个日期之间的天数

注意到两个LocalDateTime之间的差值使用Duration表示，类似PT1235H10M30S，表示1235小时10分钟30秒。而两个LocalDate之间的差值用Period表示，类似P1M21D，表示1个月21天。

Duration和Period的表示方法也符合ISO 8601的格式，它以P...T...的形式表示，P...T之间表示日期间隔，T后面表示时间间隔。如果是PT...的格式表示仅有时间间隔。利用ofXxx()或者parse()方法也可以直接创建Duration

 package com.study.date;
 ​
 import java.time.*;
 import java.time.format.DateTimeFormatter;
 import java.time.temporal.TemporalAdjusters;
 ​
 public class LocalDateTimeDemo {
     public static void main(String[] args) {
         demo1();
         System.out.println("========================");
 ​
         demo2();
         System.out.println("========================");
 ​
         demo3();
         System.out.println("========================");
 ​
         demo4();
         System.out.println("========================");
 ​
         demo5();
     }
 ​
     private static void demo1() {
         LocalDate d = LocalDate.now(); // 当前日期
         LocalTime t = LocalTime.now(); // 当前时间
         LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间
         System.out.println(d); // 严格按照ISO 8601格式打印 2022-10-08
         System.out.println(t); // 15:58:33.308
         System.out.println(dt); // 2022-10-08T15:58:33.308
 ​
         d = dt.toLocalDate(); // 转换到当前日期
         t = dt.toLocalTime(); // 转换到当前时间
         System.out.println(d);
         System.out.println(t);
         System.out.println("=============");
 ​
         // 通过指定的日期和时间创建LocalDateTime
         LocalDate d2 = LocalDate.of(2019, 11, 30); // 2019-11-30, 注意11=11月
         LocalTime t2 = LocalTime.of(15, 16, 17); // 15:16:17
         LocalDateTime dt2 = LocalDateTime.of(2019, 11, 30, 15, 16, 17);
         LocalDateTime dt3 = LocalDateTime.of(d2, t2);
         System.out.println(dt2);
         System.out.println(dt3);
         System.out.println("=============");
 ​
         // 将字符串转换为 LocalDateTime
         LocalDateTime dt4 = LocalDateTime.parse("2019-11-19T15:16:17");
         LocalDate d4 = LocalDate.parse("2019-11-19");
         LocalTime t4 = LocalTime.parse("15:16:17");
         System.out.println(dt4);
         System.out.println(d4);
         System.out.println(t4);
     }
 ​
     private static void demo2() {
         // 自定义格式化:
         DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
         System.out.println(dtf.format(LocalDateTime.now()));
 ​
         // 用自定义格式解析:
         LocalDateTime dt2 = LocalDateTime.parse("2019/11/30 15:16:17", dtf);
         System.out.println(dt2);
     }
 ​
     private static void demo3() {
         LocalDateTime dt = LocalDateTime.of(2019, 10, 26, 20, 30, 59);
         System.out.println(dt);
         // 加5天减3小时:
         LocalDateTime dt2 = dt.plusDays(5).minusHours(3);
         System.out.println(dt2); // 2019-10-31T17:30:59
         // 减1月:
         LocalDateTime dt3 = dt2.minusMonths(1);
         System.out.println(dt3); // 2019-09-30T17:30:59
 ​
         // 注意到调整月份时，会相应地调整日期，即把2019-10-31的月份调整为9时，日期也自动变为30
         LocalDateTime dt4 = dt.withDayOfMonth(31);
         System.out.println(dt4);
         System.out.println(dt4.withMonth(9));
         System.out.println("=============");
 ​
         // 本月第一天0:00时刻:
         LocalDateTime firstDay = LocalDate.now().withDayOfMonth(1).atStartOfDay();
         System.out.println(firstDay);
         // 本月最后1天:
         LocalDate lastDay = LocalDate.now().with(TemporalAdjusters.lastDayOfMonth());
         System.out.println(lastDay);
         // 下月第1天:
         LocalDate nextMonthFirstDay = LocalDate.now().with(TemporalAdjusters.firstDayOfNextMonth());
         System.out.println(nextMonthFirstDay);
         // 本月第1个周一:
         LocalDate firstWeekday = LocalDate.now().with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));
         System.out.println(firstWeekday);
     }
 ​
     private static void demo4() {
         LocalDateTime now = LocalDateTime.now();
         LocalDateTime target = LocalDateTime.of(2019, 11, 19, 8, 15, 0);
         System.out.println(now.isBefore(target));
         System.out.println(LocalDate.now().isBefore(LocalDate.of(2019, 11, 19)));
         System.out.println(LocalTime.now().isAfter(LocalTime.parse("08:15:00")));
     }
 ​
     private static void demo5() {
         LocalDateTime start = LocalDateTime.of(2019, 11, 19, 8, 15, 0);
         LocalDateTime end = LocalDateTime.of(2020, 1, 9, 19, 25, 30);
         Duration d = Duration.between(start, end);
         System.out.println(d); // PT1235H10M30S
 ​
         Period p = LocalDate.of(2019, 11, 19).until(LocalDate.of(2020, 1, 9));
         System.out.println(p); // P1M21D
 ​
         Duration d1 = Duration.ofHours(10); // 10 hours
         Duration d2 = Duration.parse("P1DT2H3M"); // 1 day, 2 hours, 3 minutes
         System.out.println(d1);
         System.out.println(d2);
     }
 }
 ​

四、ZonedDateTime

LocalDateTime总是表示本地日期和时间，要表示一个带时区的日期和时间，我们就需要ZonedDateTime。

可以简单地把ZonedDateTime理解成LocalDateTime加ZoneId。ZoneId是java.time引入的新的时区类，注意和旧的java.util.TimeZone区别。

创建一个ZonedDateTime对象的方式

• ZonedDateTime.now()方法返回当前时间
• 通过给一个LocalDateTime附加一个ZoneId，就可以变成ZonedDateTime

ZonedDateTime仍然提供了plusDays()等加减操作

时区转换

要特别注意，时区转换的时候，由于夏令时的存在，不同的日期转换的结果很可能是不同的。千万不要自己计算时差，否则难以正确处理夏令时。

有了ZonedDateTime，将其转换为本地时间就非常简单：

 ZonedDateTime zdt = ...
 LocalDateTime ldt = zdt.toLocalDateTime();

转换为LocalDateTime时，直接丢弃了时区信息。

 package com.study.date;
 ​
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 ​
 public class ZonedDateTimeDemo {
     public static void main(String[] args) {
         demo1();
         System.out.println("========================");
 ​
         demo2();
     }
 ​
     private static void demo1() {
         ZonedDateTime zbj = ZonedDateTime.now(); // 默认时区
         ZonedDateTime zny = ZonedDateTime.now(ZoneId.of("America/New_York")); // 用指定时区获取当前时间
         System.out.println(zbj);
         System.out.println(zny);
 ​
         LocalDateTime ldt = LocalDateTime.of(2019, 9, 15, 15, 16, 17);
         ZonedDateTime zbj2 = ldt.atZone(ZoneId.systemDefault());
         ZonedDateTime zny2 = ldt.atZone(ZoneId.of("America/New_York"));
         System.out.println(zbj2);
         System.out.println(zny2);
     }
 ​
     // 将北京时间转换为纽约时间 withZoneSameInstant
     private static void demo2() {
         // 以中国时区获取当前时间:
         ZonedDateTime zbj = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
         // 转换为纽约时间:
         ZonedDateTime zny = zbj.withZoneSameInstant(ZoneId.of("America/New_York"));
         System.out.println(zbj);
         System.out.println(zny);
     }
 }
 ​

五、DateTimeFormatter

使用旧的Date对象时，我们用SimpleDateFormat进行格式化显示。使用新的LocalDateTime或ZonedDateTime时，我们要进行格式化显示，就要使用DateTimeFormatter。

和SimpleDateFormat不同的是，DateTimeFormatter不但是不变对象，它还是线程安全的。因为SimpleDateFormat不是线程安全的，使用的时候，只能在方法内部创建新的局部变量。而DateTimeFormatter可以只创建一个实例，到处引用。

 package com.study.date;
 ​
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Locale;
 ​
 public class DateTimeFormatterDemo {
     public static void main(String[] args) {
         ZonedDateTime zdt = ZonedDateTime.now();
         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm ZZZZ");
         System.out.println(formatter.format(zdt));
 ​
         DateTimeFormatter zhFormatter = DateTimeFormatter.ofPattern("yyyy MMM dd EE HH:mm", Locale.CHINA);
         System.out.println(zhFormatter.format(zdt)); // 2022 十月 08 星期六 17:34
         zhFormatter = DateTimeFormatter.ofPattern("yyyy MMM dd EE HH:mm", Locale.US);
         System.out.println(zhFormatter.format(zdt)); // 2022 Oct 08 Sat 17:34
 ​
         DateTimeFormatter usFormatter = DateTimeFormatter.ofPattern("E, MMMM/dd/yyyy HH:mm", Locale.US);
         System.out.println(usFormatter.format(zdt)); // Sat, October/08/2022 17:34
         usFormatter = DateTimeFormatter.ofPattern("E, MMMM/dd/yyyy HH:mm", Locale.CHINA);
         System.out.println(usFormatter.format(zdt)); // 星期六, 十月/08/2022 17:34
 ​
         // 通过DateTimeFormatter预定义的几个静态变量来引用
         System.out.println(DateTimeFormatter.ISO_DATE.format(zdt));
         System.out.println(DateTimeFormatter.ISO_DATE_TIME.format(zdt));
     }
 }
 ​

六、Instant

Java提供的System.currentTimeMillis()返回的就是以毫秒表示的当前时间戳。这个当前时间戳在java.time中以Instant类型表示，我们用Instant.now()获取当前时间戳，效果和System.currentTimeMillis()类似。

Instant内部只有两个核心字段：一个是以秒为单位的时间戳，一个是更精确的纳秒精度。它和System.currentTimeMillis()返回的long相比，只是多了更高精度的纳秒。

既然Instant就是时间戳，那么，给它附加上一个时区，就可以创建出ZonedDateTime，继而可以获得了对应时区的LocalDateTime。

 ┌─────────────┐
 │LocalDateTime│────┐
 └─────────────┘    │    ┌─────────────┐
                    ├───>│ZonedDateTime│
 ┌─────────────┐    │    └─────────────┘
 │   ZoneId    │────┘           ▲
 └─────────────┘      ┌─────────┴─────────┐
                      │                   │
                      ▼                   ▼
               ┌─────────────┐     ┌─────────────┐
               │   Instant   │<───>│    long     │
               └─────────────┘     └─────────────┘

 package com.study.date;
 ​
 import java.time.Instant;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 ​
 public class InstantDemo {
     public static void main(String[] args) {
         Instant now = Instant.now();
         System.out.println(now.getEpochSecond()); // 秒
         System.out.println(now.toEpochMilli()); // 毫秒
 ​
         // 以指定时间戳创建Instant:
         Instant ins = Instant.ofEpochSecond(1568568760);
         ZonedDateTime zdt = ins.atZone(ZoneId.systemDefault());
         System.out.println(zdt); // 2019-09-16T01:32:40+08:00[Asia/Shanghai]
     }
 }
 ​

七、API转换

旧API转新API

如果要把旧式的Date或Calendar转换为新API对象，可以通过toInstant()方法转换为Instant对象，再继续转换为ZonedDateTime

 // Date -> Instant:
 Instant ins1 = new Date().toInstant();
 ​
 // Calendar -> Instant -> ZonedDateTime:
 Calendar calendar = Calendar.getInstance();
 Instant ins2 = calendar.toInstant();
 ZonedDateTime zdt = ins2.atZone(calendar.getTimeZone().toZoneId());

新API转旧API

如果要把新的ZonedDateTime转换为旧的API对象，只能借助long型时间戳做一个“中转”

 // ZonedDateTime -> long:
 ZonedDateTime zdt = ZonedDateTime.now();
 long ts = zdt.toEpochSecond() * 1000;
 ​
 // long -> Date:
 Date date = new Date(ts);
 ​
 // long -> Calendar:
 Calendar calendar = Calendar.getInstance();
 calendar.clear();
 calendar.setTimeZone(TimeZone.getTimeZone(zdt.getZone().getId()));
 calendar.setTimeInMillis(zdt.toEpochSecond() * 1000);

在数据库中存储日期和时间

除了旧式的java.util.Date，我们还可以找到另一个java.sql.Date，它继承自java.util.Date，但会自动忽略所有时间相关信息。这个奇葩的设计原因要追溯到数据库的日期与时间类型。

在数据库中，也存在几种日期和时间类型：

• DATETIME：表示日期和时间；
• DATE：仅表示日期；
• TIME：仅表示时间；
• TIMESTAMP：和DATETIME类似，但是数据库会在创建或者更新记录的时候同时修改TIMESTAMP。

在使用Java程序操作数据库时，我们需要把数据库类型与Java类型映射起来。下表是数据库类型与Java新旧API的映射关系：

数据库	对应Java类（旧）	对应Java类（新）
DATETIME	java.util.Date	LocalDateTime
DATE	java.sql.Date	LocalDate
TIME	java.sql.Time	LocalTime
TIMESTAMP	java.sql.Timestamp	LocalDateTime

实际上，在数据库中，我们需要存储的最常用的是时刻（Instant），因为有了时刻信息，就可以根据用户自己选择的时区，显示出正确的本地时间。所以，最好的方法是直接用长整数long表示，在数据库中存储为BIGINT类型。

通过存储一个long型时间戳，我们可以编写一个timestampToString()的方法，非常简单地为不同用户以不同的偏好来显示不同的本地时间

 package com.study.date;
 ​
 import java.time.Instant;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.time.format.FormatStyle;
 import java.util.Locale;
 ​
 public class UtilDemo {
     public static void main(String[] args) {
         long ts = 1574208900000L;
         // 2019-11-20 上午8:15
         System.out.println(timestampToString(ts, Locale.CHINA, "Asia/Shanghai"));
         // Nov 19, 2019 7:15 PM
         System.out.println(timestampToString(ts, Locale.US, "America/New_York"));
     }
 ​
     public static String timestampToString(long epochMilli, Locale lo, String zoneId) {
         Instant ins = Instant.ofEpochMilli(epochMilli);
         DateTimeFormatter f = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM, FormatStyle.SHORT);
         return f.withLocale(lo).format(ZonedDateTime.ofInstant(ins, ZoneId.of(zoneId)));
     }
 }
 ​