Java日期学习笔记（二）：JDK1.8新特性
Java 8另一个新增的重要特性就是引入了新的时间和日期API，它们被包含在java.time包中。借助新的时间和日期API可以以更简洁的方法处理时间和日期。
在介绍本篇文章内容之前，我们先来讨论Java 8为什么要引入新的日期API，与之前的时间和日期处理方式有什么不同？
在Java 8之前，所有关于时间和日期的API都存在各种使用方面的缺陷，主要有：
- Java的java.util.Date和java.util.Calendar类易用性差，不支持时区，而且他们都不是线程安全的；
- 用于格式化日期的类DateFormat被放在java.text包中，它是一个抽象类，所以我们需要实例化一个SimpleDateFormat对象来处理日期格式化，并且DateFormat也是非线程安全，这意味着如果你在多线程程序中调用同一个DateFormat对象，会得到意想不到的结果。
- 对日期的计算方式繁琐，而且容易出错，因为月份是从0开始的，从Calendar中获取的月份需要加一才能表示当前月份。
由于以上这些问题，出现了一些三方的日期处理框架，例如Joda-Time，date4j等开源项目。但是，Java需要一套标准的用于处理时间和日期的框架，于是Java 8中引入了新的日期API。新的日期API是JSR-310规范的实现，Joda-Time框架的作者正是JSR-310的规范的倡导者，所以能从Java 8的日期API中看到很多Joda-Time的特性。
Java 8日期/时间类
Java 8的日期和时间类包含LocalDate、LocalTime、Instant、Duration以及Period，这些类都包含在java.time包中，下面我们看看这些类的用法。
LocalDate和LocalTime
LocalDate类表示一个具体的日期，但不包含具体时间，也不包含时区信息。可以通过LocalDate的静态方法of()创建一个实例，LocalDate也包含一些方法用来获取年份，月份，天，星期几等：
LocalDate localDate = LocalDate.of(2017, 1, 4); // 初始化一个日期：2017-01-04
int year = localDate.getYear(); // 年份：2017
Month month = localDate.getMonth(); // 月份：JANUARY
int dayOfMonth = localDate.getDayOfMonth(); // 月份中的第几天：4
DayOfWeek dayOfWeek = localDate.getDayOfWeek(); // 一周的第几天：WEDNESDAY
int length = localDate.lengthOfMonth(); // 月份的天数：31
boolean leapYear = localDate.isLeapYear(); // 是否为闰年：false也可以调用静态方法now()来获取当前日期：
LocalDate now = LocalDate.now();LocalTime和LocalDate类似，他们之间的区别在于LocalDate不包含具体时间，而LocalTime包含具体时间，例如：
LocalTime localTime = LocalTime.of(17, 23, 52); // 初始化一个时间：17:23:52
int hour = localTime.getHour(); // 时：17
int minute = localTime.getMinute(); // 分：23
int second = localTime.getSecond(); // 秒：52LocalDateTime
LocalDateTime类是LocalDate和LocalTime的结合体，可以通过of()方法直接创建，也可以调用LocalDate的atTime()方法或LocalTime的atDate()方法将LocalDate或LocalTime合并成一个LocalDateTime：
LocalDateTime ldt1 = LocalDateTime.of(2017, Month.JANUARY, 4, 17, 23, 52);
LocalDate localDate = LocalDate.of(2017, Month.JANUARY, 4);
LocalTime localTime = LocalTime.of(17, 23, 52);
LocalDateTime ldt2 = localDate.atTime(localTime);
LocalDateTime也提供用于向LocalDate和LocalTime的转化：
LocalDate date = ldt1.toLocalDate();
LocalTime time = ldt1.toLocalTime();Instant
Instant用于表示一个时间戳，它与我们常使用的System.currentTimeMillis()有些类似，不过Instant可以精确到纳秒（Nano-Second），System.currentTimeMillis()方法只精确到毫秒（Milli-Second）。如果查看Instant源码，发现它的内部使用了两个常量，seconds表示从1970-01-01 00:00:00开始到现在的秒数，nanos表示纳秒部分（nanos的值不会超过999,999,999）。Instant除了使用now()方法创建外，还可以通过ofEpochSecond方法创建：
Instant instant = Instant.ofEpochSecond(120, 100000);ofEpochSecond()方法的第一个参数为秒，第二个参数为纳秒，上面的代码表示从1970-01-01 00:00:00开始后两分钟的10万纳秒的时刻，控制台上的输出为：
Duration
Duration的内部实现与Instant类似，也是包含两部分：seconds表示秒，nanos表示纳秒。两者的区别是Instant用于表示一个时间戳（或者说是一个时间点），而Duration表示一个时间段，所以Duration类中不包含now()静态方法。可以通过Duration.between()方法创建Duration对象：
LocalDateTime from = LocalDateTime.of(2017, Month.JANUARY, 5, 10, 7, 0); // 2017-01-05 10:07:00
LocalDateTime to = LocalDateTime.of(2017, Month.FEBRUARY, 5, 10, 7, 0); // 2017-02-05 10:07:00
Duration duration = Duration.between(from, to); // 表示从 2017-01-05 10:07:00 到 2017-02-05 10:07:00 这段时间
long days = duration.toDays(); // 这段时间的总天数
long hours = duration.toHours(); // 这段时间的小时数
long minutes = duration.toMinutes(); // 这段时间的分钟数
long seconds = duration.getSeconds(); // 这段时间的秒数
long milliSeconds = duration.toMillis(); // 这段时间的毫秒数
long nanoSeconds = duration.toNanos(); // 这段时间的纳秒数
Duration对象还可以通过of()方法创建，该方法接受一个时间段长度，和一个时间单位作为参数：
Duration duration1 = Duration.of(5, ChronoUnit.DAYS); // 5天
Duration duration2 = Duration.of(1000, ChronoUnit.MILLIS); // 1000毫秒Period
Period在概念上和Duration类似，区别在于Period是以年月日来衡量一个时间段，比如2年3个月6天：
Period period = Period.of(2, 3, 6);Period对象也可以通过between()方法创建，值得注意的是，由于Period是以年月日衡量时间段，所以between()方法只能接收LocalDate类型的参数：
// 2017-01-05 到 2017-02-05 这段时间
Period period = Period.between(
LocalDate.of(2017, 1, 5),
LocalDate.of(2017, 2, 5));日期的操作和格式化
增加和减少日期
Java 8中的日期/时间类都是不可变的，这是为了保证线程安全。当然，新的日期/时间类也提供了方法用于创建对象的可变版本，比如增加一天或者减少一天：
LocalDate date = LocalDate.of(2017, 1, 5); // 2017-01-05
LocalDate date1 = date.withYear(2016); // 修改为 2016-01-05
LocalDate date2 = date.withMonth(2); // 修改为 2017-02-05
LocalDate date3 = date.withDayOfMonth(1); // 修改为 2017-01-01
LocalDate date4 = date.plusYears(1); // 增加一年 2018-01-05
LocalDate date5 = date.minusMonths(2); // 减少两个月 2016-11-05
LocalDate date6 = date.plus(5, ChronoUnit.DAYS); // 增加5天 2017-01-10格式化日期
新的日期API中提供了一个DateTimeFormatter类用于处理日期格式化操作，它被包含在java.time.format包中，Java 8的日期类有一个format()方法用于将日期格式化为字符串，该方法接收一个DateTimeFormatter类型参数：
LocalDateTime dateTime = LocalDateTime.now();
String strDate1 = dateTime.format(DateTimeFormatter.BASIC_ISO_DATE); // 20170105
String strDate2 = dateTime.format(DateTimeFormatter.ISO_LOCAL_DATE); // 2017-01-05
String strDate3 = dateTime.format(DateTimeFormatter.ISO_LOCAL_TIME); // 14:20:16.998
String strDate4 = dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")); // 2017-01-05
String strDate5 = dateTime.format(DateTimeFormatter.ofPattern("今天是：YYYY年 MMMM DD日 E", Locale.CHINESE)); // 今天是：2017年 一月 05日 星期四同样，日期类也支持将一个字符串解析成一个日期对象，例如：
String strDate6 = "2017-01-05";
String strDate7 = "2017-01-05 12:30:05";
LocalDate date = LocalDate.parse(strDate6, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
LocalDateTime dateTime1 = LocalDateTime.parse(strDate7, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));时区
Java 8中的时区操作被很大程度上简化了，新的时区类java.time.ZoneId是原有的java.util.TimeZone类的替代品。ZoneId对象可以通过ZoneId.of()方法创建，也可以通过ZoneId.systemDefault()获取系统默认时区：
ZoneId shanghaiZoneId = ZoneId.of("Asia/Shanghai");
ZoneId systemZoneId = ZoneId.systemDefault();of()方法接收一个“区域/城市”的字符串作为参数，你可以通过getAvailableZoneIds()方法获取所有合法的“区域/城市”字符串：
Set zoneIds = ZoneId.getAvailableZoneIds(); 对于老的时区类TimeZone，Java 8也提供了转化方法：
ZoneId oldToNewZoneId = TimeZone.getDefault().toZoneId();有了ZoneId，我们就可以将一个LocalDate、LocalTime或LocalDateTime对象转化为ZonedDateTime对象：
LocalDateTime localDateTime = LocalDateTime.now();
ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, shanghaiZoneId);将zonedDateTime打印到控制台为：
2018-07-26T16:30:16.038+08:00[Asia/Shanghai]
ZonedDateTime对象由两部分构成，LocalDateTime和ZoneId，其中2018-07-26T16:30:16.038部分为LocalDateTime，+08:00[Asia/Shanghai]部分为ZoneId。
另一种表示时区的方式是使用ZoneOffset，它是以当前时间和世界标准时间（UTC）/格林威治时间（GMT）的偏差来计算，例如：
ZoneOffset zoneOffset = ZoneOffset.of("+09:00");
LocalDateTime localDateTime = LocalDateTime.now();
OffsetDateTime offsetDateTime = OffsetDateTime.of(localDateTime, zoneOffset);其他历法
Java中使用的历法是ISO 8601日历系统，它是世界民用历法，也就是我们所说的公历。平年有365天，闰年是366天。闰年的定义是：非世纪年，能被4整除；世纪年能被400整除。为了计算的一致性，公元1年的前一年被当做公元0年，以此类推。
此外Java 8还提供了4套其他历法（很奇怪为什么没有汉族人使用的农历），每套历法都包含一个日期类，分别是：
- ThaiBuddhistDate：泰国佛教历
- MinguoDate：中华民国历
- JapaneseDate：日本历
- HijrahDate：伊斯兰历
每个日期类都继承ChronoLocalDate类，所以可以在不知道具体历法的情况下也可以操作。不过这些历法一般不常用，除非是有某些特殊需求情况下才会使用。
这些不同的历法也可以用于向公历转换：
LocalDate date = LocalDate.now();
JapaneseDate jpDate = JapaneseDate.from(date);由于它们都继承ChronoLocalDate类，所以在不知道具体历法情况下，可以通过ChronoLocalDate类操作日期：
Chronology jpChronology = Chronology.ofLocale(Locale.JAPANESE);
ChronoLocalDate jpChronoLocalDate = jpChronology.dateNow();我们在开发过程中应该尽量避免使用ChronoLocalDate，尽量用与历法无关的方式操作时间，因为不同的历法计算日期的方式不一样，比如开发者会在程序中做一些假设，假设一年中有12个月，如果是中国农历中包含了闰月，一年有可能是13个月，但开发者认为是12个月，多出来的一个月属于明年的。再比如假设年份是累加的，过了一年就在原来的年份上加一，但日本天皇在换代之后需要重新纪年，所以过了一年年份可能会从1开始计算。
在实际开发过程中建议使用LocalDate，包括存储、操作、业务规则的解读；除非需要将程序的输入或者输出本地化，这时可以使用ChronoLocalDate类。
常见例子
示例 1、在Java 8中获取今天的日期
Java 8中的LocalDate用于表示当天日期。和java.util.Date不同，它只有日期，不包含时间。当你仅需要表示日期时就用这个类。
LocalDate today = LocalDate.now();
System.out.println("今天的日期是：" + today);输出:
今天的日期是：2016-04-18
上面的代码创建了当天的日期，不含时间信息。打印出的日期格式非常友好，不像老的Date类打印出一堆没有格式化的信息。
示例 2、在Java 8中获取当前的年、月、日信息
LocalDate类提供了获取年、月、日的快捷方法，其实例还包含很多其它的日期属性。通过调用这些方法就可以很方便的得到需要的日期信息，不用像以前一样需要依赖java.util.Calendar类了。
LocalDate today = LocalDate.now();
int year = today.getYear();
int month = today.getMonthValue();
int day = today.getDayOfMonth();
System.out.printf("当前的年 : %d 月 : %d 日 : %d%n", year, month, day);输出:
当前的年 : 2016 月 : 4 日 : 18
看到了吧，在Java 8中得到年、月、日信息是这么简单直观，想用就用，没什么需要记的。对比看看以前Java是怎么处理年月日信息的吧。
示例 3、在Java 8中获取特定日期
在第一个例子里，我们通过静态工厂方法now()非常容易地创建了当天日期，你还可以调用另一个有用的工厂方法LocalDate.of()创建任意日期，该方法需要传入年、月、日做参数，返回对应的LocalDate实例。这个方法的好处是没再犯老API的设计错误，比如年度起始于1900，月份是从0开始等等。日期所见即所得，就像下面这个例子表示了1月14日，没有任何隐藏机关。
LocalDate dateOfBirth = LocalDate.of(2016, 4, 18);
System.out.println("你的出生日期是：" + dateOfBirth);输出:
你的出生日期是：2016-04-18
可以看到创建的日期完全符合预期，与你写入的2016年4月18日完全一致。
示例 4、在Java 8中判断两个日期是否相等
现实生活中有一类时间处理就是判断两个日期是否相等。你常常会检查今天是不是个特殊的日子，比如生日、纪念日或非交易日。这时就需要把指定的日期与某个特定日期做比较，例如判断这一天是否是假期。下面这个例子会帮助你用Java 8的方式去解决，你肯定已经想到了，LocalDate重载了equal方法，请看下面的例子：
LocalDate today = LocalDate.now();
LocalDate date1 = LocalDate.of(2016, 4, 18);
if (date1.equals(today)) {
System.out.printf("今天 %s 和 date1 %s 是同一天!%n", today, date1);
}输出:
今天 2016-04-18 和 date1 2016-04-18 是同一天!
这个例子中我们比较的两个日期相同。注意，如果比较的日期是字符型的，需要先解析成日期对象再作判断。对比Java老的日期比较方式，你会感到清风拂面。
示例 5、在Java 8中检查像生日这种周期性事件
Java中另一个日期时间的处理就是检查类似每月账单、结婚纪念日、EMI日或保险缴费日这些周期性事件。如果你在电子商务网站工作，那么一定会有一个模块用来在圣诞节、感恩节这种节日时向客户发送问候邮件。Java中如何检查这些节日或其它周期性事件呢？答案就是MonthDay类。这个类组合了月份和日，去掉了年，这意味着你可以用它判断每年都会发生事件。和这个类相似的还有一个YearMonth类。这些类也都是不可变并且线程安全的值类型。下面我们通过MonthDay来检查周期性事件：
LocalDate today = LocalDate.now();
LocalDate dateOfBirth = LocalDate.of(2016, 4, 18);
MonthDay birthday = MonthDay.of(dateOfBirth.getMonth(), dateOfBirth.getDayOfMonth());
MonthDay currentMonthDay = MonthDay.from(today);
if(currentMonthDay.equals(birthday)){
System.out.println("好高兴今天是您的生日!!");
}else{
System.out.println("对不起，今天不是您的生日!!");
}输出:
好高兴今天是您的生日!!
只要当天的日期和生日匹配，无论是哪一年都会打印出祝贺信息。你可以把程序整合进系统时钟，看看生日时是否会受到提醒，或者写一个单元测试来检测代码是否运行正确。
示例 6、在Java 8中获取当前时间
与Java 8获取日期的例子很像，获取时间使用的是LocalTime类，一个只有时间没有日期的LocalDate的近亲。可以调用静态工厂方法now()来获取当前时间。默认的格式是hh:mm:ss:nnn。对比一下Java 8之前获取当前时间的方式。
LocalTime time = LocalTime.now();
System.out.println("当前时间是:" + time);输出:
当前时间是:23:43:42.200
可以看到当前时间就只包含时间信息，没有日期。
示例 7、如何在现有的时间上增加小时
通过增加小时、分、秒来计算将来的时间很常见。Java 8除了不变类型和线程安全的好处之外，还提供了更好的plusHours()方法替换add()，并且是兼容的。注意，这些方法返回一个全新的LocalTime实例，由于其不可变性，返回后一定要用变量赋值。
LocalTime time = LocalTime.now();
LocalTime newTime = time.plusHours(2); // 添加两小时
System.out.println("当前时间:" + time + ",两小时后的时间: " + newTime);输出:
当前时间:23:50:56.195,两小时后的时间: 01:50:56.195
可以看到，新的时间在当前时间23:50:56.195的基础上增加了2个小时。和旧版Java的增减时间的处理方式对比一下，看看哪种更好。
示例 8、如何计算一周后的日期
和上个例子计算两小时以后的时间类似，这个例子会计算一周后的日期。LocalDate日期不包含时间信息，它的plus()方法用来增加天、周、月，ChronoUnit类声明了这些时间单位。由于LocalDate也是不变类型，返回后一定要用变量赋值。
LocalDate today = LocalDate.now();
LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS);
System.out.println("今天是:" + today + ",一周以后的日期: " + nextWeek);输出:
今天是:2016-04-18,一周以后的日期: 2016-04-25
可以看到新日期离当天日期是7天，也就是一周。你可以用同样的方法增加1个月、1年、1小时、1分钟甚至一个世纪，更多选项可以查看Java 8 API中的ChronoUnit类。
示例 9、计算一年前或一年后的日期
继续上面的例子，上个例子中我们通过LocalDate的plus()方法增加天数、周数或月数，这个例子我们利用minus()方法计算一年前的日期。
LocalDate today = LocalDate.now();
LocalDate preYear = today.minus(1, ChronoUnit.YEARS);
LocalDate nextYear = today.plus(1, ChronoUnit.YEARS);
System.out.println("今天是:" + today + ",一年前的日期: " + preYear + ",一年后的日期: " + nextYear);输出:
今天是:2016-04-18,一年前的日期: 2015-04-18,一年后的日期: 2017-04-18
例子结果中得到了两个日期，一个2015年、一个2017年、分别是2016年的前一年和后一年。
示例 10、使用Java 8的Clock时钟类
Java 8增加了一个Clock时钟类用于获取当时的时间戳，或当前时区下的日期时间信息。以前用到System.currentTimeInMillis()和TimeZone.getDefault()的地方都可用Clock替换。
// 得到UTC的时区的日期时间clock对象
Clock clock = Clock.systemUTC();
System.out.println("Clock : " + clock);
// 得到基于当前时区的日期时间clock对象
Clock defaultClock = Clock.systemDefaultZone();
System.out.println("Clock : " + clock);输出:
Clock : SystemClock[Z]
Clock : SystemClock[Z]
还可以针对clock时钟做比较，像下面这个例子：
public class MyClass {
// 依赖注入
private Clock clock;
...
public void process(LocalDate eventDate) {
if (eventDate.isBefore(LocalDate.now(clock)) {
...
}
}
}这种方式在不同时区下处理日期时会非常管用。
示例 11、如何用Java判断日期是早于还是晚于另一个日期
另一个工作中常见的操作就是如何判断给定的一个日期是大于某天还是小于某天？在Java 8中，LocalDate类有两类方法isBefore()和isAfter()用于比较日期。调用isBefore()方法时，如果给定日期小于当前日期则返回true。
LocalDate today = LocalDate.now();
LocalDate tomorrow = LocalDate.of(2016, 4, 19);
if (tomorrow.isAfter(today)) {
System.out.println("明天晚于今天！");
}
LocalDate yesterday = today.minus(1, ChronoUnit.DAYS);
if (yesterday.isBefore(today)) {
System.out.println("昨天先于今天！");
}输出:
明天晚于今天！
昨天先于今天！
在Java 8中比较日期非常方便，不需要使用额外的Calendar类来做这些基础工作了。
示例 12、在Java 8中处理时区
Java 8不仅分离了日期和时间，也把时区分离出来了。现在有一系列单独的类如ZoneId来处理特定时区，ZoneDateTime类来表示某时区下的时间。这在Java 8以前都是GregorianCalendar类来做的。下面这个例子展示了如何把本时区的时间转换成另一个时区的时间。
// Java 8中某时区下的日期和时间
ZoneId america = ZoneId.of("America/New_York");
LocalDateTime localtDateAndTime = LocalDateTime.now();
ZonedDateTime dateAndTimeInNewYork = ZonedDateTime.of(localtDateAndTime, america );
System.out.println("Current date and time in a particular timezone : " + dateAndTimeInNewYork);输出:
Current date and time in a particular timezone : 2016-04-19T23:10:09.251-04:00[America/New_York]
和以前使用GMT的方式转换本地时间对比一下。注意，在Java 8以前，一定要牢牢记住时区的名称，不然就会抛出下面的异常：
Exception in thread "main" java.time.zone.ZoneRulesException: Unknown time-zone ID: ASIA/Tokyo
at java.time.zone.ZoneRulesProvider.getProvider(ZoneRulesProvider.java:272)
at java.time.zone.ZoneRulesProvider.getRules(ZoneRulesProvider.java:227)
at java.time.ZoneRegion.ofId(ZoneRegion.java:120)
at java.time.ZoneId.of(ZoneId.java:403)
at java.time.ZoneId.of(ZoneId.java:351)
示例 13、如何表示信用卡到期这类固定日期，答案就在YearMonth
与MonthDay检查重复事件的例子相似，YearMonth是另一个组合类，用于表示信用卡到期日、FD到期日、期货期权到期日等。还可以用这个类得到当月共有多少天，YearMonth实例的lengthOfMonth()方法可以返回当月的天数，在判断2月有28天还是29天时非常有用。
YearMonth currentYearMonth = YearMonth.now();
System.out.printf("该月的天数 %s: %d%n", currentYearMonth, currentYearMonth.lengthOfMonth());
YearMonth creditCardExpiry = YearMonth.of(2018, Month.FEBRUARY);
System.out.printf("您的信用卡到期是： %s%n", creditCardExpiry);输出:
该月的天数 2016-04: 30
您的信用卡到期是： 2018-02
根据上述数据，你可以提醒客户信用卡快要到期了，个人认为这个类非常有用。
示例 14、如何在Java 8中检查闰年
LocalDate类有一个很实用的方法isLeapYear()判断该实例是否是一个闰年，如果你还是想重新发明轮子，这有一个代码示例，纯Java逻辑编写的判断闰年的程序。
LocalDate today = LocalDate.now();
if (today.isLeapYear()) {
System.out.println("今年是闰年！");
} else {
System.out.println("今年不是闰年！");
}输出:
今年是闰年！
你可以多写几个日期来验证是否是闰年，最好是写JUnit单元测试做判断。
示例 15、计算两个日期之间的天数和月数
有一个常见日期操作是计算两个日期之间的天数、周数或月数。在Java 8中可以用java.time.Period类来做计算。下面这个例子中，我们计算了当天和将来某一天之间的月数。
LocalDate today = LocalDate.now();
LocalDate java8Release = LocalDate.of(2016, Month.APRIL, 21);
Period periodToNext = Period.between(today, java8Release);
System.out.println("2016年4月21日距离今天的天数：" + periodToNext.getDays() );输出:
2016年4月21日距离今天的天数：3
从上面可以看到现在是一月，Java 8的中计算的当前日期是4月18日，中间相隔3天。
示例 16、包含时差信息的日期和时间
在Java 8中，ZoneOffset类用来表示时区，举例来说印度与GMT或UTC标准时区相差+05:30，可以通过ZoneOffset.of()静态方法来 获取对应的时区。一旦得到了时差就可以通过传入LocalDateTime和ZoneOffset来创建一个OffSetDateTime对象。
LocalDateTime datetime = LocalDateTime.of(2016, Month.APRIL, 19, 23, 35);
ZoneOffset offset = ZoneOffset.of("+05:30");
OffsetDateTime date = OffsetDateTime.of(datetime, offset);
System.out.println("包含时差信息的日期和时间 : " + date);Output :
包含时差信息的日期和时间 : 2016-04-19T23:35+05:30
现在的时间信息里已经包含了时区信息了。注意：OffSetDateTime是对计算机友好的，ZoneDateTime则对人更友好。
示例 17、在Java 8中获取当前的时间戳
如果你还记得Java 8以前是如何获得当前时间戳，那么现在你终于解脱了。Instant类有一个静态工厂方法now()会返回当前的时间戳，如下所示：
Instant timestamp = Instant.now();
System.out.println("时间戳是：" + timestamp);Output :
时间戳是：2016-04-18T15:41:06.876Z
时间戳信息里同时包含了日期和时间，这和java.util.Date很像。实际上Instant类确实等同于Java 8之前的Date类，你可以使用Date类和Instant类各自的转换方法互相转换，例如：Date.from(Instant) 将Instant转换成java.util.Date，Date.toInstant()则是将Date类转换成Instant类。
示例 18、在Java 8中如何使用预定义的格式化工具去解析或格式化日期
在Java 8以前的世界里，日期和时间的格式化非常诡异，唯一的帮助类SimpleDateFormat也是非线程安全的，而且用作局部变量解析和格式化日期时显得很笨重。幸好线程局部变量能使它在多线程环境中变得可用，不过这都是过去时了。Java 8引入了全新的日期时间格式工具，线程安全而且使用方便。它自带了一些常用的内置格式化工具。下面这个例子使用了BASIC_ISO_DATE格式化工具将2016年4月18日格式化成20160418。
String day = "20160418";
LocalDate formatted = LocalDate.parse(day, DateTimeFormatter.BASIC_ISO_DATE);
System.out.printf("从字符串中解析的日期: %s 是 %s %n", day, formatted);输出 :
从字符串中解析的日期: 20160418 是 2016-04-18
很明显的看出得到的日期和给出的日期是同一天，但是格式不同。
示例 19、如何在Java中使用自定义格式化工具解析日期
上个例子使用了Java内置的格式化工具去解析日期字符串。尽管内置格式化工具很好用，有时还是需要定义特定的日期格式，下面这个例子展示了如何创建自定义日期格式化工具。例子中的日期格式是“MMM dd yyyy”。可以调用DateTimeFormatter的ofPattern()静态方法并传入任意格式返回其实例，格式中的字符和以前代表的一样，M代表月，m代表分。如果格式不规范会抛出DateTimeParseException异常，不过如果只是把M写成m这种逻辑错误是不会抛异常的。
String day = "2016 04 18";
try {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy MM dd");
LocalDate holiday = LocalDate.parse(day, formatter);
System.out.printf("成功解析字符串：%s, 时间是：%s%n", day, holiday);
} catch (DateTimeParseException ex) {
System.out.printf("%s 解析失败!", day);
ex.printStackTrace();
}Output :
成功解析字符串：2016 04 18, 时间是：2016-04-18
日期值与传入的字符串是匹配的，只是格式不同而已。
示例 20、在Java 8中如何把日期转换成字符串
上 两个例子都用到了DateTimeFormatter类，主要是从字符串解析日期。现在我们反过来，把LocalDateTime日期实例转换成特定格式的字符串。这是迄今为止Java日期转字符串最为简单的方式了。下面的例子将返回一个代表日期的格式化字符串。和前面类似，还是需要创建DateTimeFormatter实例并传入格式，但这回调用的是format()方法，而非parse()方法。这个方法会把传入的日期转化成指定格式的字符串。
LocalDateTime arrivalDate = LocalDateTime.now();
try {
DateTimeFormatter format = DateTimeFormatter.ofPattern("MMM dd yyyy hh:mm a");
String landing = arrivalDate.format(format);
System.out.printf("格式化的日期时间: %s %n", landing);
} catch (DateTimeException ex) {
System.out.printf("%s 不能格式化!%n", arrivalDate);
ex.printStackTrace();
}输出:
格式化的日期时间: 四月 19 2016 12:02 上午
当前时间被指定的“MMM dd yyyy hh:mm a”格式格式化，格式包含3个代表月的字符串，时间后面带有AM和PM标记。
Java 8日期时间API的重点
通过这些例子，你肯定已经掌握了Java 8日期时间API的新知识点。现在我们来回顾一下这个优雅API的使用要点：
- 提供了javax.time.ZoneId获取时区。
- 提供了LocalDate``和LocalTime类。
- Java 8的所有日期和时间API都是不可变类并且线程安全，而现有的Date和Calendar API中的java.util.Date和SimpleDateFormat是非线程安全的。
- 主包是java.time,包含了表示日期、时间、时间间隔的一些类。里面有两个子包java.time.format用于格式化， java.time.temporal用于更底层的操作。
- 时区代表了地球上某个区域内普遍使用的标准时间。每个时区都有一个代号，格式通常由区域/城市构成（Asia/Tokyo），在加上与格林威治或UTC的时差。例如：东京的时差是+09:00。
- OffsetDateTime类实际上组合了LocalDateTime类和ZoneOffset类。用来表示包含和格林威治或UTC时差的完整日期（年、月、日）和时间（时、分、秒、纳秒）信息。
- DateTimeFormatter类用来格式化和解析时间。与SimpleDateFormat不同，这个类不可变并且线程安全，需要时可以给静态常量赋值。DateTimeFormatter类提供了大量的内置格式化工具，同时也允许你自定义。在转换方面也提供了parse()将字符串解析成日期，如果解析出错会抛出DateTimeParseException。DateTimeFormatter类同时还有format()用来格式化日期，如果出错会抛出DateTimeException异常。
- 再补充一点，日期格式“MMM d yyyy”和“MMM dd yyyy”有一些微妙的不同，第一个格式可以解析“Jan 2 2014”和“Jan 14 2014”，而第二个在解析“Jan 2 2014”就会抛异常，因为第二个格式里要求日必须是两位的。如果想修正，你必须在日期只有个位数时在前面补零，就是说“Jan 2 2014”应该写成 “Jan 02 2014”。
如何使用Java 8的全新日期时间API就介绍到这了。这些简单的例子对帮助理解新API非常有用。由于这些例子都基于真实任务，你在做Java日期编程时不用再东张西望了。我们学会了如何创建并操作日期实例，学习了纯日期、以及包含时间信息和时差信息的日期、学会了怎样计算两个日期的间隔，这些在计算当天与某个特定日期间隔的例子中都有所展示。 我们还学到了在Java 8中如何线程安全地解析和格式化日期，不用再使用蹩脚的线程局部变量技巧，也不用依赖Joda Time第三方库。新API可以作为处理日期时间操作的标准。
参考：
http://blinkfox.com/java-8zhong-guan-yu-ri-qi-he-shi-jian-apide-20ge-shi-yong-shi-li/
https://lw900925.github.io/java/java8-newtime-api.html