Java8新特性(6).新的日期时间API

一张图来概括新的日期时间API知识点

新的日期时间API

一、日期LocalDate

1.创建日期对象
(1)of:通过指定的年月日来构建日期对象
  • of (int year, int month, int day)
    • year : 年(整型 -999,999,999至999,999,999)
    • month : 月(整型 1-12)
    • day : 日(1-31)
  • of (int year, Month month, int day)
    • month : Month对象(Month是一个枚举型)
  1. /**
  2. * 通过年/月/日 都是整型
  3. */
  4. LocalDate localDate = LocalDate.of(2019, 1, 25);
  5. System.out.println(localDate); //2019-01-25
  6. /**
  7. * 通过 年/月(对象)/日 其中年和月是整型,月为对象
  8. */
  9. LocalDate localDateFormMonth = LocalDate.of(2019, Month.JANUARY.getValue(), 31);
  10. System.out.println(localDateFormMonth); //2019-01-31
(2)ofYearDay : 通过指定某年的第多少天来构建日期对象
  • ofYearDay(int year, int day)
    • year : 年份
    • day : 指定年的第多少天(1-365)
  1. LocalDate localYearDate = LocalDate.ofYearDay(2019, 35); //2019年的第35天(0-365)
  2. System.out.println(localYearDate); //2019-02-04
(3)ofEpochDay : 通过从1970-01-01开始的天数来构建日期对象
  • ofEpochDay(long day)
    • day : 从1970-01-01开始的天数(0表示1970-01-01,负数表示之前的时间)
  1. LocalDate localEpochDate = LocalDate.ofEpochDay(12);
  2. System.out.println(localEpochDate); //1970-01-13
  3. System.out.println(LocalDate.ofEpochDay(-12)); //1969-12-20
(4)from : 从另外一个日期或日期时间对象来构建新的日期对象
  • from(TemporalAccessor temporal)
    • temporal : LocalDate或LocalDateTime等日期时间对象
  1. LocalDate localFromDate = LocalDate.from(LocalDate.of(2019, 1, 30));
  2. System.out.println(localFromDate); //2019-01-30
  3. System.out.println(LocalDate.from(LocalDateTime.now())); //2019-01-31
(5)now : 获取当前日期
  1. LocalDate date = LocalDate.now();
  2. System.out.println(date); //2019-01-31
2.获取日期的相关属性
  • 获取年相关的属性
    • getYear : 获取年份
    • isLeapYear : 是否闰年
    • lengthOfYear : 全年的天数
  • 获取月相关的属性
    • getMonth : 获取月对象
    • getMonthValue : 获取月份值
    • lengthOfMonth : 一个月的天数
  • 获取日相关的属性
    • getDayOfYear : 当前日期是一年的第多少天
    • getDayOfMonth : 当前日期是当月的第多少天
    • getDayOfWeek : 当前日期是周几(是一个对象,可以通过getValue来获取值)
  • 两个日期比较
    • equals : 比较两个日期是否为同一天
    • isEqual : 比较两个日期是否为同一天
    • isBefore : 当前日期是否在指定日期之前
    • isAfter : 当前日期是否在指定日期之后
  1. LocalDate localDate = LocalDate.now(); //2019-1-31
  2. System.out.println(localDate.getYear()); //2019(2019年)
  3. System.out.println(localDate.isLeapYear()); //false(是否为闰年)
  4. System.out.println(localDate.lengthOfYear()); //365(1年的天数)
  5. System.out.println(localDate.getMonthValue()); //1(1月份)
  6. System.out.println(localDate.getMonth()); //JANUARY(1月份对象)
  7. System.out.println(localDate.lengthOfMonth()); //31(月的天数)
  8. System.out.println(localDate.getDayOfYear()); //31(2019年全年的第31天)
  9. System.out.println(localDate.getDayOfMonth()); //31(2019年1月份的第31天)
  10. System.out.println(localDate.getDayOfWeek()); //THURSDAY(周四)
  11. LocalDate today = LocalDate.of(2019, 1, 31);
  12. System.out.println(localDate.equals(today)); //true
  13. System.out.println(localDate.isEqual(today)); //true
  14. LocalDate yesterday = LocalDate.of(2019, 1, 30);
  15. LocalDate tomorrow = LocalDate.of(2019, 2, 1);
  16. System.out.println(yesterday.isBefore(today)); //true
  17. System.out.println(tomorrow.isAfter(today)); //true
3.日期计算
  • 增加(算多久周期之后的):plusXXX
    • 年:plusYears
    • 月:plusMonths
    • 周:plusWeeks
    • 日:plusDays
    • 指定周期:plus
  • 减少(算多久周期之前的):minusXXX
    • 年:minusYears
    • 月:minusMonths
    • 周:minusWeeks
    • 日:minusDays
    • 指定周期:minus
  1. LocalDate oneDay = LocalDate.of(2019, 1, 18);
  2. System.out.println(oneDay.plusYears(3)); //3年后:2022-01-18
  3. System.out.println(oneDay.plusMonths(4)); //4个月后: 2019-05-18
  4. System.out.println(oneDay.plusWeeks(3)); //3周后:2019-02-08
  5. System.out.println(oneDay.plusDays(10)); //10天后:2019-01-28
  6. System.out.println(oneDay.plus(Period.ofDays(3))); //3天后:2019-01-21
  7. System.out.println(oneDay.plus(3, ChronoUnit.DAYS)); //3天后:2019-01-21
  8. System.out.println(oneDay.minusYears(3)); //3年前:2016-01-18
  9. System.out.println(oneDay.minusMonths(4)); //4个月前: 2018-09-18
  10. System.out.println(oneDay.minusWeeks(3)); //3周前:2018-12-28
  11. System.out.println(oneDay.minusDays(10)); //10天前:2019-01-08
  12. System.out.println(oneDay.minus(Period.ofDays(3))); //3天前:2019-01-15
  13. System.out.println(oneDay.minus(3, ChronoUnit.DAYS)); //3天前:2019-01-15
4.日期时间格式化
  • format : 将日期对象格式化为字符串
  • parse : 将字符串解析为日期对象
  1. DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
  2. /**
  3. * 1 将某个时间转化为格式化的时间字符串
  4. */
  5. String dateString = LocalDateTime.now().format(dateTimeFormatter);
  6. System.out.println(dateString); //2019-01-25 16:15:08
  7. /**
  8. * 2 将某个时间解析为格式化对象
  9. */
  10. LocalDateTime dateTime = LocalDateTime.parse(dateString, dateTimeFormatter);
  11. System.out.println(dateTime); //2019-01-25T16:49:12
5.与其他日期或时间类型的转换
(1)Date对象转化为LocalDate对象
  • 第一步:将Date对象的toInstant转化为Instant对象
  • 第二步:通过Instant对象的atZone方法将Instant对象转化为ZonedDateTime对象
  • 第三步:通过ZonedDateTime对象的toLocalDate方法将ZonedDateTime对象转化为LocalDate对象
  1. Date date = new Date();
  2. Instant instant = date.toInstant();
  3. LocalDate localDate = instant.atZone(ZoneId.of("Asia/Shanghai")).toLocalDate();
  4. System.out.println(localDate); //2019-01-31
(2)LocalDate对象转化为Date对象
  • 第一步:通过LocalDate对象的atStartOfDay方法将LocalDate对象转化为ZonedDateTime对象
  • 第二步:通过ZonedDateTime的toInstant将ZonedDateTime对象转化为Instant对象
  • 第三步:通过Date的from方法将Instant对象转化为Date对象
  1. LocalDate localDateObj = LocalDate.of(2019, 1, 22);
  2. ZonedDateTime zonedDateTime = localDateObj.atStartOfDay(ZoneId.of("Asia/Shanghai"));
  3. Instant instantObj = zonedDateTime.toInstant();
  4. Date dateObj = Date.from(instantObj);
  5. System.out.println(dateObj);

二、时间LocalTime

1.构建时间对象
  • of : 通过指定的时、分、秒、纳秒等构建
  • ofSecondOfDay : 通过指定的总秒数来构建
  • now : 当前时间 
  1. System.out.println(LocalTime.of(10, 30)); //10:30
  2. System.out.println(LocalTime.of(11, 29, 18)); //11:29:18
  3. System.out.println(LocalTime.of(11, 23, 25, 15)); //11:23:25.000000015
  4. System.out.println(LocalTime.ofSecondOfDay(17000)); //04:43:20(1个小时3600秒)
  5. System.out.println(LocalTime.ofNanoOfDay(15890000000000L)); //04:24:50(1秒=1000毫秒,1毫秒=1000微秒,1微秒=1000纳秒)
2.获取时间属性
  • getHour : 小时
  • getMinute : 分钟
  • getSecond : 秒
  • getNano : 纳秒
  1. LocalTime localTime = LocalTime.of(11, 29, 18);
  2. System.out.println(localTime.getHour());
  3. System.out.println(localTime.getMinute());
  4. System.out.println(localTime.getSecond());
  5. System.out.println(localTime.getNano());
3.时间计算
    • 1.时 : plusHours
    • 2.分 : plusMinutes
    • 3.秒 : plusSeconds
    • 4.纳秒 : plusNanos
    • 5.指定周期 : plus
    • 1.时 : minusHours
    • 2.分 : minusMinutes
    • 3.秒 : minusSeconds
    • 4.纳秒 : minusNanos
    • 5.指定周期 : minus
  1. System.out.println(localTime.plusHours(10));
  2. System.out.println(localTime.plusMinutes(15));
  3. System.out.println(localTime.plusSeconds(15));
  4. System.out.println(localTime.plus(Duration.ofMinutes(10)));
  5. System.out.println(localTime.minusHours(10));
  6. System.out.println(localTime.minusMinutes(15));
  7. System.out.println(localTime.minusSeconds(15));
  8. System.out.println(localTime.minus(Duration.ofMinutes(15)));
4.时间格式化
  • format
  • parse

三、日期时间LocalDateTime

1.构建日期时间对象
  • of
    • 通过LocalDate和LocalTime两个对象构建
    • 通过指定的年、月、日、时、分、秒来构建
  • ofEpochSecond : 通过标准时间戳后的秒数来构建
  • ofInstant : 通过时间戳对象来构建
  1. LocalDateTime localDateTime = LocalDateTime.of(2019, 1, 28, 10, 30, 27);
  2. System.out.println(localDateTime); //2019-01-28T10:30:27
  3. System.out.println(LocalDateTime.ofEpochSecond(3600, 0, ZoneOffset.UTC)); //1970-01-01T01:00
2.获取日期时间属性
  • 日期属性:LocalDate的属性
  • 时间属性:LocalTime的属性
3.日期时间计算
  • 日期计算:LocalDate的计算方法
  • 时间计算:LocalTime的计算方法
4.日期时间格式化

通过DateTimeFormatter来实现

四、时间戳Instant

1.创建时间戳对象
  • ofEpochSeconds: 以标准时间戳为始点,所经过的秒数
  • now: 现在的时间(与东八区即我国使用的时区有8个小时的时差)
  1. Instant instantObj = Instant.ofEpochSecond(3600*24*365*50);
  2. System.out.println(instantObj); //2019-12-20T00:00:00Z
  3. Instant instant = Instant.now();
  4. System.out.println(instant); //2019-01-31T04:07:46.424Z(与本地时间有8个小时的时差)
  5. Instant now = Instant.now().plusMillis(TimeUnit.HOURS.toMillis(8));
  6. System.out.println(now); //2019-01-31T12:07:46.489Z
2.时间戳计算
    • plusSeconds : 指定秒数之后的时间
    • plus
    • minusSeconds : 指定秒数之前的时间
    • minus
  1. System.out.println("8小时后:" + instant.plusSeconds(3600*8)); //2019-01-31T13:07:55.870Z
  2. System.out.println(instant.plus(Duration.ofHours(8))); //2019-01-31T13:07:55.870Z
  3. System.out.println(instant.plus(4, ChronoUnit.HOURS)); //2019-01-31T09:09:31.052Z
  4. System.out.println("2小时前" + instant.minusSeconds(3600*2));
  5. System.out.println(instant.minus(Duration.ofHours(2)));

五、日期间隔Period

  • 年 : ofYears
  • 月 : ofMonths
  • 周 : ofWeeks
  • 日 : ofDays
  1. System.out.println(Period.ofDays(5)); //5天间隔
  2. System.out.println(Period.ofWeeks(3)); //3周的间隔
  3. System.out.println(Period.ofMonths(2)); //2个月的间隔
  4. System.out.println(Period.ofYears(3)); //3年的间隔

六、时间间隔Duration

  • 天 : ofDays
  • 时 : ofHours
  • 分 : ofMinutes
  • 秒 : ofSeconds
  • 毫秒 : ofMillis
  • 纳秒 : ofNanos
  1. System.out.println(Duration.ofDays(2)); //2天的间隔
  2. System.out.println(Duration.ofHours(3)); //3个小时的间隔
  3. System.out.println(Duration.ofMinutes(10));//10分钟的间隔
  4. System.out.println(Duration.ofSeconds(30)); //30秒的间隔
  5. System.out.println(Duration.ofMillis(100)); //100毫秒的间隔
  6. System.out.println(Duration.ofNanos(1000)); //1000纳秒的间隔

七、日期时间格式化LocalDateFormatter

1.日期时间格式模式
格式 格式模式 例子
yyyy 2019
MM 01
dd 01
HH 01
mm 02
ss 15
2.函数
  • ofPattern

注:与时期时间对象的parse和format方法一起配合使用

  1. /**
  2. * 日期时间格式化
  3. */
  4. DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");