计算机表示的时间是以整数表示的时间戳存储的,即Epoch Time,Java使用long型来表示以毫秒为单位的时间戳,通过System.currentTimeMillis()获取当前时间戳
(1)旧的:Date、Calendar和TimeZone(java.util)
(2)新的:在Java 8引入的,LocalDateTime、LocalDate、LocalTime、ZonedDateTime、ZoneId等(java.time)
日期:指某一天,它不是连续变化的,而是应该被看成离散的。
时间有两种概念
(1)一种是不带日期的时间,例如,12:30:59
(2)一种是带日期的时间,例如,2020-1-1 20:21:59,只有这种带日期的时间能唯一确定某个时刻,不带日期的时间是无法确定一个唯一时刻的
当前时刻,实际上是本地时间
不同的时区,在同一时刻,本地时间是不同的。全球一共分为24个时区,伦敦所在的时区称为标准时区,其他时区按东/西偏移的小时区分,北京所在的时区是东八区
时区
光靠本地时间还无法唯一确定一个准确的时刻,所以还需要给本地时间加上一个时区
例如:GMT+08:00或者UTC+08:00表示东八区,GMT和UTC可以认为基本是等价的,只是UTC使用更精确的原子钟计时,每隔几年会有一个闰秒,在开发程序的时候可以忽略两者的误差,因为计算机的时钟在联网的时候会自动与时间服务器同步时间
例如,CST表示China Standard Time,也就是中国标准时间。但是CST也可以表示美国中部时间Central Standard Time USA,因此,缩写容易产生混淆,尽量不要使用缩写
Asia/Shanghai,表示上海所在地的时区。特别注意城市名称不是任意的城市,而是由国际标准组织规定的城市
因为时区的存在,东八区的2019年11月20日早上8:15,和西五区的2019年11月19日晚上19:15,时刻是相同的
时刻:分别在两个时区的两个人,如果在这一刻通电话,各自报出自己手表上的时间,虽然本地时间是不同的,但是这两个时间表示的时刻是相同的
所谓夏令时,就是夏天开始的时候,把时间往后拨1小时,夏天结束的时候,再把时间往前拨1小时。国家实行过一段时间夏令时,1992年就废除了,但是矫情的美国人到现在还在使用,所以时间换算更加复杂
在计算机中,通常使用Locale表示一个国家或地区的日期、时间、数字、货币等格式。Locale由(语言_国家)字母缩写构成,例如,zh_CN表示中文+中国,en_US表示英文+美国。语言使用小写,国家使用大写
对于日期来说,不同的Locale,例如,中国和美国的表示方式如下
(1)zh_CN:2016-11-30
(2)en_US:11/30/2016
(1)在编写日期和时间的程序前,要准确理解日期、时间和时刻的概念
(2)由于存在本地时间,需要理解时区的概念,并且必须牢记由于夏令时的存在,同一地区用GMT/UTC和城市表示的时区可能导致时间不同
(3)计算机通过Locale来针对当地用户习惯格式化日期、时间、数字、货币等
“同一个时刻”在计算机中存储的本质上只是一个整数,我们称它为Epoch Time
Epoch Time又称为时间戳,在不同的编程语言中,会有几种存储方式:
(1)以秒为单位的整数:1574208900,缺点是精度只能到秒
(2)以毫秒为单位的整数:1574208900123,最后3位表示毫秒数
(3)以秒为单位的浮点数:1574208900.123,小数点后面表示零点几秒
它们之间转换非常简单。而在Java程序中,时间戳通常是用long表示的毫秒数。要获取当前时间戳,可以使用System.currentTimeMillis(),这是Java程序获取时间戳最常用的方法。
java.util.Date是用于表示一个日期和时间的对象,注意与java.sql.Date区分,后者用在数据库中。如果观察Date的源码,可以发现它实际上存储了一个long类型的以毫秒表示的时间戳
Date() 分配Date对象并初始化此对象,以表示分配它的事件(精确到毫秒)
Date(long date) 分配Date对象并初始化此对象,以表示自从标准的基准时间(即1970年1月1日00:00:00GMT)以来的指定毫秒
如何使用
long timeMillis = System.currentTimeMillis();
Date date = new Date(timeMillis);
System类的currentTimeMillis()方法主要用来获取系统当前时间距标准基准时间的毫秒数
方法 | 功能 |
---|---|
boolean after(Date when) | 测试当前日期是否在指定的日期之后 |
boolean before(Date when) | 测试当前日期是否在指定日期之前 |
long getTime() | 获得自1970年1月1日GMT到现在的所表示的毫秒数 |
void setTime(long time) | 设置当前Date对象所表示的日期时间值,该值用以表示1970年1月1日00:00:00GMT以后time毫秒的时间点 |
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.toString());// 转换为String
System.out.println(date.toGMTString());// 转换为GMT时区
System.out.println(date.toLocaleString());// 转换为本地时区
注意:getYear()返回的年份必须加上1900,getMonth()返回的月份是011分别表示112月,所以要加1,而getDate()返回的日期范围是1~31,又不能加1
Date对象有几个严重的问题
(1)不能转换时区,除了toGMTString()可以按GMT+0:00输出外,Date总是以当前计算机系统的默认时区为基础进行输出
(2)也很难对日期和时间进行加减,计算两个日期相差多少天,计算某个月第一个星期一的日期等
日期/时间格式化子类的抽象类(java.text)
方法 | 功能 |
---|---|
SHORT | 完全为数字,如12.12.52或3:30pm |
MEDIUM | 较长,如Jan12,1952 |
LONG | 更长,如January 12,1952或3:30:32pm |
FULL | 完全指定,如Tuesday,April 12、1954AD或3:30:42pmPST |
使用DateFormat要格式化一个当前语言环境下的日期,需要创建DateFormat类的一个对象;
由于它是抽象类,因此可以使用静态工厂方getDateInstance创建
DateFormat df = new DateFormat.getDateInstance();
方法 | 功能 |
---|---|
String format(Date date) | 将一个Date格式化为日期/时间字符串 |
Calendar getCalendar() | 获取与此日期/时间格式器关联的日历 |
static DateFormat getDateInstance() | 获取日期格式器,该格式器具有默认语言环境的默认格式化分格 |
static DateFormat getDateTimeInstance() | 获取日期/时间格式器,该格式器具有默认语言环境的默认格式化分格 |
static DateFormat getInstance() | 获取为日期和时间使用SHORT分格的默认日期/时间格式器 |
static DateFormat getTimeInstance() | 获取时间格式器,该格式器具有默认语言环境的默认格式化分格 |
Date parse(String source) | 将字符串解析成一个日期,并返回这个日期的Date对象 |
打印本地时区表示的日期和时间时,不同的计算机可能会有不同的结果。如果想要针对用户的偏好精确地控制日期和时间的格式,就可以使用SimpleDateFormat对一个Date进行转换。它用预定义的字符串表示格式化:
(1)yyyy:年
(2)MM:月
(3)dd: 日
(4)HH: 小时
(5)mm: 分钟
(6)ss: 秒
Date date = new Date();// 获取当前时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf.format(date));
一般来说,字母越长,输出越长。以M为例,假设当前月份是9月:
M:输出9
MM:输出09
MMM:输出Sep
MMMM:输出September
Calendar可以用于获取并设置年、月、日、时、分、秒,它和Date比,主要多了一个可以做简单的日期和时间运算的功能
一个抽象类,它为特定瞬间与一组YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了方法
Calendar提供了一个类方法getInstance,以获得此类型的一个通用的对象。返回一个Calendar对象,其日历字段已由当前日期和时间初始化,使用方法如下
Calendar rightNow = Calendar.getInstance();
由于Calendar类是一个抽象类,不能使用new实例化,因此除了使用getInstance方法创建,还可以使用其子类创建对象。
方法 | 功能 |
---|---|
void add(int fieId,int amount) | 根据日历规则,为给定的日历字段添加或减去指定的时间量 |
boolean after(Object when) | 判断此Calendar表示的时间是否在指定Object表示的时间之后,返回判断结果 |
boolean before(Object when) | 判断此Calendar表示的时间是否在指定Object表示的时间之前,返回判断结果 |
int get(int fieId) | 返回给定日历字段 |
static Calendar getInstance() | 使用默认时区和语言环境获得一个日历 |
Date getTime() | 返回一个表示Calendar时间值(从历元至现在的毫秒偏移量)的Date对象 |
abstract void roll(int fieId,boolean up) | 在给定的时间字段上添加或减去(上/下)单个时间单元,不更改更大的字段 |
void set(int fieId,int value) | 将给定的日历字段设置为给定值 |
void set(int year,int month,int data) | 设置日历字段YEAR、MONTH和DAY_OF_MONTH的值 |
void set( int year,int month,int date,int hourOfDay,int minute,int second) | 设置日历字段YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY和SECOND的值 |
Calendar只有一种方式获取,即Calendar.getInstance(),而且一获取到就是当前时间
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);
注意:Calendar获取年月日这些信息变成了get(int field),返回的年份不必转换,返回的月份仍然要加1,返回的星期要特别注意,1~7分别表示周日,周一,……,周六
如果想给它设置成特定的一个日期和时间,就必须先清除所有字段(clear)
Calendar c = Calendar.getInstance();// 当前时间
c.clear();// 清除所有
c.set(Calendar.YEAR, 2019);// 设置2019年
c.set(Calendar.MONTH, 8);// 设置9月,注意8表示9月
c.set(Calendar.DATE, 2);// 设置2日
c.set(Calendar.HOUR_OF_DAY, 21);// 设置时间
c.set(Calendar.MINUTE, 22);
c.set(Calendar.SECOND, 23);
// 2019-09-02 21:22:23
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(c.getTime()));
利用Calendar.getTime()可以将一个Calendar对象转换成Date对象,然后就可以用SimpleDateFormat进行格式化了。
对日期和时间进行简单的加减
Calendar c = Calendar.getInstance(); //当前时间
c.clear(); //清除所有
c.set(2019, 10 /* 11月 */, 20, 8, 15, 0); //设置年月日时分秒
c.add(Calendar.DAY_OF_MONTH, 5); //加5天并减去2小时
c.add(Calendar.HOUR_OF_DAY, -2);
// 显示时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 将Calendar对象转换为Date对象
Date d = c.getTime();
// 2019-11-25 6:15:00
System.out.println(sdf.format(d));
TimeZone
提供了时区转换的功能,时区用TimeZone对象表示
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
使用TimeZone.getAvailableIDs(),可以列出系统支持的所有ID
有了时区,就可以对指定时间进行转换
例如,将北京时间2019-11-20 8:15:00转换为纽约时间
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
利用Calendar进行时区转换的步骤
(1)清除所有字段
(2)设定指定时区
(3)设定日期和时间
(4)创建SimpleDateFormat并设定目标时区
(5)格式化获取的Date对象(注意Date对象无时区信息,时区信息存储在SimpleDateFormat中)
因此,本质上时区转换只能通过SimpleDateFormat在显示的时候完成
从Java 8开始,java.time包提供了新的日期和时间API
(1)本地日期和时间:LocalDateTime,LocalDate,LocalTime
(2)带时区的日期和时间:ZonedDateTime、ZonedDate、ZonedTime
(3)时区:ZoneId,ZoneOffset
(4)时刻:Instant
(5)以及一套新的用于取代SimpleDateFormat的格式化类型DateTimeFormatter
(6)时间间隔
和旧的API相比,新API严格区分了时刻、本地日期、本地时间和带时区的日期时间,并且,对日期和时间进行运算更加方便
新API修正了旧API不合理的常量设计
(1)Month的范围用1~12表示1月到12月
(2)Week的范围用1~7表示周一到周日
(3)新API的类型几乎全部是不变类型(和String类似),可以放心使用不必担心被修改
Clock类提供了访问当前日期和时间的方法,Clock是时区敏感的,可以用来取代 System.currentTimeMillis()来获取当前的微秒数。某一个特定的时间点也可以使用Instant类来表示,Instant类也可以用来创建老的java.util.Date对象
Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // 使用Clock创建Date
LocalTime定义了一个没有时区信息的时间,例如:晚上10点,或者17:30:15。下面的例子使用前面代码创建的时区创建了两个本地时间。之后比较时间并以小时和分钟为单位计算两个时间的时间差:
Clock clock1 = Clock.systemDefaultZone();
Clock clock2 = Clock.systemDefaultZone();
LocalTime now1 = LocalTime.now(clock1);
LocalTime now2 = LocalTime.now(clock2);
System.out.println(now1.isBefore(now2)); // false
long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
System.out.println(hoursBetween); // -3
System.out.println(minutesBetween); // -239
// LocalTime 提供了多种工厂方法来简化对象的创建,包括解析时间字符串。
LocalTime late = LocalTime.of(23, 59, 59);
System.out.println(late); // 23:59:59
DateTimeFormatter germanFormatter = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT)
.withLocale(Locale.GERMAN);
LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
System.out.println(leetTime); // 13:37
LocalDate表示了一个确切的日期,比如2014-03-11。该对象值是不可变的,用起来和LocalTime基本一致。下面的例子展示了如何给Date对象加减天/月/年。另外要注意的是这些对象是不可变的,操作返回的总是一个新实例
LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
LocalDate yesterday = tomorrow.minusDays(2);
System.out.println(tomorrow + " " + yesterday); //2020-05-30 2020-05-28
LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
System.out.println(dayOfWeek); // FRIDAY
一个本地日期和时间,通过now()获得
基本使用
LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间
LocalDate d = LocalDate.now(); // 当前日期
LocalTime t = LocalTime.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规定的日期和时间格式进行打印
上述代码其实有一个小问题,在获取3个类型的时候,由于执行一行代码总会消耗一点时间,因此,3个类型的日期和时间很可能对不上(时间的毫秒数基本上不同)。为了保证获取到同一时刻的日期和时间,可以改写如下
LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间
LocalDate d = dt.toLocalDate(); // 转换到当前日期
LocalTime t = dt.toLocalTime(); // 转换到当前时间
注意ISO 8601规定的日期和时间分隔符是T。标准格式如下:
(1)日期:yyyy-MM-dd
(2)时间:HH:mm:ss
(3)带毫秒的时间:HH:mm:ss.SSS
(4)日期和时间:yyyy-MM-dd’T’HH:mm:ss
(5)带毫秒的日期和时间:yyyy-MM-dd’T’HH:mm:ss.SSS
JDK 8中加入了对时区的支持,带时区的时间为分别为:ZonedDate、ZonedTime、ZonedDateTime
其中每个时区都对应着 ID,地区ID都为 “{区域}/{城市}”的格式。例如 :Asia/Shanghai 等
表示本地日期和时间,要表示一个带时区的日期和时间
可以简单地把ZonedDateTime理解成LocalDateTime加ZoneId。ZoneId是java.time引入的新的时区类,注意和旧的java.util.TimeZone区别
要创建一个ZonedDateTime对象,有以下几种方法
ZonedDateTime zbj = ZonedDateTime.now(); // 默认时区
// 用指定时区获取当前时间
ZonedDateTime zny = ZonedDateTime.now(ZoneId.of("America/New_York"));
时区不同,但表示的时间都是同一时刻(毫秒数不同是执行语句时的时间差)
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"));//纽约时区
要转换时区,首先需要有一个ZonedDateTime对象,然后,通过withZoneSameInstant()将关联时区转换到另一个时区,转换后日期和时间都会相应调整
如何将北京时间转换为纽约时间
// 以中国时区获取当前时间:
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);
要特别注意,时区转换的时候,由于夏令时的存在,不同的日期转换的结果很可能是不同的。这是北京时间9月15日的转换结果
ZonedDateTime是带时区的日期和时间,可用于时区转换
ZonedDateTime和LocalDateTime可以相互转换
该类中包含了所有的时区信息
常用方法
方法 | 描述 |
---|---|
getAvailableZoneIds() | 可以获取所有时区时区信息 |
of(id) | 用指定的时区信息获取ZoneId对象 |
// 获取世界各个地方的时区的集合
Set availableZoneIds = ZoneId.getAvailableZoneIds();
// 获取系统默认时区的ID
ZoneId zd = ZoneId.systemDefault();
System.out.println("系统默认时区" + zd); // Asia/Shanghai
System.out.println("系统默认时区" + zd.getId()); // Asia/Shanghai
计算机存储的当前时间,本质上只是一个不断递增的整数。Java提供的System.currentTimeMillis()返回的就是以毫秒表示的当前时间戳。
这个当前时间戳在java.time中以Instant类型表示,用Instant.now()获取当前时间戳,效果和System.currentTimeMillis()类似
Instant now = Instant.now();
System.out.println(now.getEpochSecond()); // 秒
System.out.println(now.toEpochMilli()); // 毫秒
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]
可见,对于某一个时间戳,给它关联上指定的ZoneId,就得到了ZonedDateTime,继而可以获得了对应时区的LocalDateTime
LocalDateTime,ZoneId,Instant,ZonedDateTime和long都可以互相转换
转换的时候,只需要留意long类型以毫秒还是秒为单位即可
Instant表示高精度时间戳,它可以和ZonedDateTime以及long互相转换
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDate startDate = LocalDate.parse(startTime, formatter);
CharSequence endTime;
LocalDate endDate = LocalDate.parse(endTime, formatter);
// 日期区间
long days = ChronoUnit.DAYS.between(startDate, endDate);
// 月
long month = ChronoUnit.MONTHS.between(startDate, endDate);
// 年
long year = ChronoUnit.YEARS.between(startDate, endDate);
自定义输出的格式,或者要把一个非ISO 8601格式的字符串解析成LocalDateTime,可以使用新的DateTimeFormatter
// 自定义格式化
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
dtf.format(LocalDateTime.now());
// 用自定义格式解析
LocalDateTime dt2 = LocalDateTime.parse("2019/11/30 15:16:17", dtf);
LocalDateTime提供了对日期和时间进行加减的非常简单的链式调用
LocalDateTime dt = LocalDateTime.of(2019, 10, 26, 20, 30, 59);
System.out.println(dt);
LocalDateTime dt2 = dt.plusDays(5).minusHours(3);// 加5天减3小时
System.out.println(dt2); // 2019-10-31T17:30:59
LocalDateTime dt3 = dt2.minusMonths(1);// 减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:
(1)调整年:withYear()
(2)调整月:withMonth()
(3)调整日:withDayOfMonth()
(4)调整时:withHour()
(5)调整分:withMinute()
(6)调整秒:withSecond()
Java 8引入了新的日期和时间API,它们是不变类,默认按ISO 8601标准格式化和解析;
使用LocalDateTime可以非常方便地对日期和时间进行加减,或者调整日期和时间,它总是返回新对象;
使用isBefore()和isAfter()可以判断日期和时间的先后;
使用Duration和Period可以表示两个日期和时间的“区间间隔”
(1)对ZonedDateTime或LocalDateTime进行格式化,需要使用DateTimeFormatter类
(2)DateTimeFormatter可以通过格式化字符串和Locale对日期和时间进行定制输出
使用旧的Date对象时,用SimpleDateFormat进行格式化显示。使用新的LocalDateTime或ZonedLocalDateTime时,要进行格式化显示,就要使用DateTimeFormatter。和SimpleDateFormat不同的是,DateTimeFormatter不但是不变对象,它还是线程安全的。线程的概念我们会在后面涉及到。现在我们只需要记住:因为SimpleDateFormat不是线程安全的,使用的时候,只能在方法内部创建新的局部变量。而DateTimeFormatter可以只创建一个实例,到处引用
这种方式可以按照Locale默认习惯格式化
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));
DateTimeFormatter usFormatter = DateTimeFormatter.ofPattern("E, MMMM/dd/yyyy HH:mm", Locale.US);
System.out.println(usFormatter.format(zdt));
当直接调用System.out.println()对一个ZonedDateTime或者LocalDateTime实例进行打印的时候,实际上,调用的是它们的toString()方法,默认的toString()方法显示的字符串就是按照ISO 8601格式显示的,我们可以通过DateTimeFormatter预定义的几个静态变量来引用:
LocalDateTime ldt = LocalDateTime.now();
System.out.println(DateTimeFormatter.ISO_DATE.format(ldt));
System.out.println(DateTimeFormatter.ISO_DATE_TIME.format(ldt));
得到的输出和toString()类似:
2019-09-15
2019-09-15T23:16:51.56217
从字符串解析一个LocalDate类型和解析LocalTime一样简单:
DateTimeFormatter germanFormatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)
.withLocale(Locale.GERMAN);
LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas); // 2014-12-24
由于Java提供了新旧两套日期和时间的API,除非涉及到遗留代码,否则应该坚持使用新的API
如果要把旧式的Date或Calendar转换为新API对象,可以通过toInstant()方法转换为Instant对象,再继续转换为ZonedDateTime:
Instant ins1 = new Date().toInstant();// Date -> Instant
// Calendar -> Instant -> ZonedDateTime
Calendar calendar = Calendar.getInstance();
Instant ins2 = Calendar.getInstance().toInstant();
ZonedDateTime zdt = ins2.atZone(calendar.getTimeZone().toZoneId());
从上面的代码还可以看到,旧的TimeZone提供了一个toZoneId(),可以把自己变成新的ZoneId
如果要把新的ZonedDateTime转换为旧的API对象,只能借助long型时间戳做一个“中转”:
ZonedDateTime zdt = ZonedDateTime.now();// ZonedDateTime -> long
long ts = zdt.toEpochSecond() * 1000;
Date date = new Date(ts);// long -> Date
Calendar calendar = Calendar.getInstance();// long -> Calendar
calendar.clear();
calendar.setTimeZone(TimeZone.getTimeZone(zdt.getZone().getId()));
calendar.setTimeInMillis(zdt.toEpochSecond() * 1000);
从上面的代码还可以看到,新的ZoneId转换为旧的TimeZone,需要借助ZoneId.getId()返回的String完成。
除了旧式的java.util.Date,还可以找到另一个java.sql.Date,它继承自java.util.Date,但会自动忽略所有时间相关信息。这个奇葩的设计原因要追溯到数据库的日期与时间类型
在数据库中,也存在几种日期和时间类型:
(1)DATETIME:表示日期和时间
(2)DATE:仅表示日期
(3)TIME:仅表示时间
(4)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()的方法,非常简单地为不同用户以不同的偏好来显示不同的本地时间
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)));
}
(1)处理日期和时间时,尽量使用新的java.time包
(2)在数据库中存储时间戳时,尽量使用long型时间戳,它具有省空间,效率高,不依赖数据库的优点