java8时间日期API(LocalDate、 LocalTime、 Instant、 Duration 以及 Period)

https://github.com/chenfangya/Demo.git

1. 创建一个LocalDate对象并读取其值

LocalDate date = LocalDate.of(2018, 10, 31);//2018-10-31
int year = date.getYear();//2018
Month month = date.getMonth();//OCTOBER
int day = date.getDayOfMonth();//31
DayOfWeek dow = date.getDayOfWeek();//WEDNESDAY
int len = date.lengthOfMonth();//31
boolean leap = date.isLeapYear();//false

2. 获取当前的日期

LocalDate today = LocalDate.now();

3. 使用TemporalField读取LocalDate的值

int year = date.get(ChronoField.YEAR);
int month = date.get(ChronoField.MONTH_OF_YEAR);
int day = date.get(ChronoField.DAY_OF_MONTH);

4. 创建LocalTime并读取其值

LocalTime time = LocalTime.of(13, 45, 20);//13:45:20
int hour = time.getHour();//13
int minute = time.getMinute();//45
int second = time.getSecond();//20

5. LocalDate和LocalTime都可以通过解析代表它们的字符串创建

LocalDate date = LocalDate.parse("2018-10-31");
LocalTime time = LocalTime.parse("13:45:20");

6. 合并日期和时间 LocalDateTime

	@Test
	public void test2() {
		LocalDate date = LocalDate.of(2018, 10, 31);
		LocalTime time = LocalTime.of(13, 45, 20);
		// 2018-10-31T13:45:20
		LocalDateTime dt1 = LocalDateTime.of(2018, Month.OCTOBER, 31, 13, 45, 20);
		LocalDateTime dt2 = LocalDateTime.of(date, time);
		LocalDateTime dt3 = date.atTime(13, 45, 20);
		LocalDateTime dt4 = date.atTime(time);
		LocalDateTime dt5 = time.atDate(date);
	}

7. 从LocalDateTime中提取LocalDate或者LocalTime组件

LocalDate date1 = dt1.toLocalDate();//2018-10-31
LocalTime time1 = dt1.toLocalTime();//13:45:20

8.机器的日期和时间格式 Instant

java.time.Instant类对时间建模的方式，以Unix元年时间（传统的设定为UTC时区1970年1月1日午夜时分）开始所经历的秒数进行计算.

Instant.ofEpochSecond(3);
Instant.ofEpochSecond(3, 0);
Instant.ofEpochSecond(2, 1_000_000_000);//2 秒 之 后 再 加 上100万纳秒（ 1秒）
Instant.ofEpochSecond(4, -1_000_000_000);//4秒之前的100万纳秒（ 1秒）

int day = Instant.now().get(ChronoField.DAY_OF_MONTH);
//java.time.temporal.UnsupportedTemporalTypeException: Unsupported field:DayOfMonth

它包含的是由秒及纳秒所构成的数字。所以，它无法处理那些我们非常容易理解的时间单位。但是可以通过Duration和Period类使用Instant.

定义 Duration 或 Period

	@Test
	public void test4() {
		Period tenDays = Period.between(LocalDate.of(2018, 10, 21),
				LocalDate.of(2018, 10, 31));
		System.out.println(tenDays.getDays());//10
	}

创建Duration和Period对象

Duration threeMinutes = Duration.ofMinutes(3);
Duration threeMinutes = Duration.of(3, ChronoUnit.MINUTES);
Period tenDays = Period.ofDays(10);
Period threeWeeks = Period.ofWeeks(3);
Period twoYearsSixMonthsOneDay = Period.of(2, 6, 1);

日期-时间类中表示时间间隔的通用方法

方 法 名	是否是静态方法	方法描述
between	是	创建两个时间点之间的 interval
from	是	由一个临时时间点创建 interval
of	是	由它的组成部分创建 interval 的实例
parse	是	由字符串创建 interval 的实例
addTo	否	创建该 interval 的副本，并将其叠加到某个指定的 temporal 对象
get	否	读取该 interval 的状态
isNegative	否	检查该 interval 是否为负值，不包含零
isZero	否	检查该 interval 的时长是否为零
minus	否	通过减去一定的时间创建该 interval 的副本
multipliedBy	否	将 interval 的值乘以某个标量创建该 interval 的副本
negated	否	以忽略某个时长的方式创建该 interval 的副本
plus	否	以增加某个指定的时长的方式创建该 interval 的副本
subtractFrom	否	从指定的 temporal 对象中减去该 interval

操纵、解析和格式化日期

	@Test
	public void test5() {
		LocalDate date1 = LocalDate.of(2018, 10, 31);//2018-10-31
		LocalDate date2 = date1.withYear(2011);//2011-10-31
		LocalDate date3 = date2.withDayOfMonth(25);//2011-10-25
		LocalDate date4 = date3.with(ChronoField.MONTH_OF_YEAR, 9);//2011-09-25
	}

以相对方式修改LocalDate对象的属性

	@Test
	public void test6() {
		LocalDate date1 = LocalDate.of(2018, 10, 31);//2018-10-31
		LocalDate date2 = date1.plusWeeks(1);//2018-11-07
		LocalDate date3 = date2.minusYears(3);//2015-11-07
		LocalDate date4 = date3.plus(6, ChronoUnit.MONTHS);//2016-05-07
	}
	

表示时间点的日期时间类的通用方法

方 法 名	是否是静态方法	方法描述
from	是	依据传入的 Temporal 对象创建对象实例
now	是	依据系统时钟创建 Temporal 对象
of	是	由 Temporal 对象的某个部分创建该对象的实例
parse	是	由字符串创建 Temporal 对象的实例
atOffset	否	将 Temporal 对象和某个时区偏移相结合
atZone	否	将 Temporal 对象和某个时区相结合
format	否	使用某个指定的格式器将Temporal 对象转换为字符串（Instant 类不提供该方法）
get	否	读取 Temporal 对象的某一部分的值
minus	否	创建 Temporal 对象的一个副本，通过将当前 Temporal 对象的值减去一定的时长创建该副本
plus	否	创建 Temporal 对象的一个副本，通过将当前 Temporal 对象的值加上一定的时长创建该副本
with	否	以该 Temporal 对象为模板，对某些状态进行修改创建该对象的副本

使用 TemporalAdjuster

	@Test
	public void test7() {
		LocalDate date1 = LocalDate.of(2018, 10, 31);//2018-10-31
		LocalDate date2 = date1.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));//2018-11-04
		LocalDate date3 = date2.with(TemporalAdjusters.lastDayOfMonth());//2018-11-30
	}

TemporalAdjuster类中的工厂方法

方 法 名	方法描述
dayOfWeekInMonth	创建一个新的日期，它的值为同一个月中每一周的第几天
firstDayOfMonth	创建一个新的日期，它的值为当月的第一天
firstDayOfNextMonth	创建一个新的日期，它的值为下月的第一天
firstDayOfNextYear	创建一个新的日期，它的值为明年的第一天
firstDayOfYear	创建一个新的日期，它的值为当年的第一天
firstInMonth	创建一个新的日期，它的值为同一个月中，第一个符合星期几要求的值
lastDayOfMonth	创建一个新的日期，它的值为当月的最后一天
lastDayOfNextMonth	创建一个新的日期，它的值为下月的最后一天
lastDayOfNextYear	创建一个新的日期，它的值为明年的最后一天
lastDayOfYear	创建一个新的日期，它的值为今年的最后一天
lastInMonth	创建一个新的日期，它的值为同一个月中，最后一个符合星期几要求的值
next/previous	创建一个新的日期，并将其值设定为日期调整后或者调整前，第一个符合指定星期几要求的日期
nextOrSame/previousOrSame	创建一个新的日期，并将其值设定为日期调整后或者调整前，第一个符合指定星期几要求的日期，如果该日期已经符合要求，直接返回该对象

TemporalAdjuster接口

	@Test
	public void test8() {
		LocalDate date = LocalDate.of(2018, 10, 31);
		date = date.with(temporal -> {
			DayOfWeek dow = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK));
			int dayToAdd = 1;
			if (dow == DayOfWeek.FRIDAY)
				dayToAdd = 3;
			else if (dow == DayOfWeek.SATURDAY)
				dayToAdd = 2;
			return temporal.plus(dayToAdd, ChronoUnit.DAYS);
		});
		System.out.println(date);//2018-11-01
	}

打印输出及解析日期时间对象

	@Test
	public void test8() {
		LocalDate date = LocalDate.of(2018, 10, 31);
		String s1 = date.format(DateTimeFormatter.BASIC_ISO_DATE);
		String s2 = date.format(DateTimeFormatter.ISO_LOCAL_DATE);
		System.out.println(s1);//	20181031
		System.out.println(s2);//2018-10-31

		LocalDate date1 = LocalDate.parse("20181031", DateTimeFormatter.BASIC_ISO_DATE);
		LocalDate date2 = LocalDate.parse("2018-10-31", DateTimeFormatter.ISO_LOCAL_DATE);
		System.out.println(date1 );//	2018-10-31
		System.out.println(date1 );//2018-10-31
	}

	@Test
	public void test9() {
		LocalDate date = LocalDate.of(2018, 10, 31);//2018-10-31
		DateTimeFormatter italianFormatter = DateTimeFormatter.ofPattern("d. MMMM yyyy", Locale.CHINA);
		LocalDate date1 = LocalDate.of(2018, 10, 31);//2018-10-31
		String formattedDate = date.format(italianFormatter); // 31 - 十月 - 2018
		LocalDate date2 = LocalDate.parse(formattedDate, italianFormatter);//2018-10-31
	}

	@Test
	public void test10() {
		LocalDate date = LocalDate.of(2018, 10, 31);//2018-10-31
		
		DateTimeFormatter italianFormatter = new DateTimeFormatterBuilder()
				.appendText(ChronoField.DAY_OF_MONTH)
				.appendLiteral("-")
				.appendText(ChronoField.MONTH_OF_YEAR)
				.appendLiteral("-")
				.appendText(ChronoField.YEAR)
				.parseCaseInsensitive()
				.toFormatter(Locale.CHINA);
		String format = date.format(italianFormatter);//31-十月-2018
		LocalDate parse = LocalDate.parse(format, italianFormatter);//2018-10-31
	}

处理不同的时区和历法

	/**
	Europe/Rome
	Asia/Shanghai
	2018-10-31
	2018-10-31T00:00+01:00[Europe/Rome]
	2018-10-31T13:45
	2018-10-31T13:45+01:00[Europe/Rome]
	2018-11-05T09:16:33.478Z
	2018-11-05T10:16:33.478+01:00[Europe/Rome]

	*/
	@Test
	public void test11() {
		ZoneId romeZone = ZoneId.of("Europe/Rome");
		
		ZoneId zoneId = TimeZone.getDefault().toZoneId();
		
		
		LocalDate date = LocalDate.of(2018, Month.OCTOBER, 31);
		ZonedDateTime zdt1 = date.atStartOfDay(romeZone);
		LocalDateTime dateTime = LocalDateTime.of(2018, Month.OCTOBER, 31, 13, 45);
		ZonedDateTime zdt2 = dateTime.atZone(romeZone);
		Instant instant = Instant.now();
		ZonedDateTime zdt3 = instant.atZone(romeZone);
		
		System.out.println(romeZone);
		System.out.println(zoneId);
		System.out.println(date);
		System.out.println(zdt1);
		System.out.println(dateTime);
		System.out.println(zdt2);
		System.out.println(instant);
		System.out.println(zdt3);
	}

LocaleDate、LocalTime、 LocalDateTime以及ZoneId之间的差异。