Java 8 日期/时间特性

最新推荐文章于 2023-06-26 23:07:13 发布

Tlimited

最新推荐文章于 2023-06-26 23:07:13 发布

阅读量610

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/u014204541/article/details/98352695

版权

java 专栏收录该内容

34 篇文章 1 订阅

订阅专栏

Java 8 日期/时间 API 是 JSR-310 的实现，它的实现目标是克服旧的日期时间实现中所有的缺陷，新的日期/时间
API 的一些设计原则是：

不变性：新的日期/时间 API 中，所有的类都是不可变的，这对多线程环境有好处。
关注点分离：新的 API 将人可读的日期时间和机器时间（unix timestamp）明确分离，它为日期（Date）、时间
（Time）、日期时间（DateTime）、时间戳（unix timestamp）以及时区定义了不同的类。
清晰：在所有的类中，方法都被明确定义用以完成相同的行为。举个例子，要拿到当前实例我们可以使用 now()方
法，在所有的类中都定义了 format()和 parse()方法，而不是像以前那样专门有一个独立的类。为了更好的处理问
题，所有的类都使用了工厂模式和策略模式，一旦你使用了其中某个类的方法，与其他类协同工作并不困难。
实用操作：所有新的日期/时间 API 类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从
日期/时间中提取单独部分，等等。
可扩展性：新的日期/时间 API 是工作在 ISO-8601 日历系统上的，但我们也可以将其应用在非 ISO 的日历上。

Java 8 日期/时间 API 包解释

java.time 包：这是新的 Java 日期/时间 API 的基础包，所有的主要基础类都是这个包的一部分，如：LocalDate,
LocalTime, LocalDateTime, Instant, Period, Duration 等等。所有这些类都是不可变的和线程安全的，在绝大多
数情况下，这些类能够有效地处理一些公共的需求。
java.time.chrono 包：这个包为非 ISO 的日历系统定义了一些泛化的 API，我们可以扩展 AbstractChronology
类来创建自己的日历系统。
java.time.format 包：这个包包含能够格式化和解析日期时间对象的类，在绝大多数情况下，我们不应该直接使
用它们，因为 java.time 包中相应的类已经提供了格式化和解析的方法。
java.time.temporal 包：这个包包含一些时态对象，我们可以用其找出关于日期/时间对象的某个特定日期或时间，
比如说，可以找到某月的第一天或最后一天。你可以非常容易地认出这些方法，因为它们都具有“withXXX”的格
式。
java.time.zone 包：这个包包含支持不同时区以及相关规则的类。

Java 8 日期/时间常用 API

1.java.time.LocalDate
LocalDate 是一个不可变的类，它表示默认格式(yyyy-MM-dd)的日期，我们可以使用 now()方法得到当前时间，
也可以提供输入年份、月份和日期的输入参数来创建一个 LocalDate 实例。该类为 now()方法提供了重载方法，我们
可以传入 ZoneId 来获得指定时区的日期。该类提供与 java.sql.Date 相同的功能，对于如何使用该类，我们来看一个
简单的例子。

import java.time.LocalDate;
import java.time.Month;
import java.time.ZoneId;

public class LocalDateExample {
	public static void main(String[] args) {
		// Current Date
		LocalDate today = LocalDate.now();
		System.out.println("Current Date=" + today);
		// Creating LocalDate by providing input arguments
		LocalDate firstDay_2014 = LocalDate.of(2014, Month.JANUARY, 1);
		System.out.println("Specific Date=" + firstDay_2014);
		// Try creating date by providing invalid inputs
		// LocalDate feb29_2014 = LocalDate.of(2014, Month.FEBRUARY, 29);
		// Exception in thread "main" java.time.DateTimeException:
		// Invalid date 'February 29' as '2014' is not a leap year
		// Current date in "Asia/Kolkata", you can get it from ZoneId javadoc
		LocalDate todayKolkata = LocalDate.now(ZoneId.of("Asia/Kolkata"));
		System.out.println("Current Date in IST=" + todayKolkata);
		// java.time.zone.ZoneRulesException: Unknown time-zone ID: IST
		// LocalDate todayIST = LocalDate.now(ZoneId.of("IST"));
		// Getting date from the base date i.e 01/01/1970
		LocalDate dateFromBase = LocalDate.ofEpochDay(365);
		System.out.println("365th day from base date= " + dateFromBase);
		LocalDate hundredDay2014 = LocalDate.ofYearDay(2014, 100);
		System.out.println("100th day of 2014=" + hundredDay2014);
	}
}

运行结果：

Current Date=2019-08-03
Specific Date=2014-01-01
Current Date in IST=2019-08-03
365th day from base date= 1971-01-01
100th day of 2014=2014-04-10

2.java.time.LocalTime
LocalTime 是一个不可变的类，它的实例代表一个符合人类可读格式的时间，默认格式是 hh:mm:ss.zzz。像LocalDate 一样，该类也提供了时区支持，同时也可以传入小时、分钟和秒等输入参数创建实例，我们来看一个简单的程序，演示该类的使用方法。

import java.time.LocalTime;
import java.time.ZoneId;
/**
* LocalTime Examples
*/
public class LocalTimeExample {
public static void main(String[] args) {
//Current Time
LocalTime time = LocalTime.now();
System.out.println("Current Time="+time);
//Creating LocalTime by providing input arguments
LocalTime specificTime = LocalTime.of(12,20,25,40);
System.out.println("Specific Time of Day="+specificTime);
//Try creating time by providing invalid inputs
//LocalTime invalidTime = LocalTime.of(25,20);
//Exception in thread "main" java.time.DateTimeException:
//Invalid value for HourOfDay (valid values 0 - 23): 25
//Current date in "Asia/Kolkata", you can get it from ZoneId javadoc
LocalTime timeKolkata = LocalTime.now(ZoneId.of("Asia/Kolkata"));
System.out.println("Current Time in IST="+timeKolkata);
//java.time.zone.ZoneRulesException: Unknown time-zone ID: IST
//LocalTime todayIST = LocalTime.now(ZoneId.of("IST"));
//Getting date from the base date i.e 01/01/1970
LocalTime specificSecondTime = LocalTime.ofSecondOfDay(10000);
System.out.println("10000th second time= "+specificSecondTime);
}
}

输出：

Current Time=16:05:50.041
Specific Time of Day=12:20:25.000000040
Current Time in IST=13:35:50.043
10000th second time= 02:46:40

3. java.time.LocalDateTime
LocalDateTime 是一个不可变的日期-时间对象，它表示一组日期-时间，默认格式是 yyyy-MM-dd-HH-mm-ss.zzz。它提供了一个工厂方法，接收 LocalDate 和 LocalTime 输入参数，创建 LocalDateTime 实例。我们来看一个简单的例子。

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.ZoneId;
import java.time.ZoneOffset;

public class LocalDateTimeExample {
	public static void main(String[] args) {
		// Current Date
		LocalDateTime today = LocalDateTime.now();
		System.out.println("Current DateTime=" + today);
		// Current Date using LocalDate and LocalTime
		today = LocalDateTime.of(LocalDate.now(), LocalTime.now());
		System.out.println("Current DateTime=" + today);
		// Creating LocalDateTime by providing input arguments
		LocalDateTime specificDate = LocalDateTime.of(2014, Month.JANUARY, 1, 10, 10, 30);
		System.out.println("Specific Date=" + specificDate);
		// Try creating date by providing invalid inputs
		// LocalDateTime feb29_2014 = LocalDateTime.of(2014, Month.FEBRUARY, 28,
		// 25,1,1);
		// Exception in thread "main" java.time.DateTimeException:
		// Invalid value for HourOfDay (valid values 0 - 23): 25
		// Current date in "Asia/Kolkata", you can get it from ZoneId javadoc
		LocalDateTime todayKolkata = LocalDateTime.now(ZoneId.of("Asia/Kolkata"));
		System.out.println("Current Date in IST=" + todayKolkata);
		// java.time.zone.ZoneRulesException: Unknown time-zone ID: IST
		// LocalDateTime todayIST = LocalDateTime.now(ZoneId.of("IST"));
		// Getting date from the base date i.e 01/01/1970
		LocalDateTime dateFromBase = LocalDateTime.ofEpochSecond(10000, 0, ZoneOffset.UTC);
		System.out.println("10000th second time from 01/01/1970= " + dateFromBase);
	}
}

输出：

Current DateTime=2019-08-04T16:08:36.395
Current DateTime=2019-08-04T16:08:36.396
Specific Date=2014-01-01T10:10:30
Current Date in IST=2019-08-04T13:38:36.398
10000th second time from 01/01/1970= 1970-01-01T02:46:40

  在所有这三个例子中，我们已经看到如果我们提供了无效的参数去创建日期/时间，那么系统会抛出java.time.DateTimeException，这是一种运行时异常，我们并不需要显式地捕获它。
    同时我们也看到，能够通过传入 ZoneId 得到日期/时间数据，你可以从它的 Javadoc 中得到支持的 Zoneid 的列表，当运行以上类时，可以得到以上输出。

4. java.time.Instant
Instant 类是用在机器可读的时间格式上的，它以 Unix 时间戳的形式存储日期时间，我们来看一个简单的程序

import java.time.Duration;
import java.time.Instant;

public class InstantExample {
	public static void main(String[] args) {
		// Current timestamp
		Instant timestamp = Instant.now();
		System.out.println("Current Timestamp = " + timestamp);
		// Instant from timestamp
		Instant specificTime = Instant.ofEpochMilli(timestamp.toEpochMilli());
		System.out.println("Specific Time = " + specificTime);
		// Duration example
		Duration thirtyDay = Duration.ofDays(30);
		System.out.println(thirtyDay);
	}
}

输出：

Current Timestamp = 2019-08-04T08:11:02.345Z
Specific Time = 2019-08-04T08:11:02.345Z
PT720H

5. 日期 API 工具
我们早些时候提到过，大多数日期/时间 API 类都实现了一系列工具方法，如：加/减天数、周数、月份数，等等。还有其他的工具方法能够使用 TemporalAdjuster 调整日期，并计算两个日期间的周期。


import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Period;
import java.time.temporal.TemporalAdjusters;

public class DateAPIUtilities {
	public static void main(String[] args) {
		LocalDate today = LocalDate.now();
		// 获取年份，检查是不是闰年
		System.out.println("Year " + today.getYear() + " is Leap Year? " + today.isLeapYear());
		// 比较两个LocalDate之前和之后
		System.out.println("Today is before 01/01/2015? " + today.isBefore(LocalDate.of(2015, 1, 1)));
		// Create LocalDateTime from LocalDate
		System.out.println("Current Time=" + today.atTime(LocalTime.now()));
		// 时间+和-操作
		System.out.println("10 days after today will be " + today.plusDays(10));
		System.out.println("3 weeks after today will be " + today.plusWeeks(3));
		System.out.println("20 months after today will be " + today.plusMonths(20));
		System.out.println("10 days before today will be " + today.minusDays(10));
		System.out.println("3 weeks before today will be " + today.minusWeeks(3));
		System.out.println("20 months before today will be " + today.minusMonths(20));
		// Temporal adjusters for adjusting the dates（时间调节器调整日期）
		System.out.println("First date of this month= " + today.with(TemporalAdjusters.firstDayOfMonth()));
		LocalDate lastDayOfYear = today.with(TemporalAdjusters.lastDayOfYear());
		System.out.println("Last date of this year= " + lastDayOfYear);
		Period period = today.until(lastDayOfYear);
		System.out.println("Period Format= " + period);
		System.out.println("Months remaining in the year= " + period.getMonths());
	}
}

输出：

Year 2019 is Leap Year? false
Today is before 01/01/2015? false
Current Time=2019-08-04T16:13:07.030
10 days after today will be 2019-08-14
3 weeks after today will be 2019-08-25
20 months after today will be 2021-04-04
10 days before today will be 2019-07-25
3 weeks before today will be 2019-07-14
20 months before today will be 2017-12-04
First date of this month= 2019-08-01
Last date of this year= 2019-12-31
Period Format= P4M27D
Months remaining in the year= 4

6. 解析和格式化
将一个日期格式转换为不同的格式，之后再解析一个字符串，得到日期时间对象，这些都是很常见的。我们来看一下简单的例子。


import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;

public class DateParseFormatExample {
	public static void main(String[] args) {
		System.out.println(new Date());
		// Format examples
		LocalDate date = LocalDate.now();
		// default format
		System.out.println("Default format of LocalDate=" + date);
		// specific format
		System.out.println(date.format(DateTimeFormatter.ofPattern("d::MMM::uuuu")));
		System.out.println(date.format(DateTimeFormatter.BASIC_ISO_DATE));
		LocalDateTime dateTime = LocalDateTime.now();
		// default format
		System.out.println("Default format of LocalDateTime=" + dateTime);
		// specific format
		System.out.println(dateTime.format(DateTimeFormatter.ofPattern("d::MMM::uuuu HH::mm::ss")));
		System.out.println(dateTime.format(DateTimeFormatter.BASIC_ISO_DATE));
		Instant timestamp = Instant.now();
		// default format
		System.out.println("Default format of Instant=" + timestamp);
		// Parse examples
	/*	LocalDateTime dt = LocalDateTime.parse("Sun Aug 04 16:28:19 CST 2019",
				DateTimeFormatter.ofPattern("d::MMM::uuuu HH::mm::ss"));
		System.out.println("Default format after parsing = " + dt);*/
	}
}

输出：

Sun Aug 04 16:48:14 CST 2019
Default format of LocalDate=2019-08-04
4::八月::2019
20190804
Default format of LocalDateTime=2019-08-04T16:48:14.468
4::八月::2019 16::48::14
20190804
Default format of Instant=2019-08-04T08:48:14.469Z

7. 旧的日期时间支持
旧的日期/时间类已经在几乎所有的应用程序中使用，因此做到向下兼容是必须的。这也是为什么会有若干工具方法帮助我们将旧的类转换为新的类，反之亦然。我们来看一下简单的例子。

System.out.println(defaultZone);
//ZonedDateTime from specific Calendar
ZonedDateTime gregorianCalendarDateTime = new GregorianCalendar().toZonedDateTime();
System.out.println(gregorianCalendarDateTime);
//Date API to Legacy classes
Date dt = Date.from(Instant.now());
System.out.println(dt);
TimeZone tz = TimeZone.getTimeZone(defaultZone);
System.out.println(tz);
GregorianCalendar gc = GregorianCalendar.from(gregorianCalendarDateTime);
System.out.println(gc);
}
}

输出：

Date = 2019-08-04T01:49:53.307
2019-08-04T08:49:53.471Z
Asia/Shanghai
2019-08-04T16:49:53.504+08:00[Asia/Shanghai]
Sun Aug 04 16:49:53 CST 2019
sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null]
java.util.GregorianCalendar[time=1564908593504,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=2,minimalDaysInFirstWeek=4,ERA=1,YEAR=2019,MONTH=7,WEEK_OF_YEAR=31,WEEK_OF_MONTH=1,DAY_OF_MONTH=4,DAY_OF_YEAR=216,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=1,AM_PM=1,HOUR=4,HOUR_OF_DAY=16,MINUTE=49,SECOND=53,MILLISECOND=504,ZONE_OFFSET=28800000,DST_OFFSET=0]

补充：我们可以看到，旧的 TimeZone 和 GregorianCalendar 类的 toString()方法太啰嗦了，一点都不友好。

7.7 Java8 之前的日期和时间使用的槽点

Tiago Fernandez 做过一次投票，选举最烂的 JAVA API，排第一的 EJB2.X，第二的就是日期 API（Date 和
Calender）
1. 槽点一
最开始的时候，Date 既要承载日期信息，又要做日期之间的转换，还要做不同日期格式的显示，职责较繁杂（不懂单
一职责，你妈妈知道吗？纯属恶搞~哈哈）
后来从 JDK 1.1 开始，这三项职责分开了：
1）使用 Calendar 类实现日期和时间字段之间转换；
2）使用 DateFormat 类来格式化和分析日期字符串；
3）而 Date 只用来承载日期和时间信息。
原有 Date 中的相应方法已废弃。不过，无论是 Date，还是 Calendar，都用着太不方便了，这是 API 没有设
计好的地方。
2. 槽点二
坑爹的 year 和 month。
我们看下面的代码：

 Date date = new Date(2012,1,1);
 System.out.println(date);

输出 Thu Feb 01 00:00:00 CST 3912
观察输出结果，year 是 2012+1900，而 month，月份参数我不是给了 1 吗？怎么输出二月（Feb）了？
应该曾有人告诉你，如果你要设置日期，应该使用 java.util.Calendar，像这样…

 Calendar calendar = Calendar.getInstance();
 calendar.set(2013, 8, 2);

这样写又不对了，calendar 的 month 也是从 0 开始的，表达 8 月份应该用 7 这个数字，要么就干脆用枚举

calendar.set(2013, Calendar.AUGUST, 2);

注意上面的代码，Calendar 年份的传值不需要减去 1900（当然月份的定义和 Date 还是一样），这种不一致真
是让人抓狂！有些人可能知道，Calendar 相关的 API 是 IBM 捐出去的，所以才导致不一致。
3. 槽点三
java.util.Date 与 java.util.Calendar 中的所有属性都是可变的
下面的代码，计算两个日期之间的天数…

public class DateAPILegacySupport {
	public static void main(String[] args) {
		Calendar birth = Calendar.getInstance();
		birth.set(1975, Calendar.MAY, 26);
		Calendar now = Calendar.getInstance();
		System.out.println(daysBetween(birth, now));
		System.out.println(daysBetween(birth, now)); // 显示 0？
	}

	public static long daysBetween(Calendar begin, Calendar end) {
		long daysBetween = 0;
		while (begin.before(end)) {
			begin.add(Calendar.DAY_OF_MONTH, 1);
			daysBetween++;
		}
		return daysBetween;
	}
}

daysBetween 有点问题，如果连续计算两个 Date 实例的话，第二次会取得 0，因为 Calendar 状态是可变的，考虑到重复计算的场合，最好复制一个新的 Calendar

 public static long daysBetween(Calendar begin, Calendar end) {
		 Calendar calendar = (Calendar) begin.clone(); // 复制
		 long daysBetween = 0;
		while(calendar.before(end)) {
		 calendar.add(Calendar.DAY_OF_MONTH, 1);
		 daysBetween++;
		 }
		 return daysBetween;
		 }

以上种种，导致目前有些第三方的 java 日期库诞生，比如广泛使用的 JODA-TIME，还有 Date4j 等，虽然第三方库已经足 3 / 8 够强大，好用，但还是有兼容问题的，比如标准的 JSF 日期转换器与 joda-time API 就不兼容，你需要编写自己的转换器，所以标准的 API 还是必须的，于是就有了 JSR310。

7.8 Java8 日期实现 JSR310 规范

1. JSR310 介绍
JSR 310 实际上有两个日期概念。第一个是 Instant，它大致对应于 java.util.Date 类，因为它代表了一个确定的时间点，即相对于标准 Java 纪元（1970 年 1 月 1 日）的偏移量；但与java.util.Date 类不同的是其精确到了
纳秒级别。
第二个对应于人类自身的观念，比如 LocalDate 和 LocalTime。他们代表了一般的时区概念，要么是日期（不包含时间），要么是时间（不包含日期），类似于 java.sql 的表示方式。此外，还有一个 MonthDay，它可以存储某人的生日（不包含年份）。每个类都在内部存储正确的数据而不是像 java.util.Date 那样利用午夜 12 点来区分日期，利用 1970-01-01 来表示时间。
目前 Java8 已经实现了 JSR310 的全部内容。新增了 java.time 包定义的类表示了日期-时间概念的规则，包括 instants,durations, dates, times, time-zones and periods。这些都是基于 ISO 日历系统，它又是遵循Gregorian 规则的。最重要的一点是值不可变，且线程安全，通过下面一张图，我们快速看下 java.time 包下的一些主要的类的值的格式，方便理解。
在这里插入图片描述
2. Java8 方法概览
java.time 包下的方法概览

与旧的 API 相比

3. 简单实用 java.time 的 API 实用


import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.chrono.ChronoLocalDateTime;
import java.time.chrono.Chronology;
import java.time.chrono.HijrahChronology;
import java.time.format.DateTimeFormatter;
import java.time.temporal.IsoFields;
import java.util.Date;

public class TimeIntroduction {
	public static void testClock() throws InterruptedException {
		// 时钟提供给我们用于访问某个特定 时区的 瞬时时间、日期 和 时间的。
		Clock c1 = Clock.systemUTC(); // 系统默认 UTC 时钟（当前瞬时时间
										// System.currentTimeMillis()）
		System.out.println(c1.millis()); // 每次调用将返回当前瞬时时间（UTC）
		Clock c2 = Clock.systemDefaultZone(); // 系统默认时区时钟（当前瞬时时间）
		Clock c31 = Clock.system(ZoneId.of("Europe/Paris")); // 巴黎时区
		System.out.println(c31.millis()); // 每次调用将返回当前瞬时时间（UTC）
		Clock c32 = Clock.system(ZoneId.of("Asia/Shanghai"));// 上海时区
		System.out.println(c32.millis());// 每次调用将返回当前瞬时时间（UTC）
		Clock c4 = Clock.fixed(Instant.now(), ZoneId.of("Asia/Shanghai"));// 固定上海时区时钟
		System.out.println(c4.millis());
		Thread.sleep(1000);
		System.out.println(c4.millis()); // 不变 即时钟时钟在那一个点不动
		Clock c5 = Clock.offset(c1, Duration.ofSeconds(2)); // 相对于系统默认时钟两秒的时钟
		System.out.println(c1.millis());
		System.out.println(c5.millis());
	}

	public static void testInstant() {
		// 瞬时时间 相当于以前的 System.currentTimeMillis()
		Instant instant1 = Instant.now();
		System.out.println(instant1.getEpochSecond());// 精确到秒 得到相对于 1970-01-01
														// 00:00:00 UTC 的一个时间
		System.out.println(instant1.toEpochMilli()); // 精确到毫秒
		Clock clock1 = Clock.systemUTC(); // 获取系统 UTC 默认时钟
		Instant instant2 = Instant.now(clock1);// 得到时钟的瞬时时间
		System.out.println(instant2.toEpochMilli());
		Clock clock2 = Clock.fixed(instant1, ZoneId.systemDefault()); // 固定瞬时时间时钟
		Instant instant3 = Instant.now(clock2);// 得到时钟的瞬时时间
		System.out.println(instant3.toEpochMilli());// equals instant1
	}

	public static void testLocalDateTime() {
		// 使用默认时区时钟瞬时时间创建 Clock.systemDefaultZone() -->即相对于
		// ZoneId.systemDefault() 默认时区
		LocalDateTime now = LocalDateTime.now();
		System.out.println(now);
		// 自定义时区
		LocalDateTime now2 = LocalDateTime.now(ZoneId.of("Europe/Paris"));
		System.out.println(now2);// 会以相应的时区显示日期
		// 自定义时钟
		Clock clock = Clock.system(ZoneId.of("Asia/Dhaka"));
		LocalDateTime now3 = LocalDateTime.now(clock);
		System.out.println(now3);// 会以相应的时区显示日期
		// 不需要写什么相对时间 如 java.util.Date 年是相对于 1900 月是从 0 开始
		// 2013-12-31 23:59
		LocalDateTime d1 = LocalDateTime.of(2013, 12, 31, 23, 59);
		// 年月日 时分秒 纳秒
		LocalDateTime d2 = LocalDateTime.of(2013, 12, 31, 23, 59, 59, 11);
		// 使用瞬时时间 + 时区
		Instant instant = Instant.now();
		LocalDateTime d3 = LocalDateTime.ofInstant(Instant.now(), ZoneId.systemDefault());
		System.out.println(d3);
		// 解析 String--->LocalDateTime
		LocalDateTime d4 = LocalDateTime.parse("2013-12-31T23:59");
		System.out.println(d4);
		LocalDateTime d5 = LocalDateTime.parse("2013-12-31T23:59:59.999");// 999
																			// 毫秒
																			// 等价于
																			// 999000000
																			// 纳秒

		System.out.println(d5);
		// 使用 DateTimeFormatter API 解析 和 格式化
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
		LocalDateTime d6 = LocalDateTime.parse("2013/12/31 23:59:59", formatter);
		System.out.println(formatter.format(d6));
		// 时间获取
		System.out.println(d6.getYear());
		System.out.println(d6.getMonth());
		System.out.println(d6.getDayOfYear());
		System.out.println(d6.getDayOfMonth());
		System.out.println(d6.getDayOfWeek());
		System.out.println(d6.getHour());
		System.out.println(d6.getMinute());
		System.out.println(d6.getSecond());
		System.out.println(d6.getNano());
		// 时间增减
		LocalDateTime d7 = d6.minusDays(1);
		LocalDateTime d8 = d7.plus(1, IsoFields.QUARTER_YEARS);
		// LocalDate 即年月日 无时分秒
		// LocalTime 即时分秒 无年月日
		// API 和 LocalDateTime 类似就不演示了
	}

	public static void testZonedDateTime() {
		// 即带有时区的 date-time 存储纳秒、时区和时差（避免与本地 date-time 歧义）。
		// API 和 LocalDateTime 类似，只是多了时差(如
		// 2013-12-20T10:35:50.711+08:00[Asia/Shanghai])
		ZonedDateTime now = ZonedDateTime.now();
		System.out.println(now);
		ZonedDateTime now2 = ZonedDateTime.now(ZoneId.of("Europe/Paris"));
		System.out.println(now2);
		// 其他的用法也是类似的 就不介绍了
		ZonedDateTime z1 = ZonedDateTime.parse("2013-12-31T23:59:59Z[Europe/Paris]");
		System.out.println(z1);
	}

	public static void testDuration() {
		// 表示两个瞬时时间的时间段
		Duration d1 = Duration.between(Instant.ofEpochMilli(System.currentTimeMillis() - 12323123), Instant.now());
		// 得到相应的时差
		System.out.println(d1.toDays());
		System.out.println(d1.toHours());
		System.out.println(d1.toMinutes());

		System.out.println(d1.toMillis());
		System.out.println(d1.toNanos());
		// 1 天时差 类似的还有如 ofHours()
		Duration d2 = Duration.ofDays(1);
		System.out.println(d2.toDays());
	}

	public static void testChronology() {
		// 提供对 java.util.Calendar 的替换，提供对年历系统的支持
		Chronology c = HijrahChronology.INSTANCE;
		ChronoLocalDateTime d = c.localDateTime(LocalDateTime.now());
		System.out.println(d);
	}

	/**
	 * 新旧日期转换
	 */
	public static void testNewOldDateConversion() {
		Instant instant = new Date().toInstant();
		Date date = Date.from(instant);
		System.out.println(instant);
		System.out.println(date);
	}

	public static void main(String[] args) throws InterruptedException {
		testClock();
		testInstant();
		testLocalDateTime();
		testZonedDateTime();
		testDuration();
		testChronology();
		testNewOldDateConversion();
	}
}

7.9 JSR310 规范 Joda-Time 的区别

其实 JSR310 的规范领导者 Stephen Colebourne，同时也是 Joda-Time 的创建者，JSR310 是在 Joda-Time 的基础上建立的，参考了绝大部分的 API，但并不是说 JSR310=JODA-Time，下面几个比较明显的区别是：

最明显的变化就是包名（从 org.joda.time 以及 java.time）
JSR310 不接受 NULL 值，Joda-Time 视 NULL 值为 0
JSR310 的计算机相关的时间（Instant）和与人类相关的时间（DateTime）之间的差别变得更明显
JSR310 所有抛出的异常都是 DateTimeException 的子类。虽然 DateTimeException 是一个RuntimeException

7.10 总结 (2017-11-23-wl)

Java.time	java.util.Calendar 以及 Date
流畅的 API	不流畅的 API
实例不可变	实例可变
线程安全	非线程安全

Tlimited

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 8 日期/时间特性

Java 8 日期/时间 API 是 JSR-310 的实现，它的实现目标是克服旧的日期时间实现中所有的缺陷，新的日期/时间API 的一些设计原则是：不变性：新的日期/时间 API 中，所有的类都是不可变的，这对多线程环境有好处。关注点分离：新的 API 将人可读的日期时间和机器时间（unix timestamp）明确分离，它为日期（Date）、时间（Time）、日期时间（DateTim...
复制链接

扫一扫