Skip to content

Latest commit

 

History

History
608 lines (399 loc) · 20.3 KB

date&time.md

File metadata and controls

608 lines (399 loc) · 20.3 KB

基本概念

本地时间

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

localtime

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

时区

时区有好几种表示方式：

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

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

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

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

夏令时

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

daynight-saving

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

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

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

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

本地化

计算机通过Locale来针对当地用户习惯格式化日期、时间、数字、货币等。

Locale由语言_国家的字母缩写构成，语言使用小写，国家使用大写。例如，zh_CN表示中文+中国，en_US表示英文+美国。

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

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

一个电商网站会根据用户所在的Locale对用户显示如下：

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

Date Calendar

计算机表示的时间是以整数表示的时间戳存储的，即Epoch Time（是计算从1970年1月1日零点（格林威治时区／GMT+00:00）到现在所经历的秒数），Java使用long型来表示以毫秒为单位的时间戳，通过System.currentTimeMillis()获取当前时间戳。

Java有两套日期和时间的API：

  • 一套定义在java.util这个包里面，主要包括Date、Calendar和TimeZone这几个类；

  • 一套新的API是在Java 8引入的，定义在java.time这个包里面，主要包括LocalDateTime、ZonedDateTime、ZoneId等

Date

java.util.Date是用于表示一个日期和时间的对象，可以发现它实际上存储了一个long类型的以毫秒表示的时间戳：

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());
        
        System.out.println( new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date));
    }
}

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

Calendar

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

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);
    }
}

返回的星期要特别注意，1~7分别表示周日，周一，……，周六。

Calendar只有一种方式获取，即Calendar.getInstance()，而且一获取到就是当前时间。

如果我们想给它设置成特定的一个日期和时间，就必须先清除所有字段：

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
    }
}

TimeZone

Calendar和Date相比，除了基本运算外，还提供了时区转换的功能。时区用TimeZone对象表示：

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");
        
        //TimeZone tzDefault = TimeZone.getDefault(); // 当前时区
        //TimeZone tzGMT9 = TimeZone.getTimeZone("GMT+09:00"); // GMT+9:00时区
        sdf.setTimeZone(TimeZone.getTimeZone("America/New_York"));
        System.out.println(sdf.format(c.getTime()));
        // 2019-11-19 19:15:00
    }
}

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

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

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

DateTime

Java 8 引入了新的日期和时间 API，它们是不变类，默认按 ISO 8601 标准格式化和解析，主要涉及的类型有：

  • 本地日期和时间：LocalDateTime，LocalDate，LocalTime；

  • 带时区的日期和时间：ZonedDateTime；

  • 时刻：Instant；

  • 时区：ZoneId，ZoneOffset；

  • 时间间隔：Duration。

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

注意 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

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

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

LocalDateTime，ZoneId，Instant，ZonedDateTime和long都可以互相转换：

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

只需要留意long类型以毫秒还是秒为单位即可。

LocalDateTime

使用LocalDateTime可以非常方便地对日期和时间进行加减，或者调整日期和时间，它总是返回新对象

使用isBefore()和isAfter()可以判断日期和时间的先后

使用Duration和Period可以表示两个日期和时间的“区间间隔”

当前日期

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格式打印
    }
}

上述代码其实有一个小问题，由于执行一行代码总会消耗一点时间，因此，3个类型的日期和时间很可能对不上（时间的毫秒数基本上不同）。为了保证获取到同一时刻的日期和时间，可以改写如下：

LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间
LocalDate d = dt.toLocalDate(); // 转换到当前日期
LocalTime t = dt.toLocalTime(); // 转换到当前时间

指定日期

通过of()方法：

// 指定日期和时间:
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);

传入标准格式：

LocalDateTime dt = LocalDateTime.parse("2019-11-19T15:16:17");
LocalDate d = LocalDate.parse("2019-11-19");
LocalTime t = LocalTime.parse("15:16:17");

运算

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

public class Main {
    public static void main(String[] args) {
        LocalDateTime dt = LocalDateTime.of(2019, 10, 26, 20, 30, 59);  
        
        // 加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
    }
}

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

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")));
    }
}

修改

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

还有一个通用的 with() 方法允许我们做更复杂的运算。

public class Main {
    public static void main(String[] args) {
        // 日期变为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
        
        // 本月第一天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);
    }
}

Duration vs Period

  • Duration 表示两个时刻之间的时间间隔

  • Period 表示两个日期之间的天数

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
    }
}

利用 ofXxx() 或者 parse() 方法也可以直接创建Duration：

Duration d1 = Duration.ofHours(10); // 10 hours
Duration d2 = Duration.parse("P1DT2H3M"); // 1 day, 2 hours, 3 minutes

P...T 之间表示日期间隔，T 后面表示时间间隔。如果是 PT... 的格式表示仅有时间间隔

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

ZonedDateTime

ZonedDateTime 是带时区的日期和时间，可用于时区转换；ZonedDateTime 和 LocalDateTime 可以相互转换。

创建

一种是通过 now() 方法返回当前时间

ZonedDateTime zbj = ZonedDateTime.now(); // 默认时区
ZonedDateTime zny = ZonedDateTime.now(ZoneId.of("America/New_York")); // 用指定时区获取当前时间

另一种方式是通过给一个LocalDateTime附加一个ZoneId

LocalDateTime ldt = LocalDateTime.of(2019, 9, 15, 15, 16, 17);
ZonedDateTime zbj = ldt.atZone(ZoneId.systemDefault());
ZonedDateTime zny = ldt.atZone(ZoneId.of("America/New_York"));

时区转换

public class Main {
    public static void main(String[] args) {
        // 以中国时区获取当前时间:
        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);
        
        LocalDateTime ldt = zny.toLocalDateTime();
    }
}

DateTimeFormatter

DateTimeFormatter 可以通过格式化字符串和 Locale 对日期和时间进行定制输出。

和 SimpleDateFormat 不同的是，DateTimeFormatter 不但是不变对象，它还是线程安全的。

public class Main {
    public static void main(String[] args) {
        ZonedDateTime zdt = ZonedDateTime.now();
        var formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm ZZZZ");
        System.out.println(formatter.format(zdt));

        var zhFormatter = DateTimeFormatter.ofPattern("yyyy MMM dd EE HH:mm", Locale.CHINA);
        System.out.println(zhFormatter.format(zdt));

        var usFormatter = DateTimeFormatter.ofPattern("E, MMMM/dd/yyyy HH:mm", Locale.US);
        System.out.println(usFormatter.format(zdt));

        // 用自定义格式解析:
        LocalDateTime dt2 = LocalDateTime.parse("2019/11/30 15:16:17", dtf);
        System.out.println(dt2);
        
        System.out.println(DateTimeFormatter.ISO_DATE.format(dt2));
        System.out.println(DateTimeFormatter.ISO_DATE_TIME.format(dt2));
    }
}

Instant

Instant 表示高精度时间戳。用 Instant.now() 获取当前时间戳，效果和 System.currentTimeMillis() 类似

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

既然 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]

最佳实践

处理日期和时间时，尽量使用新的 java.time 包；

在数据库中存储时间戳时，尽量使用 long 型时间戳，它具有省空间，效率高，不依赖数据库的优点。

旧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.toZoneId());

新API转旧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类（旧） 对应Java类（新）
DATETIME java.util.Date LocalDateTime
DATE java.sql.Date LocalDate
TIME java.sql.Time LocalTime
TIMESTAMP java.sql.Timestamp LocalDateTime

最好的方法是直接用长整数 long 表示，在数据库中存储为 BIGINT 类型。

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

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)));
    }
}