阅读完需:约 23 分钟
Date和Calendar的区别
Date类表示的是特定的,瞬间的,它能精确毫秒。
Calendar它是一种抽象类,相比Date它在操作日历的时候提供了一些方法来操作日历字段
在JDK1.0中,Date类是唯一的一个代表时间的类,但是由于Date类不便于实现国际化,所以从JDK1.1版本开始,推荐使用Calendar类进行时间和日期处理 。
————————————————————————————————————
Date
Date date = new Date();
System.out.println("毫秒:"+date.getTime());//输入毫秒
//时间转字符串
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String time = sdf.format(date);
System.out.println("时间转字符串:"+time);
//利用字符串来转时间格式(记得抛出异常)
String time02 = "2018-09-05";
SimpleDateFormat sdf2 = new SimpleDateFormat ("yyyy-MM-dd");
Date date2 = sdf2.parse(time02);
System.out.println("字符串转时间格式:"+date2);
Calendar
public class CalendarDemo {
public static void main(String[] args) {
// 其日历字段已由当前日期和时间初始化:
Calendar rightNow = Calendar.getInstance(); // 子类对象
// 获取年
int year = rightNow.get(Calendar.YEAR);
// 获取月
int month = rightNow.get(Calendar.MONTH);
// 获取日
int date = rightNow.get(Calendar.DATE);
//获取几点
int hour=rightNow.get(Calendar.HOUR_OF_DAY);
//获取上午下午
int moa=rightNow.get(Calendar.AM_PM);
if(moa==1)
System.out.println("下午");
else
System.out.println("上午");
System.out.println(year + "年" + (month + 1) + "月" + date + "日"+hour+"时");
rightNow.add(Calendar.YEAR,5);
rightNow.add(Calendar.DATE, -10);
int year1 = rightNow.get(Calendar.YEAR);
int date1 = rightNow.get(Calendar.DATE);
System.out.println(year1 + "年" + (month + 1) + "月" + date1 + "日"+hour+"时");
}
注意:month是从0开始的,而月份是从1开始的,所以month需要加一。
Calendar常量(field)的作用
Calendar cal = Calendar.getInstance();
cal.get(Calendar.DATE);//-----------------------当天 1-31
cal.get(Calendar.DAY_OF_MONTH);//---------------当天 1-31 ,这个相对而言会比较准确
cal.get(Calendar.DAY_OF_WEEK);//----------------从星期天开始计算,如果今天星期二,那么返回3
cal.get(Calendar.DAY_OF_YEAR);//----------------
cal.get(Calendar.HOUR);//-----------------------12小时制
cal.get(Calendar.HOUR_OF_DAY);//----------------24小时制,一般使用这个属性赋值
cal.get(Calendar.MILLISECOND);//----------------
cal.get(Calendar.MINUTE);//---------------------
cal.get(Calendar.SECOND);//---------------------
cal.get(Calendar.WEEK_OF_MONTH);//--------------
cal.get(Calendar.WEEK_OF_YEAR);//---------------
cal.get(Calendar.MONTH);//-----------------------月份获取需要 +1,那么,赋值时需要 -1
Calendar类的成员方法
日历字段
————————————————————————————————————
Date和Calendar互相转换
1、Calendar转Date
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String s = simpleDateFormat.format(date);
System.out.println("时间为===="+s);
Date转Calendar
Date date2 = new Date();
Calendar cal2 = Calendar.getInstance();
cal2.setTime( date );
Date date2 = new Date();
Calendar cal2 = Calendar.getInstance();
cal2.setTime(date );
System.out.println(cal2.get(Calendar.YEAR) +"-"+(cal2.get(Calendar.MONTH)+1)+"-"+cal2.get(Calendar.DATE));
————————————————————————————————————
TimeZone
Calendar
和Date
相比,它提供了时区转换的功能。时区用TimeZone
对象表示:
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
转换为纽约时间:
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
也可以对日期和时间进行简单的加减:
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
}
}
注意:
计算机表示的时间是以整数表示的时间戳存储的,即Epoch Time,Java使用long
型来表示以毫秒为单位的时间戳,通过System.currentTimeMillis()
获取当前时间戳。
Java有两套日期和时间的API:
- 旧的Date、Calendar和TimeZone;
- 新的LocalDateTime、ZonedDateTime、ZoneId等。
分别位于java.util
和java.time
包中。
————————————————————————————————————
SimpleDateFormat
SimpleDateFormat 是一个各种项目中使用频度都很高的类,主要用于时间解析与格式化,频繁使用的主要方法有parse和format。
parse方法:将字符串类型(java.lang.String)解析为日期类型(java.util.Date)
format方法:将日期类型(Date)数据格式化为字符串(String)
————————————————————————————————————
System.currentTimeMillis()
计算方式与时间的单位转换
一、时间的单位转换
1秒=1000毫秒(ms) 1毫秒=1/1,000秒(s)
1秒=1,000,000 微秒(μs) 1微秒=1/1,000,000秒(s)
1秒=1,000,000,000 纳秒(ns) 1纳秒=1/1,000,000,000秒(s)
1秒=1,000,000,000,000 皮秒(ps) 1皮秒=1/1,000,000,000,000秒(s)
1分钟=60秒
1小时=60分钟=3600秒
二、System.currentTimeMillis()计算方式
在开发过程中,通常很多人都习惯使用new Date()来获取当前时间。new Date()所做的事情其实就是调用了System.currentTimeMillis()。如果仅仅是需要或者毫秒数,那么完全可以使用System.currentTimeMillis()去代替new Date(),效率上会高一点。如果需要在同一个方法里面多次使用new Date(),通常性能就是这样一点一点地消耗掉。
—————————————————————————————————
LocalDateTime
从Java 8开始,java.time
包提供了新的日期和时间API,主要涉及的类型有:
- 本地日期和时间:
LocalDateTime
,LocalDate
,LocalTime
; - 带时区的日期和时间:
ZonedDateTime
; - 时刻:
Instant
; - 时区:
ZoneId
,ZoneOffset
; - 时间间隔:
Duration
。
以及一套新的用于取代SimpleDateFormat
的格式化类型DateTimeFormatter
。
LocalDateTime与Date转换
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
public class DateUtils {
public static Date asDate(LocalDate localDate) {
return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
}
public static Date asDate(LocalDateTime localDateTime) {
return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}
public static LocalDate asLocalDate(Date date) {
return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDate();
}
public static LocalDateTime asLocalDateTime(Date date) {
return Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDateTime();
}
}
和旧的API相比,新API严格区分了时刻、本地日期、本地时间和带时区的日期时间,并且,对日期和时间进行运算更加方便。
此外,新API修正了旧API不合理的常量设计:
- Month的范围用1~12表示1月到12月;
- Week的范围用1~7表示周一到周日。
最后,新API的类型几乎全部是不变类型(和String类似),可以放心使用不必担心被修改。
LocalDateTime
我们首先来看最常用的LocalDateTime
,它表示一个本地日期和时间:
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规定的日期和时间格式进行打印。
上述代码其实有一个小问题,在获取3个类型的时候,由于执行一行代码总会消耗一点时间,因此,3个类型的日期和时间很可能对不上(时间的毫秒数基本上不同)。为了保证获取到同一时刻的日期和时间,可以改写如下:
LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间
LocalDate d = dt.toLocalDate(); // 转换到当前日期
LocalTime t = dt.toLocalTime(); // 转换到当前时间
反过来,通过指定的日期和时间创建LocalDateTime
可以通过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);
因为严格按照ISO 8601的格式,因此,将字符串转换为LocalDateTime
就可以传入标准格式:
LocalDateTime dt = LocalDateTime.parse("2019-11-19T15:16:17");
LocalDate d = LocalDate.parse("2019-11-19");
LocalTime t = LocalTime.parse("15:16:17");
注意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
Jackson 转换 LocalDateTime
改变jackson内部序列化和反序列化LocalDateTime的方式,序列化时转换为时间戳,反序列化时将时间戳转换为LocalDateTime即可。
创建两个类,分别继承JsonSerializer和JsonDeserializer
//时间序列化时变为时间戳
public class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
@Override
public void serialize(LocalDateTime localDateTime, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
jsonGenerator.writeNumber(localDateTime.toInstant(ZoneOffset.ofHours(8)).toEpochMilli());
}
}
//时间戳反序列化时间
public class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
@Override
public LocalDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
Long timestamp = jsonParser.getLongValue();
return LocalDateTime.ofEpochSecond(timestamp / 1000, 0, ZoneOffset.ofHours(8));
}
}
LocalDateTime 转 json 使用方法
LocalDateTime dt = LocalDateTime.now();
ObjectMapper mapper = new ObjectMapper();
try {
JavaTimeModule timeModule = new JavaTimeModule();
timeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer());
mapper.registerModule(timeModule);
String json = mapper.writeValueAsString(dt);
System.out.println(json);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
经过此方式序列化得到的结果为:”1568528927273″
json 转 LocalDateTime 使用方法
String json = "1568528927273";
ObjectMapper mapper = new ObjectMapper();
try {
JavaTimeModule timeModule = new JavaTimeModule();
timeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer());
mapper.registerModule(timeModule);
LocalDateTime dt = mapper.readValue(json, LocalDateTime.class);
System.out.println(dt);
} catch (IOException e) {
e.printStackTrace();
}
DateTimeFormatter
如果要自定义输出的格式,或者要把一个非ISO 8601格式的字符串解析成LocalDateTime
,可以使用新的DateTimeFormatter
:
public class Main {
public static void main(String[] args) {
// 自定义格式化:
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);
}
}
LocalDateTime
提供了对日期和时间进行加减的非常简单的链式调用:
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()
示例代码如下:
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
}
}
同样注意到调整月份时,会相应地调整日期,即把2019-10-31
的月份调整为9
时,日期也自动变为30
。
实际上,LocalDateTime
还有一个通用的with()
方法允许我们做更复杂的运算。例如:
public class Main {
public static void main(String[] args) {
// 本月第一天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);
}
}
对于计算某个月第1个周日这样的问题,新的API可以轻松完成。
要判断两个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")));
}
}
注意到LocalDateTime
无法与时间戳进行转换,因为LocalDateTime
没有时区,无法确定某一时刻。后面我们要介绍的ZonedDateTime
相当于LocalDateTime
加时区的组合,它具有时区,可以与long
表示的时间戳进行转换。
Duration和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
}
}
注意到两个LocalDateTime
之间的差值使用Duration
表示,类似PT1235H10M30S
,表示1235小时10分钟30秒。而两个LocalDate
之间的差值用Period
表示,类似P1M21D
,表示1个月21天。
Duration
和Period
的表示方法也符合ISO 8601的格式,它以P...T...
的形式表示,P...T
之间表示日期间隔,T
后面表示时间间隔。如果是PT...
的格式表示仅有时间间隔。利用ofXxx()
或者parse()
方法也可以直接创建Duration
:
Duration d1 = Duration.ofHours(10); // 10 hours
Duration d2 = Duration.parse("P1DT2H3M"); // 1 day, 2 hours, 3 minutes
Java 8引入了新的日期和时间API,它们是不变类,默认按ISO 8601标准格式化和解析;
使用LocalDateTime
可以非常方便地对日期和时间进行加减,或者调整日期和时间,它总是返回新对象;
使用isBefore()
和isAfter()
可以判断日期和时间的先后;
使用Duration
和Period
可以表示两个日期和时间的“区间间隔”。
Duration
Duration主要用来衡量秒级和纳秒级的时间,使用于时间精度要求比较高的情况。
public final class Duration
implements TemporalAmount, Comparable<Duration>, Serializable
可以看到,Duration是一个final class,并且它是可序列化和可比较的。我们注意,Duration还实现了TemporalAmount接口。
那么TemporalAmount接口是什么呢?
TemporalAmount
是Duration
和Period
的父接口。
其中TemporalUnit代表的是时间对象的单位,比如:years, months, days, hours, minutes 和 seconds
而Temporal代表的是对时间对象的读写操作
Instant start = Instant.parse("2020-08-03T10:15:30.00Z");
Instant end = Instant.parse("2020-08-03T10:16:30.12Z");
Duration duration = Duration.between(start, end);
log.info("{}",duration.getSeconds());
log.info("{}",duration.getNano());
log.info("{}",duration.getUnits());
除了Instance,我们还可以使用LocalTime
LocalTime start2 = LocalTime.of(1, 20, 25, 1314);
LocalTime end2 = LocalTime.of(3, 22, 27, 1516);
Duration.between(start2, end2).getSeconds();
我们还可以对Duration做plus和minus操作,并且通过使用isNegative来判断两个时间的先后顺
duration.plusSeconds(60);
duration.minus(30, ChronoUnit.SECONDS);
log.info("{}",duration.isNegative());
使用Duration.of方法来方便的创建Duration
Duration fromDays = Duration.ofDays(1);
Duration fromMinutes = Duration.ofMinutes(60);
Period
Period的单位是year, month 和day 。
操作基本上和Duration是一致的。
public final class Period
implements ChronoPeriod, Serializable
其中ChronoPeriod是TemporalAmount的子接口。
同样的,我们可以使用Period.between从LocalDate来构建Period:
LocalDate startDate = LocalDate.of(2020, 2, 20);
LocalDate endDate = LocalDate.of(2021, 1, 15);
Period period = Period.between(startDate, endDate);
log.info("{}",period.getDays());
log.info("{}",period.getMonths());
log.info("{}",period.getYears());
也可以直接从Period.of来构建:
Period fromUnits = Period.of(3, 10, 10);
Period fromDays = Period.ofDays(50);
Period fromMonths = Period.ofMonths(5);
Period fromYears = Period.ofYears(10);
Period fromWeeks = Period.ofWeeks(40);
period.plusDays(50);
period.minusMonths(2);
ChronoUnit
ChronoUnit是用来表示时间单位的,但是也提供了一些非常有用的between方法来计算两个时间的差值:
LocalDate startDate = LocalDate.of(2020, 2, 20);
LocalDate endDate = LocalDate.of(2021, 1, 15);
long years = ChronoUnit.YEARS.between(startDate, endDate);
long months = ChronoUnit.MONTHS.between(startDate, endDate);
long weeks = ChronoUnit.WEEKS.between(startDate, endDate);
long days = ChronoUnit.DAYS.between(startDate, endDate);
long hours = ChronoUnit.HOURS.between(startDate, endDate);
long minutes = ChronoUnit.MINUTES.between(startDate, endDate);
long seconds = ChronoUnit.SECONDS.between(startDate, endDate);
long milis = ChronoUnit.MILLIS.between(startDate, endDate);
long nano = ChronoUnit.NANOS.between(startDate, endDate);
LocalDate today = LocalDate.now();
System.out.println("当前时间: " + today); //2021-12-02
//LocalDate plus(long amountToAdd, TemporalUnit unit)
LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS);
System.out.println("下周的时间: " + nextWeek); //2021-12-09
LocalDate nextMonth = today.plus(1, ChronoUnit.MONTHS);
System.out.println("下个月的时间: " + nextMonth); //2022-01-02
LocalDate nextYear = today.plus(1, ChronoUnit.YEARS);
System.out.println("下一年的时间: " + nextYear);//2022-12-02
LocalDate nextDecade = today.plus(1, ChronoUnit.DECADES);
System.out.println("10年后的时间: " + nextDecade);//2031-12-02
- Enum Constant 描述
- CENTURIES 代表一个世纪概念的单位。
- DAYS 代表一天概念的单位。
- DECADES 代表十年概念的单位。
- ERAS 代表一个时代概念的单位。
- FOREVER 代表永恒概念的人工单位。
- HALF_DAYS 代表AM / PM中使用的半天概念的单位。
- HOURS 表示一小时概念的单位。
- MICROS 表示微秒概念的单位。
- MILLENNIA 代表千年概念的单位。
- MILLIS 表示毫秒概念的单位。
- MINUTES 表示一分钟概念的单位。
- MONTHS 代表一个月概念的单位。
- NANOS 代表纳秒概念的单位,是支持的最小时间单位。
- SECONDS 秒
- WEEKS 表示一周概念的单位。
- YEARS 代表一年概念的单位。
————————————————————————————————————
ZonedDateTime
LocalDateTime
总是表示本地日期和时间,要表示一个带时区的日期和时间,我们就需要ZonedDateTime
。
可以简单地把ZonedDateTime
理解成LocalDateTime
加ZoneId
。ZoneId
是java.time
引入的新的时区类,注意和旧的java.util.TimeZone
区别。
要创建一个ZonedDateTime
对象,有以下几种方法,一种是通过now()
方法返回当前时间:
public class Main {
public static void main(String[] args) {
ZonedDateTime zbj = ZonedDateTime.now(); // 默认时区
ZonedDateTime zny = ZonedDateTime.now(ZoneId.of("America/New_York")); // 用指定时区获取当前时间
System.out.println(zbj);
System.out.println(zny);
}
}
观察打印的两个ZonedDateTime
,发现它们时区不同,但表示的时间都是同一时刻(毫秒数不同是执行语句时的时间差):
2019-09-15T20:58:18.786182+08:00[Asia/Shanghai]
2019-09-15T08:58:18.788860-04:00[America/New_York]
另一种方式是通过给一个LocalDateTime
附加一个ZoneId
,就可以变成ZonedDateTime
:
public class Main {
public static void main(String[] args) {
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"));
System.out.println(zbj);
System.out.println(zny);
}
}
以这种方式创建的ZonedDateTime
,它的日期和时间与LocalDateTime
相同,但附加的时区不同,因此是两个不同的时刻:
2019-09-15T15:16:17+08:00[Asia/Shanghai]
2019-09-15T15:16:17-04:00[America/New_York]
时区转换
要转换时区,首先我们需要有一个ZonedDateTime
对象,然后,通过withZoneSameInstant()
将关联时区转换到另一个时区,转换后日期和时间都会相应调整。
下面的代码演示了如何将北京时间转换为纽约时间:
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);
}
}
要特别注意,时区转换的时候,由于夏令时的存在,不同的日期转换的结果很可能是不同的。这是北京时间9月15日的转换结果:
2019-09-15T21:05:50.187697+08:00[Asia/Shanghai]
2019-09-15T09:05:50.187697-04:00[America/New_York]
这是北京时间11月15日的转换结果:
2019-11-15T21:05:50.187697+08:00[Asia/Shanghai]
2019-11-15T08:05:50.187697-05:00[America/New_York]
两次转换后的纽约时间有1小时的夏令时时差。 涉及到时区时,千万不要自己计算时差,否则难以正确处理夏令时。
有了ZonedDateTime
,将其转换为本地时间就非常简单:
ZonedDateTime zdt = ...
LocalDateTime ldt = zdt.toLocalDateTime();
转换为LocalDateTime
时,直接丢弃了时区信息。
————————————————————————————————————
DateTimeFormatter
使用旧的Date
对象时,我们用SimpleDateFormat
进行格式化显示。使用新的LocalDateTime
或ZonedLocalDateTime
时,我们要进行格式化显示,就要使用DateTimeFormatter
。
和SimpleDateFormat
不同的是,DateTimeFormatter
不但是不变对象,它还是线程安全的。线程的概念我们会在后面涉及到。现在我们只需要记住:因为SimpleDateFormat
不是线程安全的,使用的时候,只能在方法内部创建新的局部变量。而DateTimeFormatter
可以只创建一个实例,到处引用。
创建DateTimeFormatter
时,我们仍然通过传入格式化字符串实现:
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
格式化字符串的使用方式与SimpleDateFormat
完全一致。
另一种创建DateTimeFormatter
的方法是,传入格式化字符串时,同时指定Locale
:
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("E, yyyy-MMMM-dd HH:mm", Locale.US);
这种方式可以按照Locale
默认习惯格式化。我们来看实际效果:
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));
}
}
在格式化字符串中,如果需要输出固定字符,可以用'xxx'
表示。
运行上述代码,分别以默认方式、中国地区和美国地区对当前时间进行显示,结果如下:
2019-09-15T23:16 GMT+08:00
2019 9月 15 周日 23:16
Sun, September/15/2019 23:16
当我们直接调用System.out.println()
对一个ZonedDateTime
或者LocalDateTime
实例进行打印的时候,实际上,调用的是它们的toString()
方法,默认的toString()
方法显示的字符串就是按照ISO 8601
格式显示的,我们可以通过DateTimeFormatter
预定义的几个静态变量来引用:
var 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
小结
对ZonedDateTime
或LocalDateTime
进行格式化,需要使用DateTimeFormatter
类;
DateTimeFormatter
可以通过格式化字符串和Locale
对日期和时间进行定制输出。