Java8时间日期处理新特性

Java8时间日期处理新特性

简介

伴随lambda表达式、streams以及一系列小优化，Java 8 推出了全新的日期时间API。Java处理日期、日历和时间的不足之处：将 java.util.Date 设定为可变类型，以及 SimpleDateFormat 的非线程安全使其应用非常受限。然后就在 java8 上面增加新的特性。全新API的众多好处之一就是，明确了日期时间概念，例如：瞬时（instant）、长短（duration）、日期、时间、时区和周期。同时继承了Joda 库按人类语言和计算机各自解析的时间处理方式。不同于老版本，新API基于ISO标准日历系统，java.time包下的所有类都是不可变类型而且线程安全。

关键类

Instant：瞬时实例。

LocalDate：本地日期，不包含具体时间 例如：2014-01-14 可以用来记录生日、纪念日、加盟日等。

LocalTime：本地时间，不包含日期。

LocalDateTime：组合了日期和时间，但不包含时差和时区信息。

ZonedDateTime：最完整的日期时间，包含时区和相对UTC或格林威治的时差

实际应用

获取当前时间的对象

1. LocalDateTime localDateTime = LocalDateTime.now();
2. Date date = new Date();

localDateTime相比Date更像是一个工具类，就是为了时间操作使用。其构造方法是私有的

从字符串中解析

字符串 2019-01-11 解析成时间对象

1. String str = "2019-01-11";
2. DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
3. LocalDate localDate = LocalDate.parse(str, formatter);
4.  
5. SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
6. try {
7.     Date date = simpleDateFormat.parse(str);
8. } catch (ParseException e) {
9.     e.printStackTrace();
10. }

DateTimeFormatter的包路径是java.time.format和LocalDate一样在java.time下面，而SimpleDateFormat和Date是不同的。所以当判断引入路径的时候更容易判断。
当解析失败的时候，两个异常的抛出不一样，DateTimeFormatter抛出的是DateTimeParseException,继承自RuntimeException,而ParseException明显继承的是Exception。
个人感觉这个思路是，前者如果抛出异常那就是编程上错误，而后者则是的程序代码的不稳定性。更倾向于第一种的异常设计，应该加强对入参的检测判断，而不是通过捕获异常去处理入参的错误。（类似NumberFormatException）

LocalDate比Date更强的初始化时间

Date 设置某个日期，基本上3个方式，时间戳/Calendar/字符串解析。相对的LocalDate就简单很多

1. LocalDate.of(2019,1,12);

时间戳的转换

LocalDate时间戳的转换不如Date直接。主要因为LocalDate本身是没有时区的。

时间戳传LocalDateTime

1. long timestamp = System.currentTimeMillis();
2. Instant instant = Instant.ofEpochMilli(timestamp);
3. LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

LocalDateTime转时间戳

1. LocalDateTime dateTime = LocalDateTime.now();
2. dateTime.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
3. dateTime.toInstant(ZoneOffset.of("+08:00")).toEpochMilli();
4. dateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();

和Date互转

1. import java.time.Instant;
2. import java.util.Date;
3.  
4. public class Main {
5.   public static void main(String[] args) {
6.     Date  dt =  new Date(); 
7.     System.out.println("Date: "  + dt);
8.  
9.     Instant in = dt.toInstant(); 
10.     System.out.println("Instant: "  + in);
11.  
12.     Date  dt2  = Date.from(in); 
13.     System.out.println("Date: "  + dt2);
14.   }
15. }

更好的理解和操作方式

Date、Calendar的操作，例如设置月份，day of week 的使用都不符合常规，例如1月的定义是0，周一是0。1号是0，相对于的 LocalDate就比较友好。例如DayOfWeek是枚举类型能更直观的使用

另外日期和时间的计算可以直接进行加减和比较，如使用'加'的示例：

而Calendar操作日期则是使用get，set方法很不友好如：

Calendar cal = Calendar.getInstance();

cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1)

线程安全性比较

Java8提供的日期处理API LocalDate 等系列都是线程安全的，每一个字段都用了final关键字了，所以进行操作后都是返回新的copy对象

而Date线程不安全，get,set在多线程的时候容易出现问题，不过set方法已经标注@Deprecated废弃了。当然不是因为线程安全问题废弃的，是因为有了更好的替代

SimpleDateFormat的线程安全性

在一定负载情况下，SimpleDateFormat会出问题的。当然SimpleDateFormat线程不安全应该人尽皆知的，但依然有不安全的使用，但每次使用都new一个实例，当负载大的时候也不好。

Java8时间常用计算实例

1. import java.time.Clock;
2. import java.time.Instant;
3. import java.time.LocalDate;
4. import java.time.LocalDateTime;
5. import java.time.LocalTime;
6. import java.time.Month;
7. import java.time.MonthDay;
8. import java.time.OffsetDateTime;
9. import java.time.ZoneOffset;
10. import java.time.Period;
11. import java.time.YearMonth;
12. import java.time.ZoneId;
13. import java.time.ZonedDateTime;
14. import java.time.format.DateTimeFormatter;
15. import java.time.temporal.ChronoUnit;
16. import java.util.Date;
17.  
18. public class DateTest {
19.     //获取今天的日期
20.     public void getCurrentDate(){
21.         LocalDate today = LocalDate.now();
22.         System.out.println("Today's Local date : " + today);
23.         
     
24.         //这个是作为对比
25.         Date date = new Date();
26.         System.out.println(date);
27.     }
28.     
     
29.     //获取年、月、日信息
30.     public void getDetailDate(){
31.         LocalDate today = LocalDate.now();
32.         int year = today.getYear();
33.         int month = today.getMonthValue();
34.         int day = today.getDayOfMonth();
35.         System.out.printf("Year : %d  Month : %d  day : %d t %n", year, month, day);
36.     }
37.     
     
38.     //处理特定日期
39.     public void handleSpecilDate(){
40.         LocalDate dateOfBirth = LocalDate.of(2018, 01, 21);
41.         System.out.println("The specil date is : " + dateOfBirth);
42.     }
43.     
     
44.     //判断两个日期是否相等
45.     public void compareDate(){
46.         LocalDate today = LocalDate.now();
47.         LocalDate date1 = LocalDate.of(2018, 01, 21);
48.         if(date1.equals(today)){
49.             System.out.printf("TODAY %s and DATE1 %s are same date %n", today, date1);
50.         }
51.     }
52.     
     
53.     //处理周期性的日期
54.     public void cycleDate(){
55.         LocalDate today = LocalDate.now();
56.         LocalDate dateOfBirth = LocalDate.of(2018, 01, 21);
57.         MonthDay birthday = MonthDay.of(dateOfBirth.getMonth(), dateOfBirth.getDayOfMonth());
58.         MonthDay currentMonthDay = MonthDay.from(today);
59.         if(currentMonthDay.equals(birthday)){
60.            System.out.println("Many Many happy returns of the day !!");
61.         }else{
62.            System.out.println("Sorry, today is not your birthday");
63.         }
64.     }
65.     
     
66.     //获取当前时间
67.     public void getCurrentTime(){
68.         LocalTime time = LocalTime.now();
69.         System.out.println("local time now : " + time);
70.     }
71.     
     
72.     //增加小时
73.     public void plusHours(){
74.         LocalTime time = LocalTime.now();
75.         LocalTime newTime = time.plusHours(2); // 增加两小时
76.         System.out.println("Time after 2 hours : " +  newTime);
77.     }
78.     
     
79.     //如何计算一周后的日期
80.     public void nextWeek(){
81.         LocalDate today = LocalDate.now();
82.         LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS);
83.         System.out.println("Today is : " + today);
84.         System.out.println("Date after 1 week : " + nextWeek);
85.     }
86.     
     
87.     //计算一年前或一年后的日期
88.     public void minusDate(){
89.         LocalDate today = LocalDate.now();
90.         LocalDate previousYear = today.minus(1, ChronoUnit.YEARS);
91.         System.out.println("Date before 1 year : " + previousYear);
92.         LocalDate nextYear = today.plus(1, ChronoUnit.YEARS);
93.         System.out.println("Date after 1 year : " + nextYear);
94.     }
95.     
     
96.     public void clock(){
97.         // 根据系统时间返回当前时间并设置为UTC。
98.         Clock clock = Clock.systemUTC();
99.         System.out.println("Clock : " + clock);
100.         // 根据系统时钟区域返回时间
101.         Clock defaultClock = Clock.systemDefaultZone();
102.         System.out.println("Clock : " + clock);
103.     }
104.     
      
105.     //如何用Java判断日期是早于还是晚于另一个日期
106.     public void isBeforeOrIsAfter(){
107.         LocalDate today = LocalDate.now(); 
108.  
109.         LocalDate tomorrow = LocalDate.of(2018, 1, 29);
110.         if(tomorrow.isAfter(today)){
111.             System.out.println("Tomorrow comes after today");
112.         }
113.         LocalDate yesterday = today.minus(1, ChronoUnit.DAYS);
114.         if(yesterday.isBefore(today)){
115.             System.out.println("Yesterday is day before today");
116.         }
117.     }
118.     
      
119.     //时区处理
120.     public void getZoneTime(){
121.         //设置时区
122.         ZoneId america = ZoneId.of("America/New_York");
123.         LocalDateTime localtDateAndTime = LocalDateTime.now();
124.         ZonedDateTime dateAndTimeInNewYork  = ZonedDateTime.of(localtDateAndTime, america );
125.         System.out.println("现在的日期和时间在特定的时区 : " + dateAndTimeInNewYork);
126.     }
127.     
      
128.     //使用 YearMonth类处理特定的日期
129.     public void checkCardExpiry(){
130.         YearMonth currentYearMonth = YearMonth.now();
131.         System.out.printf("Days in month year %s: %d%n", currentYearMonth, currentYearMonth.lengthOfMonth());
132.         YearMonth creditCardExpiry = YearMonth.of(2028, Month.FEBRUARY);
133.         System.out.printf("Your credit card expires on %s %n", creditCardExpiry);
134.     }
135.     
      
136.     //检查闰年
137.     public void isLeapYear(){
138.         LocalDate today = LocalDate.now();
139.         if(today.isLeapYear()){
140.            System.out.println("This year is Leap year");
141.         }else {
142.             System.out.println("2018 is not a Leap year");
143.         }
144.     }
145.     
      
146.     //计算两个日期之间的天数和月数
147.     public void calcDateDays(){
148.         LocalDate today = LocalDate.now();
149.         LocalDate java8Release = LocalDate.of(2018, Month.MAY, 14);
150.         Period periodToNextJavaRelease = Period.between(today, java8Release);
151.         System.out.println("Months left between today and Java 8 release : "  + periodToNextJavaRelease.getMonths() );
152.     }
153.     
      
154.     // 包含时差信息的日期和时间
155.     public void ZoneOffset(){
156.         LocalDateTime datetime = LocalDateTime.of(2018, Month.FEBRUARY, 14, 19, 30);
157.         ZoneOffset offset = ZoneOffset.of("+05:30");
158.         OffsetDateTime date = OffsetDateTime.of(datetime, offset);  
159.         System.out.println("Date and Time with timezone offset in Java : " + date);
160.     }
161.     
      
162.     // 获取时间戳
163.     public void getTimestamp(){
164.         Instant timestamp = Instant.now();
165.         System.out.println("What is value of this instant " + timestamp);
166.     }
167.  
168.     // 使用预定义的格式化工具去解析或格式化日期
169.     public void formateDate(){
170.         String dayAfterTommorrow = "20180210";
171.         LocalDate formatted = LocalDate.parse(dayAfterTommorrow, DateTimeFormatter.BASIC_ISO_DATE);
172.         System.out.printf("Date generated from String %s is %s %n", dayAfterTommorrow, formatted);
173.     }
174.     
      
175.     public static void main(String[] args) {
176.         DateTest dt = new DateTest();
177.         dt.formateDate();
178.     }
179. }

总结

Java 8日期时间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。

参考链接：

https://www.136.la/jingpin/show-15179.html

https://www.jianshu.com/p/4508d6976bb1