阅读完需：约 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，那么，赋值时需要 -1Calendar类的成员方法
日历字段
————————————————————————————————————
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 minutesJava 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对日期和时间进行定制输出。
