yrl's blog
0%

JDK8新特性——时间类

发表于 分类于

JDK8新特性——时间类

为什么需要使用新的时间类

1、Date如果不格式化，打印出的日期可读性差【Tue Sep 10 09:34:04 CST 2019】；

2、使用 SimpleDateFormat 对时间进行格式化，但 SimpleDateFormat 是线程不安全的；

3、获取时间一些参数需要转换为calendar类获取……

JDK8新特性提供的时间操作类

1、LocalDate 【日期】

2、LocalTime 【时间】

3、LocalDateTime 【日期时间】

API

获取当前日期

1
LocalDate localDate = LocalDate.now();

构造指定的年月日

1
LocalDate localDate1 = LocalDate.of(2019, 9, 10);

获取当前时间

1
LocalTime localTime = LocalTime.now();

构造指定的时分秒

1
LocalTime localTime1 = LocalTime.of(12, 9, 10);

获取当前时日

1
LocalDateTime localDateTime = LocalDateTime.now();

构造指定的时日

1
LocalDateTime localDateTime1 = LocalDateTime.of(2019, Month.SEPTEMBER, 10, 14, 46, 56);

获取时间的某一个值

1
2
3
4
5
6
7
8
9
int year = localDateTime1.getYear();   //2020  年份
Month month = localDateTime1.getMonth();   //JUNE  月份
int monthValue = localDateTime1.getMonthValue();   //6  月份数值
int day = localDateTime1.getDayOfMonth();   //28  日期
DayOfWeek dayOfWeek = localDateTime1.getDayOfWeek();   //SUNDAY  周
int dayOfYear = localDateTime1.getDayOfYear();   //180  年的第几天
int hour = localDateTime1.getHour();   //13 小时
int minute = localDateTime1.getMinute();   //51  分钟
int second = localDateTime1.getSecond();   //19  秒

LocalDateTime、LocalDate、LocalTime的转换

1
2
3
4
5
LocalDateTime localDateTime = LocalDateTime.of(localDate, localTime);
LocalDateTime localDateTime = localDate.atTime(localTime);
LocalDateTime localDateTime = localTime.atDate(localDate);
LocalDate localDate = localDateTime.toLocalDate();
LocalTime localTime = localDateTime.toLocalTime();

将某个时间增加

1
2
localDateTime = localDateTime.plus(2,ChronoUnit.YEARS);  //增加2年
localDateTime = localDateTime.plusYears(2);  //增加2年

将某个时间减少

1
2
localDateTime = localDateTime.minus(2,ChronoUnit.YEARS);  //减少2年
localDateTime = localDateTime.minusYears(2);  //减少2年

将某个时间参数指定

1
2
localDateTime1 = localDateTime1.with(ChronoField.MONTH_OF_YEAR,1);  //指定月份为1月
localDateTime1 = localDateTime1.withHour(2);  //指定小时为2时

其他

1
2
3
4
5
6
7
8
localDateTime.with(firstDayOfYear());  //获取当年的第一天
localDateTime.with(firstDayOfMonth());  //获取当月的第一天
localDateTime.with(firstDayOfNextYear());  //获取下年的第一天
localDateTime.with(firstDayOfNextMonth());  //获取下月的第一天
localDateTime.with(firstInMonth(DayOfWeek.MONDAY));  //获取当月第一个星期一的时间
localDateTime.with(lastDayOfYear());  //获取上年的第一天
localDateTime.with(lastDayOfMonth());  //获取上月的第一天
localDateTime.with(lastInMonth(DayOfWeek.MONDAY));  //获取当月最后一个星期一的时间

格式化时间

1
2
3
4
5
6
//默认提供了几种格式时间的方式【一般不用】
String s1 = localDateTime.format(DateTimeFormatter.BASIC_ISO_DATE);
String s2 = localDateTime.format(DateTimeFormatter.ISO_DATE_TIME);
//自定义格式化时间的方式
DateTimeFormatter dateTimeFormatter =   DateTimeFormatter.ofPattern("dd/MM/yyyy/hh/mm/ss");
String s3 = localDateTime.format(dateTimeFormatter);

字符串解析时间

1
2
3
4
LocalDate localDate1 = LocalDate.parse("20190910", DateTimeFormatter.BASIC_ISO_DATE);
LocalDate localDate2 = LocalDate.parse("2019-09-10", DateTimeFormatter.ISO_LOCAL_DATE);
DateTimeFormatter dateTimeFormatter =   DateTimeFormatter.ofPattern("dd/MM/yyyy/hh/mm/ss");
LocalDate localDate3 = LocalDate.parse("28/06/2020/02/28/46", dateTimeFormatter);

Timestamp与LocalDateTime的转换

1
LocalDateTime localDateTime1 = new Timestamp(System.currentTimeMillis()).toLocalDateTime();

LocalDateTime与Long（时间戳）的转换

1
2
LocalDateTime localDateTime = (new Timestamp(System.currentTimeMillis())).toLocalDateTime();
long time = localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();

时间的比较

1
2
3
4
LocalDateTime localDateTime = LocalDateTime.of(1994,8,7,9,0,0);
LocalDateTime localDateTime4 = LocalDateTime.now();
System.out.println(localDateTime.isBefore(localDateTime4));
System.out.println(localDateTime.isAfter(localDateTime4));

计算时间间隔（Duration类和Period类）

使用场景【计算年龄、合同时间等。。。】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
LocalDateTime localDateTime = LocalDateTime.of(1994,8,7,9,0,0);
LocalDateTime localDateTime4 = LocalDateTime.now();
Duration duration = Duration.between(localDateTime,localDateTime4);
//间隔多少天
long days = duration.toDays();
//间隔多少小时
long hours = duration.toHours();
//间隔多少分钟
long minutes = duration.toMinutes();
Period period2 = Period.between(localDateTime.toLocalDate(),localDateTime4.toLocalDate());
//间隔多少年
int years = period2.getYears();
//间隔多少月（只计算月份，不计年）
int months = period2.getMonths();
//间隔多少月（计算年）
long toTotalMonths = period2.toTotalMonths();

工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
import java.sql.Timestamp;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;

public class DateTimeUtils {

    public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HHmmss");
    public static final DateTimeFormatter YEAR_MONTH_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM");
    public static final DateTimeFormatter SHORT_DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
    public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    public static final DateTimeFormatter SHORT_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
    public static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    public static final DateTimeFormatter LONG_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss SSS");
    public static final DateTimeFormatter ABC_DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy/MM/dd");
    public static final DateTimeFormatter ABC_TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");
    public static final DateTimeFormatter ABC_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
    public static final DateTimeFormatter ABC_SHORT_DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyMMddHHmmss");

    /**
     *  将旧格式字符串日期 转换成新格式字符串日期
     *  格式转换
     */
    public static String dateStrConvertDateStrFromLocalDateTime(String dateStr,DateTimeFormatter oldDateTimeFormatter,DateTimeFormatter newDateTimeFormatter){
       LocalDateTime localDateTime = LocalDateTime.parse(dateStr, oldDateTimeFormatter);
       return localDateTime.format(newDateTimeFormatter);
    }
    /**
     *  将旧格式字符串日期 转换成新格式字符串日期
     *  格式转换
     */
    public static String dateStrConvertDateStrFromLocalDate(String dateStr,DateTimeFormatter oldDateTimeFormatter,DateTimeFormatter newDateTimeFormatter){
        LocalDate localDate = LocalDate.parse(dateStr, oldDateTimeFormatter);
       return localDate.format(newDateTimeFormatter);
    }


    /**
     *  将字符串日期转换成date类型
     */
    public static Date dateStrConvertDate(String dateStr,DateTimeFormatter dateTimeFormatter){
        LocalDateTime parse = LocalDateTime.parse(dateStr, dateTimeFormatter);
        // 获得 Instant
        Instant instant = Instant.ofEpochSecond(parse.toEpochSecond(ZoneOffset.ofHours(8)));
        // 获得 Date
        return Date.from(instant);
    }
    /**
     *  将date类型转换成字符串日期
     */
    public static String dateConvertDateStr(Date date,DateTimeFormatter dateTimeFormatter){
        LocalDateTime localDateTime = date.toInstant().atOffset(ZoneOffset.ofHours(8)).toLocalDateTime();
        return localDateTime.format(dateTimeFormatter);
    }


    /**
     * 将date转换成localdate
     */
    public static LocalDate dateConvertLocalDate(Date date){
        return date.toInstant().atOffset(ZoneOffset.ofHours(8)).toLocalDate();
    }
    /**
     * 将date转换成localDateTime
     */
    public static LocalDateTime dateConvertLocalDateTime(Date date){
        return date.toInstant().atOffset(ZoneOffset.ofHours(8)).toLocalDateTime();
    }
    /**
     * 将localdate转换成date(时分秒为零)
     */
    public static Date localDateConvertDate(LocalDate localDate){
        Instant instant = localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant();
        // 获得 Date
        return Date.from(instant);
    }
    /**
     * 将localDateTime转换成date
     */
    public static Date localDateTimeConvertDate(LocalDateTime localDateTime){
        Instant instant = Instant.ofEpochSecond(localDateTime.toEpochSecond(ZoneOffset.ofHours(8)));
        // 获得 Date
        return Date.from(instant);
    }


    /**
     * 返回当前的日期
     */
    public static LocalDate getCurrentLocalDate() {
        return LocalDate.now();
    }
    /**
     * 返回当前时间
     */
    public static LocalTime getCurrentLocalTime() {
        return LocalTime.now();
    }
    /**
     * 返回当前日期时间
     */
    public static LocalDateTime getCurrentLocalDateTime() {
        return LocalDateTime.now();
    }
    /**
     * 返回当前日期字符串以“yyyy-MM-dd”格式返回
     */
    public static String getCurrentDateStr() {
        return LocalDate.now().format(DATE_FORMATTER);
    }
    /**
     * 返回当前日期字符串以“yyMMdd”格式返回
     */
    public static String getCurrentShortDateStr() {
        return LocalDate.now().format(SHORT_DATE_FORMATTER);
    }
    /**
     * 返回当前日期字符串以“yyyy-MM”格式返回
     */
    public static String getCurrentMonthStr() {
        return LocalDate.now().format(YEAR_MONTH_FORMATTER);
    }
    /**
     * 返回当前日期时间字符串以“yyyy-MM-dd HH:mm:ss”格式返回
     */
    public static String getCurrentDateTimeStr() {
        return LocalDateTime.now().format(DATETIME_FORMATTER);
    }
    /**
     * 返回当前日期时间字符串以“yyyy-MM-dd HH:mm:ss SSS”格式返回
     */
    public static String getCurrentLongDateTimeStr(){
        return LocalDateTime.now().format(LONG_DATETIME_FORMATTER);
    }
    /**
     * 返回当前日期时间字符串以“yyMMddHHmmss”格式返回
     */
    public static String getCurrentShortDateTimeStr() {
        return LocalDateTime.now().format(SHORT_DATETIME_FORMATTER);
    }
    /**
     * 返回当前时间字符串以“HHmmss”格式返回
     */
    public static String getCurrentTimeStr() {
        return LocalTime.now().format(TIME_FORMATTER);
    }
    /**
     * 返回当前时间日期字符串以指定的字符串格式返回
     */
    public static String getCurrentDateTimeStr(String pattern) {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(pattern));
    }
    
    
    /**
     * 将指定日期格式的字符串转为LocalDate
     */
    public static LocalDate parseLocalDate(String dateStr, String pattern) {
        return LocalDate.parse(dateStr, DateTimeFormatter.ofPattern(pattern));
    }
    /**
     * 将指定日期格式的字符串转为LocalDateTime
     */
    public static LocalDateTime parseLocalDateTime(String dateTimeStr, String pattern) {
        return LocalDateTime.parse(dateTimeStr, DateTimeFormatter.ofPattern(pattern));
    }
    /**
     * 将指定日期格式的字符串转为LocalTime
     */
    public static LocalTime parseLocalTime(String timeStr, String pattern) {
        return LocalTime.parse(timeStr, DateTimeFormatter.ofPattern(pattern));
    }
    /**
     * 将LocalTime转为指定日期格式的字符串
     */
    public static String formatLocalDate(LocalDate date, String pattern) {
        return date.format(DateTimeFormatter.ofPattern(pattern));
    }
    /**
     * 将LocalDateTime转为指定日期格式的字符串
     */
    public static String formatLocalDateTime(LocalDateTime datetime, String pattern) {
        return datetime.format(DateTimeFormatter.ofPattern(pattern));
    }
    /**
     * 将LocalTime转为指定日期格式的字符串
     */
    public static String formatLocalTime(LocalTime time, String pattern) {
        return time.format(DateTimeFormatter.ofPattern(pattern));
    }
    /**
     * 将LocalTime转为指定日期格式的字符串
     */
    public static LocalDate formatLocalDate(String dateStr,DateTimeFormatter dateTimeFormatter) {
        return LocalDate.parse(dateStr, dateTimeFormatter);
    }
    /**
     * 将LocalDateTime转为指定日期格式的字符串
     */
    public static LocalDateTime formatLocalDateTime(String dateTimeStr,DateTimeFormatter dateTimeFormatter) {
        return LocalDateTime.parse(dateTimeStr, dateTimeFormatter);
    }
    /**
     * 将LocalTime转为指定日期格式的字符串
     */
    public static LocalTime formatLocalTime(String longDateTimeStr,DateTimeFormatter dateTimeFormatter){
        return LocalTime.parse(longDateTimeStr, dateTimeFormatter);
    }


    /**
     * 两个日期相隔秒数
     */
    public static long periodHours(LocalDateTime startDateTime,LocalDateTime endDateTime){
        return Duration.between(startDateTime, endDateTime).get(ChronoUnit.SECONDS);
    }
    /**
     * 两个日期相隔天数
     */
    public static long periodDays(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.DAYS);
    }
    /**
     * 两个日期相隔周数
     */
    public static long periodWeeks(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.WEEKS);
    }
    /**
     * 两个日期相隔月数
     */
    public static long periodMonths(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.MONTHS);
    }
    /**
     * 两个日期相隔年数
     */
    public static long periodYears(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.YEARS);
    }


    /**
     * 是否当天
     */
    public static boolean isToday(LocalDate date) {
        return getCurrentLocalDate().equals(date);
    }
    /**
     * 根据LocalDateTime获取时间日期的毫秒数
     */
    public static Long localDateTimeToEpochMilli(LocalDateTime dateTime) {
        return dateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
    }
    /**
     * 根据时间毫秒数获取LocalDateTime
     */
    public static LocalDateTime epochMilliToLocalDateTime(Long timeMillis) {
        return (new Timestamp(timeMillis)).toLocalDateTime();
    }
    /**
     * 根据LocalDateTime获取Timestamp
     */
    public static Timestamp localDateTimeToTimestamp(LocalDateTime dateTime) {
        return new Timestamp(dateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());
    }
    /**
     * 根据Timestamp获取LocalDateTime
     */
    public static LocalDateTime localDateTimeToTimestamp(Timestamp timestamp) {
        return timestamp.toLocalDateTime();
    }
    /**
     * 判断是否为闰年
     */
    public static boolean isLeapYear(LocalDate localDate){
        return localDate.isLeapYear();
    }
    /**
     * 判断时间A是否在时间B之前
     */
    public static boolean isBefore(LocalDateTime localDateTimeA,LocalDateTime localDateTimeB){
        return localDateTimeA.isBefore(localDateTimeB);
    }
    /**
     * 判断时间A是否在时间B之后
     */
    public static boolean isAfter(LocalDateTime localDateTimeA,LocalDateTime localDateTimeB){
        return localDateTimeA.isAfter(localDateTimeB);
    }
    /**
     * 根据合同开始时间和合同年限获取合同结束时间（整数年）
     */
    public static LocalDateTime getContractEndTimeByYear(LocalDateTime startTime,long years){
        return startTime.plusYears(years).minusSeconds(1);
    }
    /**
     * 根据合同开始时间和合同年限获取合同结束时间(非整数年)
     */
    public static LocalDateTime getContractEndTimeByMonth(LocalDateTime startTime,long monthValues){
        return startTime.plusMonths(monthValues).minusSeconds(1);
    }
}

时间相应注解

将返回时间转为指定字符串格式

@JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”, timezone = “GMT+8”)

时间入参格式化

@DateTimeFormat(pattern = “yyyy-MM-dd”)

@DateTimeFormat(pattern = “yyyy-MM-dd HH:mm:ss”)