LocalDateTime工具类篇

TimeFormatEnum

import lombok.Getter;

import java.time.format.DateTimeFormatter;

/**
 * 描述 : 时间格式化类型枚举类.
 *
 * 
说明：
 * 1. TimeFormatEnum.LONG_DATE_PATTERN_LINE.formatter; // 获取默认时间格式: yyyy-MM-dd HH:mm:ss
 * 2. 对于LocalDate，只能指定短时间格式化类型，否则会出现UnsupportedTemporalTypeException异常
 * 3. 当日期字符串格式与指定的{@link TimeFormatEnum}格式无法对应时，则会出现DateTimeParseException异常
 *
 * @author : MoCha
 * @version : v1
 * @date : 2021-02-14 09:04
 */
@Getter
public enum TimeFormatEnum {
    /* ---------------- 短时间格式 -------------- */

    /**
     * 短时间格式 yyyy-MM-dd.
     */
    SHORT_DATE_PATTERN_LINE("yyyy-MM-dd"),

    /**
     * 短时间格式 yyyy/MM/dd.
     */
    SHORT_DATE_PATTERN_SLASH("yyyy/MM/dd"),

    /**
     * 短时间格式 yyyy\MM\dd.
     */
    SHORT_DATE_PATTERN_BACK_SLASH("yyyy\\MM\\dd"),

    /**
     * 短时间格式 yyyyMMdd.
     */
    SHORT_DATE_PATTERN_NONE("yyyyMMdd"),

    /* ---------------- 长时间格式 -------------- */

    /**
     * 长时间格式 yyyy-MM-dd HH:mm:ss.
     */
    LONG_DATE_PATTERN_LINE("yyyy-MM-dd HH:mm:ss"),

    /**
     * 长时间格式 yyyy/MM/dd HH:mm:ss.
     */
    LONG_DATE_PATTERN_SLASH("yyyy/MM/dd HH:mm:ss"),

    /**
     * 长时间格式 yyyy\MM\dd HH:mm:ss.
     */
    LONG_DATE_PATTERN_BACK_SLASH("yyyy\\MM\\dd HH:mm:ss"),

    /**
     * 长时间格式 yyyyMMdd HH:mm:ss.
     */
    LONG_DATE_PATTERN_NONE("yyyyMMdd HH:mm:ss"),

    /**
     * 长时间格式 yyyyMMddHHmmss.
     */
    LONG_DATE_PATTERN_WITH_NONE("yyyyMMddHHmmss"),

    /* ---------------- 长时间格式 带毫秒 -------------- */

    /**
     * 长时间格式 带毫秒 yyyy-MM-dd HH:mm:ss.SSS .
     */
    LONG_DATE_PATTERN_WITH_MISC_LINE("yyyy-MM-dd HH:mm:ss.SSS"),

    /**
     * 长时间格式 带毫秒 yyyy/MM/dd HH:mm:ss.SSS .
     */
    LONG_DATE_PATTERN_WITH_MISC_SLASH("yyyy/MM/dd HH:mm:ss.SSS"),

    /**
     * 长时间格式 带毫秒 yyyy\MM\dd HH:mm:ss.SSS .
     */
    LONG_DATE_PATTERN_WITH_MISC_BACK_SLASH("yyyy\\MM\\dd HH:mm:ss.SSS"),

    /**
     * 长时间格式 带毫秒 yyyyMMdd HH:mm:ss.SSS .
     */
    LONG_DATE_PATTERN_WITH_MISC_NONE("yyyyMMdd HH:mm:ss.SSS");

    /**
     * 时间格式化器.
     */
    private final DateTimeFormatter formatter;

    TimeFormatEnum(String pattern) {
        formatter = DateTimeFormatter.ofPattern(pattern);
    }

    /**
     * 判断是否为短时间格式类型
     *
     * 
说明：
     * 1. 判断的界限以{@link TimeFormatEnum#SHORT_DATE_PATTERN_NONE}为参考
     *
     * @param timeFormatEnum 时间格式化类型
     * @return true表示为短时间格式化类型
     */
    public static boolean isShortDatePattern(TimeFormatEnum timeFormatEnum) {
        return timeFormatEnum.ordinal() <= SHORT_DATE_PATTERN_NONE.ordinal();
    }
}

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

LocalDateTimeUtils

import org.springframework.util.Assert;

import java.time.*;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

/**
 * 描述 : LocalDate工具类.
 *
 * @author : MoCha
 * @version : v1
 * @date : 2021-02-13 17:00
 */
public final class LocalDateUtils {
    /**
     * Prevents instantiation.
     */
    private LocalDateUtils() {
    }

    /* ---------------- 时间戳相关方法 -------------- */

    /**
     * 当前LocalDate 转 时间戳（秒级别）
     *
     * @return 时间戳（秒级别）
     */
    public static Long toNowSecond() {
        return toSecond(LocalDate.now());
    }

    /**
     * 当前LocalDate 转 时间戳（毫秒级别）
     *
     * @return 时间戳（毫秒级别）
     */
    public static Long toNowMilliseconds() {
        return toMilliseconds(LocalDate.now());
    }

    /**
     * LocalDate 转 时间戳(秒级别).
     *
     * @param localDate 日期对象
     * @return 时间戳（秒级别）
     */
    public static Long toSecond(LocalDate localDate) {
        return localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant().getEpochSecond();
    }

    /**
     * LocalDate 转 时间戳(毫秒级别).
     *
     * @param localDate 日期对象
     * @return 时间戳（毫秒级别）
     */
    public static Long toMilliseconds(LocalDate localDate) {
        return localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant().toEpochMilli();
    }

    /**
     * 时间戳(秒级别) 转 LocalDate.
     *
     * @param timestamp 时间戳(秒级别)
     * @return 日期对象
     */
    public static LocalDate ofSecond(Long timestamp) {
        return Instant.ofEpochSecond(timestamp).atZone(ZoneOffset.ofHours(8)).toLocalDate();
    }

    /**
     * 时间戳(毫秒级别) 转 LocalDate.
     *
     * @param timestamp 时间戳(毫秒级别)
     * @return 日期对象
     */
    public static LocalDate ofMilliseconds(Long timestamp) {
        return Instant.ofEpochMilli(timestamp).atZone(ZoneOffset.ofHours(8)).toLocalDate();
    }

    /**
     * 获取指定日期开始时间点（凌晨零点）的时间戳（秒级别）.
     *
     * @return 指定日期开始时间点的时间戳（秒级别）
     */
    public static long getTodayStartTimeStamp(LocalDate localDate) {
        return LocalDateTime.of(localDate, LocalTime.MIN).toEpochSecond(ZoneOffset.ofHours(8));
    }

    /**
     * 获取指定日期结束时间点（夜晚23点59分59秒）的时间戳（秒级别）.
     *
     * @return 指定日期结束时间点的时间戳（秒级别）
     */
    public static long getTodayEndTimeStamp(LocalDate localDate) {
        return LocalDateTime.of(localDate, LocalTime.MAX).toEpochSecond(ZoneOffset.ofHours(8));
    }

    /* ---------------- 格式化日期对象相关方法 -------------- */

    /**
     * 根据时间戳返回短时间格式化日期对象 .
     *
     * @param timestamp 日期时间戳
     * @return 日期对象格式化值
     */
    public static String formatShortDatePatternLine(Long timestamp) {
        return formatShortDatePatternLine(ofMilliseconds(timestamp));
    }

    /**
     * 短时间格式化日期对象 格式：yyyy-MM-dd {@link TimeFormatEnum#SHORT_DATE_PATTERN_LINE}.
     *
     * @param localDate 日期对象
     * @return 日期对象格式化值
     */
    public static String formatShortDatePatternLine(LocalDate localDate) {
        return TimeFormatEnum.SHORT_DATE_PATTERN_LINE.getFormatter().format(localDate);
    }

    /**
     * 短时间格式化日期对象 格式：yyyyMMdd.
     *
     * @param localDate 日期对象
     * @return 日期对象格式化值
     */
    public static String formatShortDatePatternNone(LocalDate localDate) {
        return TimeFormatEnum.SHORT_DATE_PATTERN_NONE.getFormatter().format(localDate);
    }

    /**
     * 指定格式化类型进行日期对象格式化.
     *
     * 
说明：
     * 1. 对于LocalDate，只能指定短时间格式化类型，否则会出现UnsupportedTemporalTypeException异常
     *
     * @param localDate      日期对象
     * @param timeFormatEnum 格式化类型枚举 {@link TimeFormatEnum}
     * @return 日期对象格式化值
     */
    public static String format(LocalDate localDate, TimeFormatEnum timeFormatEnum) {
        Assert.isTrue(TimeFormatEnum.isShortDatePattern(timeFormatEnum), "对于LocalDate，只能格式化短时间格式的LocalDate");
        return timeFormatEnum.getFormatter().format(localDate);
    }

    /* ---------------- 解析时间字符串相关方法 -------------- */

    /**
     * 解析日期字符串为日期对象 格式：yyyy-MM-dd.
     *
     * @param text 日期字符串 格式：yyyy-MM-dd {@link TimeFormatEnum#SHORT_DATE_PATTERN_LINE}
     * @return 日期对象
     */
    public static LocalDate parseShortDatePatternLine(CharSequence text) {
        return LocalDate.parse(text, TimeFormatEnum.SHORT_DATE_PATTERN_LINE.getFormatter());
    }

    /**
     * 解析日期字符串为日期对象 格式：yyyyMMdd.
     *
     * @param text 日期字符串 格式：yyyyMMdd
     * @return 日期对象
     */
    public static LocalDate parseShortDatePatternNone(CharSequence text) {
        return LocalDate.parse(text, TimeFormatEnum.SHORT_DATE_PATTERN_NONE.getFormatter());
    }

    /**
     * 指定解析类型进行日期字符串解析
     *
     * 
说明：
     * 1. 当日期字符串格式与指定的{@link TimeFormatEnum}格式无法对应时，则会出现DateTimeParseException异常
     * 2. 对于LocalDate，只能解析短时间格式的日期字符串
     *
     * @param text           日期字符串
     * @param timeFormatEnum 格式化类型枚举 {@link TimeFormatEnum}
     * @return 日期对象
     */
    public static LocalDate parse(CharSequence text, TimeFormatEnum timeFormatEnum) {
        Assert.isTrue(TimeFormatEnum.isShortDatePattern(timeFormatEnum), "对于LocalDate，只能解析短时间格式的日期字符串");
        return LocalDate.parse(text, timeFormatEnum.getFormatter());
    }

    /* ---------------- 与业务场景相关的方法 -------------- */

    /**
     * 获取指定日期上一个月的最后一天.
     *
     * @return 日期对象
     */
    public static LocalDate getPreviousMonthLastDay(LocalDate localDate) {
        return localDate.minusMonths(1).with(TemporalAdjusters.lastDayOfMonth());
    }

    /**
     * 获取指定日期所在月份的第一个周几.
     *
     * 
说明：
     * 1. 如果想要获取当前日期所在月份的第一个周几，第一个入参设置为LocalDate.now()
     * 2. DayOfWeek可选值，通常使用MONDAY，TUESDAY，WEDNESDAY，THURSDAY，FRIDAY，SATURDAY，SUNDAY
     *
     * 
例如：
     * LocalDateUtils.getFirstDayOfWeek(LocalDate.now(), DayOfWeek.THURSDAY)
     *
     * @param localDate 指定日期对象
     * @param dayOfWeek 周几（周一、周二、周三...、周天）
     * @return 第一个周几的LocalDate日期对象
     */
    public static LocalDate getFirstDayOfWeek(LocalDate localDate, DayOfWeek dayOfWeek) {
        return localDate.with(TemporalAdjusters.firstInMonth(dayOfWeek));
    }

    /**
     * 获取当前月份的第一天.
     *
     * @return 当前月份的第一天日期对象
     */
    public static LocalDate getFirstDayOfCurrentMonth() {
        return LocalDate.now().with(TemporalAdjusters.firstDayOfMonth());
    }

    /**
     * 获取当前月份的最后一天.
     *
     * @return 当前月份的最后一天日期对象
     */
    public static LocalDate getLastDayOfCurrentMonth() {
        return LocalDate.now().with(TemporalAdjusters.lastDayOfMonth());
    }

    /**
     * 获取两个日期字符串之间的日期时间戳集.
     *
     * 
说明：
     * 1. 时间戳仅考虑年月日，不带时分秒
     *
     * 
示例：
     * getBetweenTimeStampShortDatePatternNone("20210626", "20210712")
     *
     * @param startText 开始日期字符串；须为短时间格式，即不带时分秒
     * @param endText   结束日期字符串；须为短时间格式，即不带时分秒
     * @return 两个日期字符串之间的日期时间戳集
     */
    public static List<Long> getBetweenTimeStampShortDatePatternNone(CharSequence startText, CharSequence endText) {
        List<Long> betweenTimeStampList = new ArrayList<>();
        LocalDate startDate = parse(startText, TimeFormatEnum.SHORT_DATE_PATTERN_NONE);
        LocalDate endDate = parse(endText, TimeFormatEnum.SHORT_DATE_PATTERN_NONE);

        long distance = getBetweenDays(startDate, endDate);
        if (distance < 1) {
            return betweenTimeStampList;
        }

        Stream.iterate(startDate, date -> date.plusDays(1))
                .limit(distance + 1)
                .forEach(localDate -> betweenTimeStampList.add(toMilliseconds(localDate)));
        return betweenTimeStampList;
    }

    /**
     * 获取两个日期字符串之间的日期字符串集.
     *
     * 
说明：
     * 1. 日期列表为短时间格式 yyyyMMdd
     *
     * 
示例：
     * getBetweenDateTextShortDatePatternNone("20210626", "20210712")
     *
     * @param startText 开始日期字符串；须为短时间格式，即不带时分秒
     * @param endText   结束日期字符串；须为短时间格式，即不带时分秒
     * @return 两个日期字符串之间的日期字符串集
     */
    public static List<String> getBetweenDateTextShortDatePatternNone(CharSequence startText, CharSequence endText) {
        return getBetweenDateText(startText, endText, TimeFormatEnum.SHORT_DATE_PATTERN_NONE);
    }

    /**
     * 获取两个日期字符串之间的日期字符串集.
     *
     * 
示例：
     * getBetweenDateText("20210626", "20210712", TimeFormatEnum.SHORT_DATE_PATTERN_NONE)
     *
     * @param startText      开始日期字符串；须为短时间格式，即不带时分秒
     * @param endText        结束日期字符串；须为短时间格式，即不带时分秒
     * @param timeFormatEnum 时间格式化类型枚举类；须为短时间格式枚举类
     * @return 两个日期字符串之间的日期字符串集
     */
    public static List<String> getBetweenDateText(CharSequence startText, CharSequence endText, TimeFormatEnum timeFormatEnum) {
        List<String> betweenDateTextList = new ArrayList<>();
        LocalDate startDate = parse(startText, timeFormatEnum);
        LocalDate endDate = parse(endText, timeFormatEnum);

        long distance = ChronoUnit.DAYS.between(startDate, endDate);
        if (distance < 1) {
            return betweenDateTextList;
        }

        Stream.iterate(startDate, date -> date.plusDays(1))
                .limit(distance + 1)
                .forEach(localDate -> betweenDateTextList.add(format(localDate, timeFormatEnum)));
        return betweenDateTextList;
    }

    /**
     * 计算两个时间戳间隔的天数.
     *
     * 
说明：时间戳仅考虑年月日，不带时分秒
     *
     * @param startTimeStamp 开始时间戳
     * @param endTimeStamp   结束时间戳
     * @return 间隔天数
     */
    public static Long getBetweenDays(Long startTimeStamp, Long endTimeStamp) {
        LocalDate startLocalDate = ofMilliseconds(startTimeStamp);
        LocalDate endLocalDate = ofMilliseconds(endTimeStamp);
        return getBetweenDays(startLocalDate, endLocalDate);
    }

    /**
     * 计算两个日期对象间隔的天数.
     *
     * @param startDate 起始日期对象
     * @param endDate   结束日期对象
     * @return 两个日期对象间隔的天数
     */
    public static Long getBetweenDays(LocalDate startDate, LocalDate endDate) {
        return startDate.until(endDate, ChronoUnit.DAYS);
    }

    /* ---------------- 季度相关的方法 -------------- */

    /**
     * 获取当前年份季度中文描述.
     *
     * @return 返回示例：2021年第一季度
     */
    public static String getNowYearQuarterlyDesc() {
        switch (getNowQuarterEnum()) {
            case FIRST:
                return LocalDate.now().getYear() + "年第一季度";
            case SECOND:
                return LocalDate.now().getYear() + "年第二季度";
            case THIRD:
                return LocalDate.now().getYear() + "年第三季度";
            case FOURTH:
                return LocalDate.now().getYear() + "年第四季度";
            default:
                return "";
        }
    }

    /**
     * 获取当前季度值.
     *
     * @return 当前季度值
     */
    public static int getNowQuarterly() {
        return getNowQuarterEnum().getValue();
    }

    /**
     * 查询当前季度枚举类.
     *
     * @return 季度枚举类
     */
    public static QuarterEnum getNowQuarterEnum() {
        return LocalDate.now().query(new QuarterOfYearQuery());
    }

    /**
     * 获取当前时间季度开始时间戳（毫秒级别）.
     *
     * 
说明：时间戳仅考虑年月日，不带时分秒
     *
     * @return 返回当前时间季度开始时间戳
     */
    public static Long getNowQuarterStartTimeStamp() {
        LocalDate nowLocalDate = LocalDate.now();
        Month firstMonthOfQuarter = nowLocalDate.getMonth().firstMonthOfQuarter();
        nowLocalDate = LocalDate.of(nowLocalDate.getYear(), firstMonthOfQuarter, 1);
        return toMilliseconds(nowLocalDate);
    }
}

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
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387