使用Java8，新的日期时间API引入覆盖旧的日期时间API的以下缺点。
非线程安全&- java.util.Date不是线程安全的，因此开发者必须在使用日期处理并发性问题。新的日期时间API是不可变的，并且没有setter方法。
设计不佳&- 默认的开始日期从1900年，开始每月从1天从0开始，所以没有统一。不直接使用方法操作日期。新的API提供了这样操作实用方法。
困难的时区处理&- 开发人员必须编写大量的代码来处理时区的问题。新的API设计开发保持特定领域设计。
JAVA8引入了java.time包 - 下一个新的日期时间API。以下是一些在java.time程序包引入重要的类。
本地&- 简化日期时间API，没有时间处理区的复杂性。
时区&- 专业的日期时间API来处理各种时区。
使用描述方法
LocalDate/本地时间和LocalDateTime类简化时区不需要开发。
时区日期时间API使用的时区是需要考虑的。
java.time.temporal.ChronoUnit枚举在Java8添加，以取代旧的API用来代表日，月等整数值
这些类引入到处理时间的差异。
TemporalAdjuster是做数学日期。例如，要获得&本月第二个星期六&或&下周二&。
toInstant()方法被添加到可用于将它们转换到新的日期时间的API原始日期和日历对象。
本站代码下载：Java时区处理之夏令时，冬令时 - 美国的6个时区
时间： 02:07:11
&&&& 阅读：4010
&&&& 评论：
&&&& 收藏：
标签：&&&&&&&&&&&&??????? 在开始之前，如果要了解Java中的时区操作的基本概念和事例，可以参见另一篇博客：
一、夏令时概述：
Daylight Saving Time：DST????夏令时，又称“日光节约时制”或“夏时制”，是一种为节约能源而人为规定地方时间的制度，在这一制度实行期间所采用的统一时间称为“夏令时间”。一般在天亮早的夏季人为将时间提前一小时，可以使人早起早睡，减少照明量，以充分利用光照资源，从而节约照明用电。各个采纳夏令时的国家具体规定不同。目前全世界有近110个国家每年要实行夏令时。（各时区多数位于其理想边界之西，导致实际上全年实施夏令时。）
????? 1986年至1991年，中华人民共和国在全国范围实行了六年夏令时，每年从4月中旬的第一个星期日2时整（北京时间）到9月中旬第一个星期日的凌晨2时 整（北京夏令时）。除1986年因是实行夏令时的第一年，从5月4日开始到9月14日结束外，其它年份均按规定的时段施行。日后不再实 行。其实，1916年，德国首先实行夏令时，英国因为怕德国会从中得到更大的效益，因此紧跟着也采取了夏令时。日本现在没有实行夏令时，但是在美国驻军的1948年到1951年使用了夏令时。另外自日开始俄罗斯永久使用夏令时，把时间拨快一小时，不再调回。 夏令时会导致某一天多出一个小时，或者少出一个小时。
1、先来看一个有趣的实例：号0点不见了
package com.wsheng.aggregator.
import java.text.DateF
import java.text.SimpleDateF
import java.util.D
* 号的0点不见了
* @author Josh Wang(Sheng)
public class DST1 {
public static final DateFormat Y2MD_HMS = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
public static void main(String[] args) throws Exception {
Date d = DST1.Y2MD_HMS.parse(" 0:0:0");
System.out.println(d);
?执行结果：
Sun May 04 01:00:00 CDT 1986
从上面的概述可以知道，这是因为中国在当天还在使用夏令时，时间被拨快了1个小时。
2、再来一个实例：预期的0点也没有了
package com.wsheng.aggregator.
import java.text.DateF
import java.text.SimpleDateF
import java.util.C
import java.util.D
* @author Josh Wang(Sheng)
public class DST2 {
public static void main(String[] args) throws Exception {
DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:SS");
String sTime = " 00:00:00";
Date time = sdf.parse(sTime);
Calendar cd = Calendar.getInstance();
cd.setTime(time);
cd.add(Calendar.DATE, 7);
time = cd.getTime();
System.out.println(sdf.format(time));
?预期结果： 00:00:00
?实际结果：?
从上面的分析也很容易得出，这也是由于当时的时间中国正在实习夏令时，使用 Calendar.DST_OFFSET 可以获得偏移量，其实夏令时是通过 TimeZone 的子类 sun.util.calendar.ZoneInfo 实现的。 ZoneInfo 中的数据存放于 %JRE_HOME%/lib/zi 目录中。（注意，是在jre的目录下）我们机器一般采用的时区名称为 Asia/Shanghai，相对应的时区信息文件位于：%JRE_HOME%/lib/zi/Asia/Shanghai 中，这是一个二进制文件。可通过 sun.util.calendar.ZoneInfoFile 的解析，可以获得需要采用夏令时的时间为：
01:00:00 ~
01:00:00 ~
01:00:00 ~
01:00:00 ~
01:00:00 ~
01:00:00 ~
01:00:00 ~
01:00:00 ~
?前段表示那一天开始的时间，也就是说那一天的 0 点在该时区中是不存在。
后段表示那一天结束的时间，由于每个时区的夏令时都不一样，编程语言中的夏令时算法比较复杂，如在北京时区：
如果当前时间为： 23:00:00，增加 1 小时后为
如果当前时间为： 22:00:00，增加 2 小时后为
23:00:00，因为
23:00:00 是夏令时结束时间，时钟需要回拨。
3、更具体的例子说明：美国洛杉矶的夏令时和冬令时
3.1、Java中不是每天都是标准的24个小时，可能是23，也可能是25。23小时和25小时就是夏令时、冬令时引起的。
3.2、下面用一个实例来判断中国和洛杉矶在1970年以来到从开始到往后的5年内对夏令时和冬令时的使用情况：
package com.wsheng.aggregator.
import java.text.DateF
import java.text.SimpleDateF
import java.util.C
import java.util.D
import java.util.TimeZ
* 测试看看中国和美国洛杉矶在1970年以来到从现在开始的5年后的时间里，什么时候
* 使用夏令时，什么时候没有使用夏令时
* @author Josh Wang(Sheng)
public class DST3 {
private static void testDayTime(TimeZone timeZone) {
System.out.println("Time Zone is : " + timeZone.getDisplayName() + " : " + timeZone.getID());
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar start = Calendar.getInstance(timeZone);
start.setTime(new Date(0)); // UTC
System.out.println("start=" + df.format(start.getTime()));
// will print: start= 08:00:00
Calendar end = Calendar.getInstance(timeZone);
end.add(Calendar.YEAR, 5);
System.out.println("end=" + df.format(end.getTime()));
boolean find =
for (long i = start.getTimeInMillis(); i & end.getTimeInMillis(); i = start.getTimeInMillis()) {
start.add(Calendar.DATE, 1); // add one day
if ((start.getTimeInMillis() - i) % (24 * 3600 * 1000L) != 0) { // 是否能被24整除
System.out.println("from " + df.format(new Date(i)) + " to " + df.format(start.getTime()) + " has "
+ (start.getTimeInMillis() - i) + "ms" + "[" + (start.getTimeInMillis() - i) / (3600 * 1000L)
+ "hours]");
if (!find) {
System.out.println("Every day is ok.");
public static void main(String[] args) {
TimeZone timeZone = TimeZone.getDefault();
DST3.testDayTime(timeZone);
System.out.println(" -------------------- ");
timeZone = TimeZone.getTimeZone("GMT");
DST3.testDayTime(timeZone);
System.out.println(" -------------------- ");
timeZone = TimeZone.getTimeZone("America/Los_Angeles");
DST3.testDayTime(timeZone);
输出结果：
Time Zone is : China Standard Time : Asia/Shanghai
start= 08:00:00
end= 16:24:55
08:00:00 to
08:00:00 has ms[23hours]
08:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
08:00:00 has ms[23hours]
08:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
08:00:00 has ms[23hours]
08:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
08:00:00 has ms[23hours]
08:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
08:00:00 has ms[23hours]
08:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
08:00:00 has ms[23hours]
08:00:00 to
08:00:00 has ms[25hours]
--------------------
Time Zone is : Greenwich Mean Time : GMT
start= 08:00:00
end= 16:24:55
Every day is ok.
--------------------
Time Zone is : Pacific Standard Time : America/Los_Angeles
start= 08:00:00
end= 16:24:55
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
07:00:00 to
08:00:00 has ms[25hours]
08:00:00 to
07:00:00 has ms[23hours]
从输出结果可以看出：中国时区在1992年后就废除了夏令时、冬令时，GMT时区是不存在夏令时、冬令时，而美国洛杉矶一直在用夏令时、冬令时。
4、事例：好奇一天怎么会变23，25小时，继续试验。
在开始该实例时，有必要交代一下美国的时区，美国横跨西五区至西十区，共六个时区。每个时区对应一个标准时间，从东向西分别为东部时间(EST)(西五区时间)、中部时间(CST)(西六区时间)、山地时间(MST)(西七区时间)、(西部时间)(PST)(西八区时间)、时间(AKST)(西九区时间)和夏威夷时间(HST)(西十区时间)，按照“东早西晚”的规律，各递减一小时。（由于美国使用夏令时，所以这些时区可以看做是冬令时，即夏令时结束后回拨回来的标准时间， 冬令时是在冬天使用的。在使用的地区，夏天时钟拨快一，冬天再拨回来。这时采用的是标准时间，也就是冬令时。）
美国标准时间
与北京时间时差(小时)
如上标准时间（冬令时）一 一对应的夏令时为：
夏季始于每年4月的第1个周日，止于每年10月的最后一个周日。也称为DST: Daylight Saving Time 。。
美国夏季时间
与北京时间时差(小时)
比如对于太平洋时区而言，标准时区（冬令时时区）为PST，夏令时时区为PDT。这个地方需要注意的是CST（中部时区），CST除了代表美国的西部时区外，还可以代表别的3个时区，即CST却同时可以代表如下 4 个不同的时区：?
Central Standard Time (USA) UT-6:00
Central Standard Time (Australia) UT+9:30
China Standard Time UT+8:00
Cuba Standard Time UT-4:00
可见，CST可以同时表示美国，澳大利亚，中国，古巴四个国家的标准时间。 有时做前后端开发的时候会碰到一些奇怪的问题，比如：
????? 在服务器端通过 Java 获取当前时间为 Fri Aug 28 09:37:46 CST 2009， 转化为GMT时间为：28 Aug :46 GMT，也就是说GMT时间加上 8 个小时等于CST表示的时间， 那这个CST不就是北京时间么，因为我们是在东八区的。 一切看起来很正常，不过在客户端用JavaScript解析这个时间就有问题了：? ??? // Fri Aug 28 :46 GMT+0800?? new Date(‘Fri Aug 28 09:37:46 CST 2009‘).toString();??? 好奇怪，这次GMT和CST表示的时间居然相差整整 14 个小时？
这就是因为CST可以代表多个时区引起来的，通过 Java 获取的CST时间用的是China Standard Time，而客户端JavaScript则默认采用的是美国的中部时间，所以整整相差了14个小时，所以将 Fri Aug 28 09:37:46 CST 2009 加上 6 个小时，再加上 8 个小时，就等于 Fri Aug 28 :46GMT+0800? ?可见，在以后的编程中为了避免错误，还是不要使用CST时间，而尽量采用GMT时间。
下面回到我们要说的例子上来：
package com.wsheng.aggregator.
import java.text.DateF
import java.text.SimpleDateF
import java.util.D
import java.util.TimeZ
* 为什么一天会变成23、25小时
* @author Josh Wang(Sheng)
public class DST4 {
private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args) {
// 特殊时间点
long abc = 0l;
printDate(abc);
printDate(abc);
private static void printDate(long now) {
// 中国时间
// TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
// System.out.println(new Date(now).toString());
// System.out.println(new Date(now).toLocaleString());
// 美国时间
TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
Date date = new Date(now);
System.out.println(date);
System.out.println(df.format(date));
System.out.println("============================================================");
执行结果：
Sun Nov 02 01:59:59 PDT 2014
============================================================
Sun Nov 02 01:00:00 PST 2014
============================================================
发现long值为0l，美国时间是 1:59:59；但增加一秒0l，美国时间却是 1:00:00，这不是错误，仔细观察下你会发现，0l是夏令时PDT的?Sun Nov 02 01:59:59 PDT 2014；而0l是冬令时PST的?Sun Nov 02 01:00:00 PST 2014。
至此问题问题就明白了！！！
解决方案：
在Java中，想到Date和时区有关系，那只要在日期转换前设置下时区就解决问题了。
private static String conventTime(long time) {
// 中国时间
// TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
// 美国时间
TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"));
return new Date(time).toLocaleString();
1. 原来Java中不是每天都是标准的24个小时，可能是23，也可能是25
2. 日期的计算，使用Calendar提供的API，是不会出差错的，简单的new Date(long milliseconds)并不靠谱
3. 来自多方协作的项目，最好使用统一的时间标准，例如系统时间，或是统一时区
?标签：&&&&&&&&&&&&原文：http://josh-/blog/2230341
教程昨日排行
&&国之画&&&& &&&&&&
&& &&&&&&&&&&&&&&
鲁ICP备号-4
打开技术之扣，分享程序人生！伴随lambda表达式、streams以及一系列小优化，Java 8 推出了全新的日期时间API，在教程中我们将通过一些简单的实例来学习如何使用新API。Java处理日期、日历和时间的方式一直为社区所诟病，将 java.util.Date设定为可变类型，以及SimpleDateFormat的非线程安全使其应用非常受限。Java也意识到需要一个更好的 API来满足社区中已经习惯了使用JodaTime API的人们。全新API的众多好处之一就是，明确了日期时间概念，例如：瞬时（instant）、 长短（duration）、日期、时间、时区和周期。同时继承了Joda库按人类语言和计算机各自解析的时间处理方式。不同于老版本,新API基于ISO标准日历系统，java.time包下的所有类都是不可变类型而且线程安全。下面是新版API中java.time包里的一些关键类：
Instant：瞬时实例。
LocalDate：本地日期，不包含具体时间 例如： 可以用来记录生日、纪念日、加盟日等。
LocalTime：本地时间，不包含日期。 LocalDateTime：组合了日期和时间，但不包含时差和时区信息。
ZonedDateTime：最完整的日期时间，包含时区和相对UTC或格林威治的时差。
新API还引入了ZoneOffSet和ZoneId类，使得解决时区问题更为简便。解析、格式化时间的DateTimeFormatter类也全部重新设 计。注意，这篇文章是我在一年前Java 8即将发布时写的，以下示例代码中的时间都是那一年的，当运行这些例子时会返回你当前的时间。
在Java 8中如何处理日期和时间
常有人问我学习一个新库的最好方式是什么？我的答案是在实际项目中使用它。项目中有很多真正的需求驱使开发者去发掘并学习新库。简单得说就是任务驱动学习探 索。这对Java 8新日期时间API也不例外。我创建了20个基于任务的实例来学习Java 8的新特性。从最简单创建当天的日期开始，然后创建时间及时区，接着模拟一个日期提醒应用中的任务——计算重要日期的到期天数，例如生日、纪念日、账单 日、保费到期日、信用卡过期日等。
示例 1、在Java 8中获取今天的日期
Java 8 中的 LocalDate 用于表示当天日期。和java.util.Date不同，它只有日期，不包含时间。当你仅需要表示日期时就用这个类。
LocalDate today = LocalDate.now();
System.out.println("Today's Local date : " + today);
Today's Local date : 2014-01-14
上面的代码创建了当天的日期，不含时间信息。打印出的日期格式非常友好，不像老的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("Year : %d
Month : %d
day : %d t %n", year, month, day);
Year : 2014
看到了吧，在Java 8 中得到年、月、日信息是这么简单直观，想用就用，没什么需要记的。对比看看以前Java是怎么处理年月日信息的吧。
示例 3、在Java 8中处理特定日期
在 第一个例子里，我们通过静态工厂方法now()非常容易地创建了当天日期，你还可以调用另一个有用的工厂方法LocalDate.of()创建任意日期， 该方法需要传入年、月、日做参数，返回对应的LocalDate实例。这个方法的好处是没再犯老API的设计错误，比如年度起始于1900，月份是从0开 始等等。日期所见即所得，就像下面这个例子表示了1月14日，没有任何隐藏机关。
LocalDate dateOfBirth = LocalDate.of(2010, 01, 14);
System.out.println("Your Date of birth is : " + dateOfBirth);
Output : Your Date of birth is : 2010-01-14
可以看到创建的日期完全符合预期，与你写入的日完全一致。
示例 4、在Java 8中判断两个日期是否相等
现 实生活中有一类时间处理就是判断两个日期是否相等。你常常会检查今天是不是个特殊的日子，比如生日、纪念日或非交易日。这时就需要把指定的日期与某个特定 日期做比较，例如判断这一天是否是假期。下面这个例子会帮助你用Java 8的方式去解决，你肯定已经想到了，LocalDate重载了equal方法，请看下面的例子：
LocalDate date1 = LocalDate.of(2014, 01, 14);
if(date1.equals(today)){
System.out.printf("Today %s and date1 %s are same date %n", today, date1);
today 2014-01-14 and date1 2014-01-14 are same date
这个例子中我们比较的两个日期相同。注意，如果比较的日期是字符型的，需要先解析成日期对象再作判断。对比Java老的日期比较方式，你会感到清风拂面。
示例 5、在Java 8中检查像生日这种周期性事件
Java 中另一个日期时间的处理就是检查类似每月账单、结婚纪念日、EMI日或保险缴费日这些周期性事件。如果你在电子商务网站工作，那么一定会有一个模块用来在 圣诞节、感恩节这种节日时向客户发送问候邮件。Java中如何检查这些节日或其它周期性事件呢？答案就是MonthDay类。这个类组合了月份和日，去掉 了年，这意味着你可以用它判断每年都会发生事件。和这个类相似的还有一个YearMonth类。这些类也都是不可变并且线程安全的值类型。下面我们通过 MonthDay来检查周期性事件：
LocalDate dateOfBirth = LocalDate.of(2010, 01, 14)
MonthDay birthday = MonthDay.of(dateOfBirth.getMonth(), dateOfBirth.getDayOfMonth())
MonthDay currentMonthDay = MonthDay.from(today)
if(currentMonthDay.equals(birthday)){
System.out.println("Many Many happy returns of the day !!")
System.out.println("Sorry, today is not your birthday")
Many Many happy returns of the day !!
只要当天的日期和生日匹配，无论是哪一年都会打印出祝贺信息。你可以把程序整合进系统时钟，看看生日时是否会受到提醒，或者写一个单元测试来检测代码是否运行正确。
示例 6、在Java 8中获取当前时间
与Java 8获取日期的例子很像，获取时间使用的是LocalTime类，一个只有时间没有日期的LocalDate近亲。可以调用静态工厂方法now()来获取当前时间。默认的格式是hh:mm:ss:nnn。对比一下Java 8之前获取当前时间的方式。
LocalTime time = LocalTime.now();
System.out.println("local time now : " + time);
local time now : 16:33:33.369
// in hour, minutes, seconds, nano seconds
可以看到当前时间就只包含时间信息，没有日期。
示例 7、如何在现有的时间上增加小时
通过增加小时、分、秒来计算将来的时间很常见。Java 8除了不变类型和线程安全的好处之外，还提供了更好的plusHours()方法替换add()，并且是兼容的。注意，这些方法返回一个全新的LocalTime实例，由于其不可变性，返回后一定要用变量赋值。
LocalTime time = LocalTime.now();
LocalTime newTime = time.plusHours(2); // adding two hours
System.out.println("Time after 2 hours : " +
Time after 2 hours : 18:33:33.369
可以看到，新的时间在当前时间16:33:33.369的基础上增加了2个小时。和旧版Java的增减时间的处理方式对比一下，看看哪种更好。
示例 8、如何计算一周后的日期
和上个例子计算两小时以后的时间类似，这个例子会计算一周后的日期。LocalDate日期不包含时间信息，它的plus()方法用来增加天、周、月，ChronoUnit类声明了这些时间单位。由于LocalDate也是不变类型，返回后一定要用变量赋值。
LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS)
System.out.println("Today is : " + today)
System.out.println("Date after 1 week : " + nextWeek)
Today is : 2014-01-14
Date after 1 week : 2014-01-21
可以看到新日期离当天日期是7天，也就是一周。你可以用同样的方法增加1个月、1年、1小时、1分钟甚至一个世纪，更多选项可以查看Java 8 API中的ChronoUnit类。
示例 9、计算一年前或一年后的日期
继续上面的例子，上个例子中我们通过LocalDate的plus()方法增加天数、周数或月数，这个例子我们利用minus()方法计算一年前的日期。
LocalDate previousYear = today.minus(1, ChronoUnit.YEARS)
System.out.println("Date before 1 year : " + previousYear)
LocalDate nextYear = today.plus(1, YEARS)
System.out.println("Date after 1 year : " + nextYear)
Date before 1 year : 2013-01-14
Date after 1 year : 2015-01-14
例子结果得到了两个日期，一个2013年、一个2015年、分别是2014年的前一年和后一年。
示例 10、使用Java 8的Clock时钟类
Java 8增加了一个Clock时钟类用于获取当时的时间戳，或当前时区下的日期时间信息。以前用到System.currentTimeMillis()和TimeZone.getDefault()的地方都可用Clock替换。
// Returns the current time based on your system clock and set to UTC.
Clock clock = Clock.systemUTC()
System.out.println("Clock : " + clock)
// Returns time based on system clock zone
Clock defaultClock = Clock.systemDefaultZone()
System.out.println("Clock : " + clock)
Clock : SystemClock[Z]
Clock : SystemClock[Z]
还可以针对clock时钟做比较，像下面这个例子：
public class MyClass {
// dependency inject
public void process(LocalDate eventDate) {
if (eventDate.isBefore(LocalDate.now(clock)) {
这种方式在不同时区下处理日期时会非常管用。
示例 11、如何用Java判断日期是早于还是晚于另一个日期
另一个工作中常见的操作就是如何判断给定的一个日期是大于某天还是小于某天？在Java 8中，LocalDate类有两类方法isBefore()和isAfter()用于比较日期。调用isBefore()方法时，如果给定日期小于当前日期则返回true。
LocalDate tomorrow = LocalDate.of(2014, 1, 15)
if(tommorow.isAfter(today)){
System.out.println("Tomorrow comes after today")
LocalDate yesterday = today.minus(1, DAYS)
if(yesterday.isBefore(today)){
System.out.println("Yesterday is day before today")
Tomorrow comes after today
Yesterday is day before today
在Java 8中比较日期非常方便，不需要使用额外的Calendar类来做这些基础工作了。
示例 12、在Java 8中处理时区
Java 8不仅分离了日期和时间，也把时区分离出来了。现在有一系列单独的类如ZoneId来处理特定时区，ZoneDateTime类来表示某时区下的时间。这在Java 8以前都是 GregorianCalendar类来做的。下面这个例子展示了如何把本时区的时间转换成另一个时区的时间。
// Date and time with timezone in 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 : 2014-01-14T16:33:33.373-05: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("Days in month year %s: %d%n", currentYearMonth, currentYearMonth.lengthOfMonth())
YearMonth creditCardExpiry = YearMonth.of(2018, Month.FEBRUARY)
System.out.printf("Your credit card expires on %s %n", creditCardExpiry)
Days in month year 2014-01: 31
Your credit card expires on 2018-02
根据上述数据，你可以提醒客户信用卡快要到期了，个人认为这个类非常有用。
示例 14、如何在Java 8中检查闰年
LocalDate类有一个很实用的方法isLeapYear()判断该实例是否是一个闰年，如果你还是想重新发明轮子，这有一个代码示例，纯Java逻辑编写的判断闰年的程序。
if(today.isLeapYear()){
System.out.println("This year is Leap year")
System.out.println("2014 is not a Leap year")
2014 is not a Leap year
你可以多写几个日期来验证是否是闰年，最好是写JUnit单元测试做判断。
示例 15、计算两个日期之间的天数和月数
有一个常见日期操作是计算两个日期之间的天数、周数或月数。在Java 8中可以用java.time.Period类来做计算。下面这个例子中，我们计算了当天和将来某一天之间的月数。
LocalDate java8Release = LocalDate.of(2014, Month.MARCH, 14)
Period periodToNextJavaRelease = Period.between(today, java8Release)
System.out.println("Months left between today and Java 8 release : "
+ periodToNextJavaRelease.getMonths() )
Months left between today and Java 8 release : 2
从上面可以看到现在是一月，Java 8的发布日期是3月，中间相隔两个月。
示例 16、包含时差信息的日期和时间
在Java 8中，ZoneOffset类用来表示时区，举例来说印度与GMT或UTC标准时区相差+05:30，可以通过ZoneOffset.of()静态方法来 获取对应的时区。一旦得到了时差就可以通过传入LocalDateTime和ZoneOffset来创建一个OffSetDateTime对象。
LocalDateTime datetime = LocalDateTime.of(2014, Month.JANUARY, 14, 19, 30);
ZoneOffset offset = ZoneOffset.of("+05:30");
OffsetDateTime date = OffsetDateTime.of(datetime, offset);
System.out.println("Date and Time with timezone offset in Java : " + date);
Date and Time with timezone offset in Java : 2014-01-14T19:30+05:30
现在的时间信息里已经包含了时区信息了。注意：OffSetDateTime是对计算机友好的，ZoneDateTime则对人更友好。
示例 17、在Java 8中获取当前的时间戳
如果你还记得Java 8以前是如何获得当前时间戳，那么现在你终于解脱了。Instant类有一个静态工厂方法now()会返回当前的时间戳，如下所示：
Instant timestamp = Instant.now();
System.out.println("What is value of this instant " + timestamp);
What is value of this instant 2014-01-14T08:33:33.379Z
时间戳信息里同时包含了日期和时间，这和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格式化工具将日格式化成。
String dayAfterTommorrow = "";
LocalDate formatted = LocalDate.parse(dayAfterTommorrow,
DateTimeFormatter.BASIC_ISO_DATE);
System.out.printf("Date generated from String %s is %s %n",
dayAfterTommorrow, formatted);
Date generated from String
is 2014-01-16
很明显的看出得到的日期和给出的日期是同一天，但是格式不同。
示例 19、如何在Java中使用自定义格式化工具解析日期
上 个例子使用了Java内置的格式化工具去解析日期字符串。尽管内置格式化工具很好用，有时还是需要定义特定的日期格式，下面这个例子展示了如何创建自定义 日期格式化工具。例子中的日期格式是“MMM dd yyyy”。可以调用DateTimeFormatter的 ofPattern()静态方法并传入任意格式返回其实例，格式中的字符和以前代表的一样，M 代表月，m代表分。如果格式不规范会抛出 DateTimeParseException异常，不过如果只是把M写成m这种逻辑错误是不会抛异常的。
String goodFriday = "Apr 18 2014";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMM dd yyyy");
LocalDate holiday = LocalDate.parse(goodFriday, formatter);
System.out.printf("Successfully parsed String %s, date is %s%n", goodFriday, holiday);
} catch (DateTimeParseException ex) {
System.out.printf("%s is not parsable!%n", goodFriday);
ex.printStackTrace();
Successfully parsed String Apr 18 2014, date is 2014-04-18
日期值与传入的字符串是匹配的，只是格式不同而已。
示例 20、在Java 8中如何把日期转换成字符串
上 两个例子都用到了DateTimeFormatter类，主要是从字符串解析日期。现在我们反过来，把LocalDateTime日期实例转换成特定格式的字符串。这是迄今为止Java日期转字符串最为简单的方式了。下面的例子将返回一个代表日期的格式化字符串。和前面类似，还是需要创建 DateTimeFormatter实例并传入格式，但这回调用的是format()方法，而非parse()方法。这个方法会把传入的日期转化成指定格式的字符串。
LocalDateTime arrivalDate
= LocalDateTime.now();
DateTimeFormatter format = DateTimeFormatter.ofPattern("MMM dd yyyy
hh:mm a");
String landing = arrivalDate.format(format);
System.out.printf("Arriving at :
%s %n", landing);
} catch (DateTimeException ex) {
System.out.printf("%s can't be formatted!%n", arrivalDate);
ex.printStackTrace();
Output : Arriving at :
Jan 14 2014
当前时间被指定的“MMM dd yyyy hh:mm a”格式格式化，格式包含3个代表月的字符串，时间后面带有AM和PM标记。
Java 8日期时间API的重点
通过这些例子，你肯定已经掌握了Java 8日期时间API的新知识点。现在我们来回顾一下这个优雅API的使用要点：
1）提供了javax.time.ZoneId 获取时区。
2）提供了LocalDate和LocalTime类。
3）Java 8 的所有日期和时间API都是不可变类并且线程安全，而现有的Date和Calendar API中的java.util.Date和SimpleDateFormat是非线程安全的。
4）主包是 java.time,包含了表示日期、时间、时间间隔的一些类。里面有两个子包java.time.format用于格式化， java.time.temporal用于更底层的操作。
5）时区代表了地球上某个区域内普遍使用的标准时间。每个时区都有一个代号，格式通常由区域/城市构成（Asia/Tokyo），在加上与格林威治或 UTC的时差。例如：东京的时差是+09:00。
6）OffsetDateTime类实际上组合了LocalDateTime类和ZoneOffset类。用来表示包含和格林威治或UTC时差的完整日期（年、月、日）和时间（时、分、秒、纳秒）信息。
7）DateTimeFormatter 类用来格式化和解析时间。与SimpleDateFormat不同，这个类不可变并且线程安全，需要时可以给静态常量赋值。 DateTimeFormatter类提供了大量的内置格式化工具，同时也允许你自定义。在转换方面也提供了parse()将字符串解析成日期，如果解析出错会抛出DateTimeParseException。DateTimeFormatter类同时还有format()用来格式化日期，如果出错会抛出DateTimeException异常。
8）再补充一点，日期格式“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可以作为处理日期时间操作的标准。
原文链接： javarevisited 翻译：
译文链接：
[ 转载请保留原文出处、译者和译文链接。]
&&相关文章推荐
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2856次
排名：千里之外