本帖最后由 长沙-小知姐姐 于 2019-3-1 16:35 编辑
1. 概述 JDK1.8中对日期的改动是特别大的，基本上是引入了一套全新的API 。因为由于原来老旧的日期API一直被人诟病，比如java.util.Date，java.util.Calendar等，并且原来所有的日期类都是可变且线程不安全的，导致许多人要么自己手动封装，要么转去使用Joda Time等这类优秀的第三方工具包。所以，在JDK1.8中，JDK官方在Joda Time等优秀工具包基础上，重新提供了一份相当不错的日期API。并且，在JDK1.8中，java.time包中的类是不可变且线程安全的。 JAVA8中的日期API是JSR-310的实现，并且是工作在ISO-8601日历系统基础上的，但我们也可以在非ISO的日历上。
JDK8的日期API大致分为以下几个包：
java.time包：JDK8中的基础包，所有常用的基础类都是这个包的一部分，如LocalDate，LocalTime，LocalDateTime等等，所有这些类都是不可变且线程安全的； java.time.chrono包：这个包为非ISO的日历系统定义了一些API，我们可以在借助这个包中的一些类扩展我们自己的日历系统； java.time.format包：这个包很明显了，格式化和解析日期时间对象，一般java.time包中的类都差不多能满足我们的需求了，如果有需要，可以调用这个包下的类自定义解析式； java.time.temporal包：这个包很有意思，封装了一些获取某个特定日期和时间的接口，比如某月的第一天或最后一天，并且这些方法都是属于特别好认的方法。 java.time.zone包：这个包就是时区相关的类了。
下面对ISO-8601简单描述一下，参考自百度百科：
ISO-8601: 国际标准化组织制定的日期和时间的表示方法，全称为《数据存储和交换形式·信息交换·日期和时间的表示方法》，简称为ISO-8601。 日的表示：小时、分和秒都用2位数表示，对UTC时间最后加一个大写字母Z，其他时区用实际时间加时差表示。如UTC时间下午2点30分5秒表示为14:30:05Z或143005Z，当时的北京时间表示为22:30:05+08:00或223005+0800，也可以简化成223005+08。 日期和时间的组合表示：合并表示时，要在时间前面加一大写字母T，如要表示北京时间2004年5月3日下午5点30分8秒，可以写成2004-05-03T17:30:08+08:00或20040503T173008+08。 在JDK1.8中，我们经常使用的大约有如下几个类：LocalDate, LocalTime, LocalDateTime, DateTimeFormatter等，所以我们主要看一下这几个类的相关方法。
2. 日期API
2.1LocalDate
java.time.LocalDate这个类，是用来表示日期的，也仅包含日期，用起来十分方便，方法也十分简单。我们来看一些小例子：
public static void testDate() { // 1. 获取当前日期(年月日) -----打印输出-----2018-01-29 LocalDate localDate = LocalDate.now(); System.out.println(localDate.toString()); // 2. 根据年月日构建Date ----打印输出-----2018-01-30 LocalDate localDate1 = LocalDate.of(2018,01, 30); // 3. 字符串转换日期,默认按照yyyy-MM-dd格式，也可以自定义格式 -----打印输出-----2018-01-30 LocalDate localDate2 =LocalDate.parse("2018-01-30"); // 4. 获取本月第一天 -----打印输出-----2018-01-01 LocalDate firstDayOfMonth =localDate.with(TemporalAdjusters.firstDayOfMonth()); // 5. 获取本月第二天 -----打印输出-----2018-01-02 LocalDate secondDayOfMonth =localDate.withDayOfMonth(2); // 6. 获取本月最后一天 -----打印输出-----2018-01-31 LocalDate lastDayOfMonth =localDate.with(TemporalAdjusters.lastDayOfMonth()); // 7. 明天 -----打印输出----- 2018-01-30 LocalDate tomorrowDay =localDate.plusDays(1L); // 8. 昨天 -----打印输出----- 2018-01-28 LocalDate yesterday =localDate.minusDays(1L); // 9. 获取本年第12天 -----打印输出-----2018-04-30 LocalDate day = localDate.withDayOfYear(120); // 10. 计算两个日期间的天数 long days = localDate.until(localDate1,ChronoUnit.DAYS); System.out.println(days); // 11. 计算两个日期间的周数 long weeks = localDate.until(localDate1,ChronoUnit.WEEKS); System.out.println(weeks); }
上面我只列举了几个常用的方法，但实际上LocalDate还有相当多的有意思的方法，基本上我们工作上遇到的与日期有关的操作，都可以通过LocadDate来实现。如果大家在遇到相关问题的时候，可以自行查看API去了解和使用。
2.2LocalTime同样，和LocalDate相对应的另一个类就是LocalTime，这个类恰好和LocalDate相反，它表示的全是时间，不包含日期。例子如下：
publicstatic void testTime() { // 1. 获取当前时间，包含毫秒数 -----打印输出----- 21:03:26.315 LocalTime localTime = LocalTime.now(); // 2. 构建时间 -----打印输出----- 12:15:30 LocalTime localTime1 = LocalTime.of(12, 15,30); // 3. 获取当前时间，不包含毫秒数 -----打印输出----- 21:01:56 LocalTime localTime2 =localTime.withNano(0); // 4. 字符串转为时间，还可以有其他格式，比如12:15, 12:15:23.233 // -----打印输出----- 12:15:30 LocalTime localTime3 =LocalTime.parse("12:15:30"); }
2.3LocalDateTimeLocalDateTime就和原先的java.util.Date很像了，既包含日期，又包含时间，它经常和DateTimeFormatter一起使用。
publicstatic void testDateTime() { // 1. 获取当前年月日 时分秒 -----打印输出----- 2018-01-29T21:23:26.774 LocalDateTime localDateTime =LocalDateTime.now(); // 2. 通过LocalDate和LocalTime构建 ----- 打印输出----- 2018-01-29T21:24:41.738 LocalDateTime localDateTime1 =LocalDateTime.of(LocalDate.now(), LocalTime.now()); // 3. 构建年月日 时分秒 -----打印输出----- 2018-01-29T19:23:13 LocalDateTime localDateTime2 =LocalDateTime.of(2018, 01, 29, 19, 23, 13); // 4. 格式化当前时间 ----打印输出----- 2018/01/29 DateTimeFormatter formatter =DateTimeFormatter.ofPattern("yyyy/MM/dd"); System.out.println(formatter.format(localDateTime2)); }
使用LocalDateTime的with开头的方法可以设置相应的时间，小时，分钟等，比如：
// 设置分钟数 LocalDateTimelocalDateTime = LocalDateTime.now().withMinute(23);
需要注意的有两点： LocalDateTime默认的格式是 2018-01-29T21:23:26.774 这种格式，这可能与我们经常使用的格式不太符合，所以我们可以指定格式。 DateTimeFormatter本身提供了许多静态格式化常量，我们可以参考使用，如果不能满足我们的需求的话，我们可以自定义； LocalDateTime的toString方法：
@OverridepublicString toString() { return date.toString() + 'T' +time.toString(); }
LocalDate，LocalTime，LocalDateTime这三个类基本上处理了大部分的日期，时间。而与这三个类经常结合使用的还有如下几个类：Year,Month,YearMonth,MonthDay,DayOfWeek。 并且，我们在LocalDate相关类的操作也可以通过Year，Month等来实现。
Yearyear =Year.now(); System.out.println(year.getValue());// 2018
2.4TemporalAdjusters
该类是一个计算用的类，提供了各种各样的计算方法。比如某个月的第一天，某个月的最后一天，某一年的第一天，某一年的第几天等各种计算方法。该类内部实现基本上全都是通过JDK8的Lambda表达式来实现的。随便举一些例子，都很简单。
LocalDatelocalDate = LocalDate.now(); // 1. 本月第一天 LocalDatefirstDayOfMonth = localDate.with(TemporalAdjusters.firstDayOfMonth()); // 2. 本月最后一天 LocalDatelastDayOfMonth = localDate.with(TemporalAdjusters.lastDayOfMonth()); // 3. 本年第一天 LocalDatefirstDayOfYear = localDate.with(TemporalAdjusters.firstDayOfYear()); // 4. 下个月第一天 LocalDatefirstDayOfNextMonth = localDate.with(TemporalAdjusters.firstDayOfNextMonth()) // 5. 本年度最后一天 LocalDatelastDayOfYear = localDate.with(TemporalAdjusters.lastDayOfYear());
System.out.println(firstDayOfMonth); System.out.println(lastDayOfMonth); System.out.println(firstDayOfYear); System.out.println(firstDayOfNextMonth); System.out.println(lastDayOfYear);
打印输出：
2018-01-01 2018-01-31 2018-01-01 2018-02-01 2018-12-31
2.5 Period和Duration Period是基于ISO-8601标准的日期系统，用于计算两个日期间的年，月，日的差值。比如'2年，3个月，4天'；而Duration和Period很像，但Duration计算的是两个日期间的秒，纳秒的值，是一种更为精确的计算方式；而ISO-8601系统是当今世界大部分地区采用的现代日历的阳历系统。
LocalDatelocalDate = LocalDate.now(); LocalDatelocalDate1 = LocalDate.of(2018, 3, 28); Periodperiod = Period.between(localDate, localDate1); System.out.println(period.getDays()); System.out.println(period.getMonths());
当然如果我们看一下Period的between方法实现，就知道底层是通过LocalDate.until方法来实现的。同样，Period的between方法也就等同于LocalDate.until方法。
但这里有一个问题，就是Period的getDays方法返回的不是两个日期间总的天数，有点像月计算后剩余的天数，但也不完全是，所以不太清楚这个类实际的意义。看个例子：
LocalDatelocalDate1 = LocalDate.of(2018, 01, 30); LocalDatelocalDate2 = LocalDate.of(2018, 03, 01); Periodperiod = Period.between(localDate1, localDate2); System.out.println(period.getDays());
打印：1
我们把第一行代码换一下值，再看一下： LocalDatelocalDate1 = LocalDate.of(2018, 01, 29);
结果还是打印1。再换： LocalDatelocalDate1 = LocalDate.of(2018, 01, 28); LocalDatelocalDate1 = LocalDate.of(2018, 01, 27);
上面两个分别打印1，2。 所以说，在没搞清楚上面的方法之前，还是不要贸然使用，而如果要计算两个日期间的总的天数，可以用如下方法来计算：
System.out.println(localDate1.until(localDate2,ChronoUnit.DAYS)); System.out.println(ChronoUnit.DAYS.between(localDate1,localDate2));
而对于Duration来说，就更简单了，计算两个时间之间的秒数，纳秒数：
LocalTimelocalTime1 = LocalTime.of(12, 12, 12); LocalTimelocalTime2 = LocalTime.of(12, 13, 27); Durationduration = Duration.between(localTime1, localTime2); System.out.println(duration.getSeconds()); // 75
但有一点需要注意，Duration中必须要支持秒数，如果没有的话，将会报错，如： LocalDatelocalDate1 = LocalDate.of(2018, 02, 28); LocalDatelocalDate2 = LocalDate.of(2018, 02, 27); Durationduration = Duration.between(localDate1, localDate2); System.out.println(duration.getSeconds());
将会直接提示： Exceptionin thread "main" java.time.temporal.UnsupportedTemporalTypeException:Unsupported unit: Seconds atjava.time.LocalDate.until(LocalDate.java:1614) atjava.time.Duration.between(Duration.java:475) atcom.jdk8.DateTest.testPeriod(DateTest.java:40) at com.jdk8.DateTest.main(DateTest.java:23)
2.6ChronoUnit 这个是个枚举类型，实现功能类型Period和Duration，但如果我们看它的底层实现，就可以看到它基本是基于Duration来实现的。这个枚举很简单，我们直接看一些例子就可以了：
LocalDateTimeoldDate = LocalDateTime.of(2017, Month.AUGUST, 31, 10, 20, 55); LocalDateTimenewDate = LocalDateTime.of(2018, Month.NOVEMBER, 9, 10, 21, 56);
System.out.println(oldDate); System.out.println(newDate); // countbetween dates longyears = ChronoUnit.YEARS.between(oldDate, newDate); longmonths = ChronoUnit.MONTHS.between(oldDate, newDate); longweeks = ChronoUnit.WEEKS.between(oldDate, newDate); longdays = ChronoUnit.DAYS.between(oldDate, newDate); longhours = ChronoUnit.HOURS.between(oldDate, newDate); longminutes = ChronoUnit.MINUTES.between(oldDate, newDate); longseconds = ChronoUnit.SECONDS.between(oldDate, newDate); longmilis = ChronoUnit.MILLIS.between(oldDate, newDate); longnano = ChronoUnit.NANOS.between(oldDate, newDate);
System.out.println("\n---Total --- "); System.out.println(years+ " years"); System.out.println(months+ " months"); System.out.println(weeks+ " weeks"); System.out.println(days+ " days"); System.out.println(hours+ " hours"); System.out.println(minutes+ " minutes"); System.out.println(seconds+ " seconds"); System.out.println(milis+ " milis"); System.out.println(nano+ " nano");
打印结果： 2017-08-31T10:20:55 2018-11-09T10:21:56 ---Total --- 1 years 14months 62 weeks 435 days 10440hours 626401minutes 37584061seconds 37584061000milis 37584061000000000nano
2.7 Clock 时钟系统，用于查找当前时刻。通过指定一个时区，我们可以获取到当前的时刻，日期，时间。所以可以使用一个时钟来代替System.currenttimemillis() 和TimeZone.getDefault()。
在应用程序的最佳实践是将时钟传递给任何需要当前即刻的方法：
publicclass MyBean { private Clock clock; // dependency inject ... public void process(LocalDate eventDate) { if(eventDate.isBefore(LocalDate.now(clock)) { ... } } }
我们可以简单测试一下：
// 系统默认 ClocksystemDefaultClock = Clock.systemDefaultZone(); System.out.println("CurrentDateTime with system default clock: " +LocalDateTime.now(systemDefaultClock)); System.out.println(systemDefaultClock.millis()); // 世界协调时UTC ClocksystemUTCClock = Clock.systemUTC(); System.out.println("CurrentDateTime with UTC clock: " + LocalDateTime.now(systemUTCClock)); System.out.println(systemUTCClock.millis()); //芝加哥 Clockclock = Clock.system(ZoneId.of(ZoneId.SHORT_IDS.get("CST"))); System.out.println("CurrentDateTime with CST clock: " + LocalDateTime.now(clock)); System.out.println(clock.millis());
打印： CurrentDateTime with system default clock: 2018-02-02T16:26:07.665 1517559967665CurrentDateTime with UTC clock: 2018-02-02T08:26:07.665 1517559967665CurrentDateTime with CST clock: 2018-02-02T02:26:07.667 1517559967667
2.8 其他其中还有一些类没有详细说明，比如： Instant，表示的是时间戳，用于记录某一时刻的更改（JDK8之前的Timestamp）; ZoneId 时区标志，比如用于标志欧洲/巴黎； ZoneOffset 时区偏移量，与UTC的偏移量； ZonedDateTime 与时区有关的日历系统，比如2007-12 03t10:15:30+01欧洲/巴黎； OffsetDateTime 用于与UTC偏移的日期时间，如如2007-12 03t10:15:30+01:00。
3. 转换
3.1java.util.Date与LocalDate，LocalTime，LocalDateTime替换将Date转换为LocalDate，LocalTime，LocalDateTime可以借助于ZonedDateTime和Instant，实现如下：
Datedate = new Date(); System.out.println("currentdate: " + date); // Date-> LocalDateTime LocalDateTimelocalDateTime =date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime(); System.out.println("localDateTimeby Instant: " + localDateTime); // Date-> LocalDate LocalDatelocalDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate(); System.out.println("localDateby Instant: " + localDate); // Date-> LocalTime LocalTimelocalTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalTime(); System.out.println("localTimeby Instant: " + localTime); //2.Date -> LocalDateTime localDateTime= LocalDateTime.ofInstant(date.toInstant(),ZoneId.systemDefault()); System.out.println("localDateTimeby ofInstant: " + localDateTime);
output： currentdate: Fri Feb 02 16:43:13 CST 2018 localDateTimeby Instant: 2018-02-02T16:43:13.073 localDateTimeby ofInstant: 2018-02-02T16:43:13.073 localDateby Instant: 2018-02-02 localTimeby Instant: 16:43:13.073
由于JDK8实现了向下兼容，所以Date里在JDK8版本引入了2个方法，from 和
toInstant，所以我们可以借助这两个方法来实现LocalDateTime到Date的转换。将LocalDateTime转为Date如下：
LocalDateTimelocalDateTime = LocalDateTime.now(); System.out.println("localDateTime:" + localDateTime); //LocalDateTime -> Date Datedate = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant()); System.out.println("LocalDateTime-> current date: " + date); //LocalDate -> Date，时间默认都是00 LocalDatelocalDate = LocalDate.now(); date =Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant()); System.out.println("LocalDate-> current date: " + date);
output： localDateTime:2018-02-02T16:55:52.464 LocalDateTime-> current date: Fri Feb 02 16:55:52 CST 2018 LocalDate-> current date: Fri Feb 02 00:00:00 CST 2018
而单独的LocalTime转为Date没什么意义，所以如果LocalTime要转为Date，一般借助于LocalDate和LocalDateTime来实现就可以了。
3.2 日期与字符串的转换 日期与字符串的转换比较简单。先说转换成日期格式，通过LocalDate，LocalTime，LocalDateTime的parse方法和DateTimeFormatter来实现
LocalDatelocalDate = LocalDate.parse("2018-09-09",DateTimeFormatter.ofPattern("yyyy-MM-dd")); LocalDateTimelocalDateTime = LocalDateTime.parse("2018-09-10 12:12:12",DateTimeFormatter.ofPattern("yyyy-MM-dd HH:ss:mm")); 而将日期转为字符串，可以通过format方法和DateTimeFormatter来实现： StringlocalDate =LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")); StringlocalDateTime =LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-ddHH:ss:mm")); // 也可以通过DateTimeFormatter的format方法 DateTimeFormatterdateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-ddHH:mm:ss"); localDateTime= dateTimeFormatter.format(LocalDateTime.now());
3.3 时间戳与LocalDateTime转换将时间戳转为LocalDateTime，可以借助Instant(其实就是时间戳)来实现：
publicstatic LocalDateTime convertToDate(long timestamp) { // ofEpochSecond 以秒为单位， ofEpochMilli 以毫秒为单位 // Instant.ofEpochSecond(timestamp); Instant instant =Instant.ofEpochMilli(timestamp); return LocalDateTime.ofInstant(instant,ZoneId.systemDefault()); }
而将LocalDateTime转为时间戳，则同样可以借助Instant来实现：
publicstatic long convertToTimestamp() { LocalDateTime localDateTime =LocalDateTime.now(); returnlocalDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(); }
而至于字符串与时间戳的转换，借助LocalDateTime来实现即可。
总结
java.time包下其实还有一些其他的类与方法，如查询是否是闰年，日期比较，获取某一年的某一天等等，我们可以等用到的时候再去查看不迟。并且我们可以将我们常用的方法封装成util包供我们在使用的时候直接调用。 JDK8提供的这套API接口基本上封装了我们平时常用的所有与日期时间的相关操作，所以如果升级了JDK8，在处理日期和时间的时候尽量多用新的API。 JDK8中新的日期不但命名优雅，通俗易懂，而且提供了向下兼容的能力，可以无缝连接。 如果用到了Period，注意它的getDays方法。
| 
收藏
淘帖
踩
