本文共 15388 字，大约阅读时间需要 51 分钟。

基本概念

在计算机中，我们经常需要处理日期和时间。这是日期：

2019-11-20
2020-1-1

而时间有两种概念，一种是不带日期的时间，例如，12:30:59。另一种是带日期的时间，例如，2020-1-1 20:21:59，只有这种带日期的时间能唯一确定某个时刻，不带日期的时间是无法确定一个唯一时刻的。

本地时间

当我们说当前时刻是2019年11月20日早上8:15的时候，我们说的实际上是本地时间。在国内就是北京时间。在这个时刻，如果地球上不同地方的人们同时看一眼手表，他们各自的本地时间是不同的。

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

时区

因为光靠本地时间还无法唯一确定一个准确的时刻，所以我们还需要给本地时间加上一个时区。时区有好几种表示方式。

一种是以GMT或者UTC加时区偏移表示，例如：GMT+08:00或者UTC+08:00表示东八区。GMT和UTC可以认为基本是等价的，只是UTC使用更精确的原子钟计时，每隔几年会有一个闰秒，我们在开发程序的时候可以忽略两者的误差，因为计算机的时钟在联网的时候会自动与时间服务器同步时间。

另一种是缩写，例如，CST表示China Standard Time，也就是中国标准时间。但是CST也可以表示美国中部时间Central Standard Time USA，因此，缩写容易产生混淆，我们尽量不要使用缩写。

最后一种是以洲／城市表示，例如，Asia/Shanghai，表示上海所在地的时区。特别注意城市名称不是任意的城市，而是由国际标准组织规定的城市。

夏令时

时区还不是最复杂的，更复杂的是夏令时。所谓夏令时，就是夏天开始的时候，把时间往后拨1小时，夏天结束的时候，再把时间往前拨1小时。我们国家实行过一段时间夏令时，1992年就废除了，但是矫情的美国人到现在还在使用，所以时间换算更加复杂。

因为涉及到夏令时，相同的时区，如果表示的方式不同，转换出的时间是不同的。我们举个栗子：

对于2019-11-20和2019-6-20两个日期来说，假设北京人在纽约：

如果以GMT或者UTC作为时区，无论日期是多少，时间都是19:00； 如果以国家／城市表示，例如America／NewYork，虽然纽约也在西五区，但是，因为夏令时的存在，在不同的日期，GMT时间和纽约时间可能是不一样的。

本地化

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

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

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

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

存储时间的方式-时间戳

在计算机中，应该如何表示日期和时间呢？

我们经常看到的日期和时间表示方式如下：

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

如果直接以字符串的形式存储，那么不同的格式，不同的语言会让表示方式非常繁琐。

在理解日期和时间的表示方式之前，我们先要理解数据的存储和展示。

当我们定义一个整型变量并赋值时：

int n = 123400;

编译器会把上述字符串（程序源码就是一个字符串）编译成字节码。在程序的运行期，变量n指向的内存实际上是一个4字节区域：

注意到计算机内存除了二进制的0/1外没有其他任何格式。上述十六机制是为了简化表示。

当我们用System.out.println(n)打印这个整数的时候，实际上println()这个方法在内部把int类型转换成String类型，然后打印出字符串123400。

类似的，我们也可以以十六进制的形式打印这个整数，或者，如果n表示一个价格，我们就以$123,400.00的形式来打印它：

import java.text.*;import java.util.*;public class Main {       public static void main(String[] args) {           int n = 123400;        // 123400        System.out.println(n);        // 1e208        System.out.println(Integer.toHexString(n));        // $123,400.00        System.out.println(NumberFormat.getCurrencyInstance(Locale.US).format(n));    }}

可见，整数123400是数据的存储格式，它的存储格式非常简单。而我们打印的各种各样的字符串，则是数据的展示格式。展示格式有多种形式，但本质上它就是一个转换方法：

String toDisplay(int n) { … }

理解了数据的存储和展示，我们回头看看以下几种日期和时间：

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表示从从1970年1月1日零点GMT时区到该时刻一共经历了1574208900秒，换算成伦敦、北京和纽约时间分别是：

1574208900 = 北京时间2019-11-20 8:15:00
= 伦敦时间2019-11-20 0:15:00
= 纽约时间2019-11-19 19:15:00

因此，在计算机中，只需要存储一个整数1574208900表示某一时刻。当需要显示为某一地区的当地时间时，我们就把它格式化为一个字符串：

String displayDateTime(int n, String timezone) { … }

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

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

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

long t = 1574208900123L;

转换成北京时间就是2019-11-20T8:15:00.123。要获取当前时间戳，可以使用System.currentTimeMillis()，这是Java程序获取时间戳最常用的方法。

标注库API

我们再来看一下Java标准库提供的API。Java标准库有两套处理日期和时间的API：

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

为什么会有新旧两套API呢？因为历史遗留原因，旧的API存在很多问题，所以引入了新的API。

那么我们能不能跳过旧的API直接用新的API呢？如果涉及到遗留代码就不行，因为很多遗留代码仍然使用旧的API，所以目前仍然需要对旧的API有一定了解，很多时候还需要在新旧两种对象之间进行转换。

本节我们快速讲解旧API的常用类型和方法。

旧API

Date

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

public class Date implements Serializable, Cloneable, Comparable
{
    private transient long fastTime;
    …
}

我们来看Date的基本用法：

import java.util.*;public class Main {       public static void main(String[] args) {           // 获取当前时间:        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        // 转换为String:        System.out.println(date.toString());        // 转换为GMT时区:        System.out.println(date.toGMTString());        // 转换为本地时区:        System.out.println(date.toLocaleString());    }}

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

格式化输出

打印本地时区表示的日期和时间时，不同的计算机可能会有不同的结果。如果我们想要针对用户的偏好精确地控制日期和时间的格式，就可以使用SimpleDateFormat对一个Date进行转换。它用预定义的字符串表示格式化：

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

我们来看如何以自定义的格式输出：

import java.text.*;import java.util.*;public class Main {       public static void main(String[] args) {           // 获取当前时间:        Date date = new Date();        var sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        System.out.println(sdf.format(date));    }}

Java的格式化预定义了许多不同的格式，我们以MMM和E为例：

import java.text.*;import java.util.*;public class Main {       public static void main(String[] args) {           // 获取当前时间:        Date date = new Date();        var sdf = new SimpleDateFormat("E MMM dd, yyyy");        System.out.println(sdf.format(date));    }}

上述代码在不同的语言环境会打印出类似Sun Sep 15, 2019这样的日期。可以从JDK文档查看详细的格式说明。一般来说，字母越长，输出越长。以M为例，假设当前月份是9月：

M：输出9
MM：输出09
MMMM：输出September

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

Calendar

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

import java.util.*;public class Main {       public static void main(String[] args) {           // 获取当前时间:        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);    }}

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

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

import java.text.*;import java.util.*;public class Main {       public static void main(String[] args) {           // 当前时间:        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    }}

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

TimeZone

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

import java.util.*;public class Main {       public static void main(String[] args) {           TimeZone tzDefault = TimeZone.getDefault(); // 当前时区        TimeZone tzGMT9 = TimeZone.getTimeZone("GMT+09:00"); // GMT+9:00时区        TimeZone tzNY = TimeZone.getTimeZone("America/New_York"); // 纽约时区        System.out.println(tzDefault.getID()); // Asia/Shanghai        System.out.println(tzGMT9.getID()); // GMT+09:00        System.out.println(tzNY.getID()); // America/New_York    }}

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

时区转换

有了时区，我们就可以对指定时间进行转换。例如，下面的例子演示了如何将北京时间2019-11-20 8:15:00转换为纽约时间：

import java.text.*;import java.util.*;public class Main {       public static void main(String[] args) {           // 当前时间:        Calendar c = Calendar.getInstance();        // 清除所有:        c.clear();        // 设置为北京时区:        c.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));        // 设置年月日时分秒:        c.set(2019, 10 /* 11月 */, 20, 8, 15, 0);        // 显示时间:        var 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    }}

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

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

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

加减日期时间

Calendar也可以对日期和时间进行简单的加减：

import java.text.*;import java.util.*;public class Main {       public static void main(String[] args) {           // 当前时间:        Calendar c = Calendar.getInstance();        // 清除所有:        c.clear();        // 设置年月日时分秒:        c.set(2019, 10 /* 11月 */, 20, 8, 15, 0);        // 加5天并减去2小时:        c.add(Calendar.DAY_OF_MONTH, 5);        c.add(Calendar.HOUR_OF_DAY, -2);        // 显示时间:        var 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    }}

新API

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

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

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

和旧的API相比，新API严格区分了时刻、本地日期、本地时间和带时区的日期时间，并且，对日期和时间进行运算更加方便。

LocalDateTime

我们首先来看最常用的LocalDateTime，它表示一个本地日期和时间：

import java.time.*;public class Main {       public static void main(String[] args) {           LocalDate d = LocalDate.now(); // 当前日期        LocalTime t = LocalTime.now(); // 当前时间        LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间        System.out.println(d); // 严格按照ISO 8601格式打印        System.out.println(t); // 严格按照ISO 8601格式打印        System.out.println(dt); // 严格按照ISO 8601格式打印    }}

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

DateTimeFormatter

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

时间加减

LocalDateTime提供了对日期和时间进行加减的非常简单的链式调用：

import java.time.*;public class Main {       public static void main(String[] args) {           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减去1个月得到的结果是2019-09-30，因为9月没有31日。

调整时间

对日期和时间进行调整则使用withXxx()方法，例如：withHour(15)会把10:11:12变为15:11:12：

调整年：withYear()
调整月：withMonth()
调整日：withDayOfMonth()
调整时：withHour()
调整分：withMinute()
调整秒：withSecond()

示例代码如下：

import java.time.*;public class Main {       public static void main(String[] args) {           LocalDateTime dt = LocalDateTime.of(2019, 10, 26, 20, 30, 59);        System.out.println(dt);        // 日期变为31日:        LocalDateTime dt2 = dt.withDayOfMonth(31);        System.out.println(dt2); // 2019-10-31T20:30:59        // 月份变为9:        LocalDateTime dt3 = dt2.withMonth(9);        System.out.println(dt3); // 2019-09-30T20:30:59    }}

时间比较

要判断两个LocalDateTime的先后，可以使用isBefore()、isAfter()方法，对于LocalDate和LocalTime类似：

import java.time.*;public class Main {       public static void main(String[] args) {           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")));    }}

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

Duration和Period

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

import java.time.*;public class Main {       public static void main(String[] args) {           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    }}

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

ZonedDateTime

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

Instant

Instant表示高精度时间戳。我们已经讲过，计算机存储的当前时间，本质上只是一个不断递增的整数。Java提供的System.currentTimeMillis()返回的就是以毫秒表示的当前时间戳：

import java.time.*;public class Main {       public static void main(String[] args) {           Instant now = Instant.now();        System.out.println(now.getEpochSecond()); // 秒        System.out.println(now.toEpochMilli()); // 毫秒    }}

打印的结果类似：

1568568760
1568568760316

实际上，Instant内部只有两个核心字段：

public final class Instant implements ... {
    private final long seconds;
    private final int nanos;
}

一个是以秒为单位的时间戳，一个是更精确的纳秒精度。它和System.currentTimeMillis()返回的long相比，只是多了更高精度的纳秒。

既然Instant就是时间戳，那么，给它附加上一个时区，就可以创建出ZonedDateTime：

// 以指定时间戳创建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

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

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

新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(ts);

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

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

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

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

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

数据库类型       | 旧API（Date） | 新API（LocalDateTime）
-----------------|--------------|-------------------
TIMESTAMP        | Date         | LocalDateTime
DATE           | Date         | LocalDate
TIME           | Date         | LocalTime
DATETIME        | Date         | LocalDateTime

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

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

import java.time.*;import java.time.format.*;import java.util.Locale;public class Main {       public static void main(String[] args) {           long ts = 1574208900000L;        System.out.println(timestampToString(ts, Locale.CHINA, "Asia/Shanghai"));        System.out.println(timestampToString(ts, Locale.US, "America/New_York"));    }    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)));
    }}

结果如下：

2019年11月20日 上午8:15
Nov 19, 2019, 7:15 PM

通过以上内容，希望对日期和时间的处理有了更深入的理解。

转载地址：http://gzum.baihongyu.com/