1 package jm.tsc.tsirm.common.helper;
2
3
4 import java.text.SimpleDateFormat;
5 import java.time.*;
6 import java.time.format.DateTimeFormatter;
7 import java.time.temporal.ChronoUnit;
8 import java.time.temporal.TemporalAccessor;
9 import java.time.temporal.TemporalAdjusters;
10 import java.util.ArrayList;
11 import java.util.Calendar;
12 import java.util.Date;
13 import java.util.List;
14
15 /**
16 * @PACKAGE_NAME: jm.tsc.tsirm.common.helper
17 * @NAME: DateUtils
18 * @USER: liul
19 * @TIME: 2022/10/27 10:30
20 * @DAY_NAME_SHORT: 周四
21 */
22 public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
23
24
25 /**
26 * 显示年月日时分秒，例如 2015-08-11 09:51:53.
27 */
28 public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
29
30 /**
31 * 仅显示年月日，例如 2015-08-11.
32 */
33 public static final String DATE_PATTERN = "yyyy-MM-dd";
34
35 /**
36 * 仅显示时分秒，例如 09:51:53.
37 */
38 public static final String TIME_PATTERN = "HH:mm:ss";
39
40 /**
41 * 显示年月日时分秒(无符号)，例如 20150811095153.
42 */
43 public static final String UNSIGNED_DATETIME_PATTERN = "yyyyMMddHHmmss";
44
45 /**
46 * 仅显示年月日(无符号)，例如 20150811.
47 */
48 public static final String UNSIGNED_DATE_PATTERN = "yyyyMMdd";
49
50 /**
51 * 春天;
52 */
53 public static final Integer SPRING = 1;
54
55 /**
56 * 夏天;
57 */
58 public static final Integer SUMMER = 2;
59
60 /**
61 * 秋天;
62 */
63 public static final Integer AUTUMN = 3;
64
65 /**
66 * 冬天;
67 */
68 public static final Integer WINTER = 4;
69
70 /**
71 * 星期日;
72 */
73 public static final String SUNDAY = "星期日";
74
75 /**
76 * 星期一;
77 */
78 public static final String MONDAY = "星期一";
79
80 /**
81 * 星期二;
82 */
83 public static final String TUESDAY = "星期二";
84
85 /**
86 * 星期三;
87 */
88 public static final String WEDNESDAY = "星期三";
89
90 /**
91 * 星期四;
92 */
93 public static final String THURSDAY = "星期四";
94
95 /**
96 * 星期五;
97 */
98 public static final String FRIDAY = "星期五";
99
100 /**
101 * 星期六;
102 */
103 public static final String SATURDAY = "星期六";
104
105 /**
106 * 年
107 */
108 private static final String YEAR = "year";
109
110 /**
111 * 月
112 */
113 private static final String MONTH = "month";
114
115 /**
116 * 周
117 */
118 private static final String WEEK = "week";
119
120 /**
121 * 日
122 */
123 private static final String DAY = "day";
124
125 /**
126 * 时
127 */
128 private static final String HOUR = "hour";
129
130 /**
131 * 分
132 */
133 private static final String MINUTE = "minute";
134
135 /**
136 * 秒
137 */
138 private static final String SECOND = "second";
139
140
141 /**
142 * 获取当前日期和时间字符串.
143 *
144 * @return String 日期时间字符串，例如 2015-08-11 09:51:53
145 */
146 public static String getLocalDateTimeStr() {
147 return format(LocalDateTime.now(), DATETIME_PATTERN);
148 }
149
150 /**
151 * 获取系统当前时间戳
152 *
153 * @return 1566889186583
154 */
155 public static String getSystemTime() {
156 String current = String.valueOf(System.currentTimeMillis());
157 return current;
158 }
159
160
161 /**
162 * 获取当前日期 yy-MM-dd
163 *
164 * @return 2019-08-27
165 */
166 public static String getLocalDateStr() {
167 Date date = new Date();
168 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
169 return sdf.format(date);
170 }
171 /**
172 * 获取当前时间字符串.
173 *
174 * @return String 时间字符串，例如 09:51:53
175 */
176 public static String getLocalTimeStr() {
177 return format(LocalTime.now(), TIME_PATTERN);
178 }
179 /**
180 * 获取当前月份
181 */
182 public static int getNowMonth(Date date) {
183 Calendar calendar = Calendar.getInstance();
184 calendar.setTime(date);
185 return calendar.get(Calendar.MONTH) + 1;
186 }
187
188 /**
189 * 获取当前日
190 */
191 public static int getNowDay(Date date) {
192 Calendar calendar = Calendar.getInstance();
193 calendar.setTime(date);
194 return calendar.get(Calendar.DATE);
195 }
196
197 /**
198 * 获取当前年份
199 */
200 public static int getNowYear(Date date) {
201 Calendar calendar = Calendar.getInstance();
202 calendar.setTime(date);
203 return calendar.get(Calendar.YEAR);
204 }
205
206 /**
207 * 获取本月份的天数
208 */
209 public static int getNowDaysOfMonth() {
210 Calendar calendar = Calendar.getInstance();
211 return daysOfMonth(calendar.get(Calendar.YEAR), calendar.get(Calendar.DATE) + 1);
212 }
213
214 /**
215 * 获取指定月份的天数
216 *
217 * @param year 年份
218 * @param month 月份
219 * @return 对应天数
220 */
221 public static int daysOfMonth(int year, int month) {
222 switch (month) {
223 case 1:
224 case 3:
225 case 5:
226 case 7:
227 case 8:
228 case 10:
229 case 12:
230 return 31;
231 case 4:
232 case 6:
233 case 9:
234 case 11:
235 return 30;
236 case 2:
237 if ((year % 4 == 0 && year % 100 == 0) || year % 400 != 0) {
238 return 29;
239 } else {
240 return 28;
241 }
242 default:
243 return -1;
244 }
245 }
246
247 /**
248 * 获取当前星期字符串.
249 *
250 * @return String 当前星期字符串，例如 星期二
251 */
252 public static String getDayOfWeekStr() {
253 return format(LocalDate.now(), "E");
254 }
255
256 /**
257 * 获取指定日期是星期几
258 *
259 * @param localDate 日期
260 * @return String 星期几
261 */
262 public static String getDayOfWeekStr(LocalDate localDate) {
263 String[] weekOfDays = {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};
264 int dayOfWeek = localDate.getDayOfWeek().getValue() - 1;
265 return weekOfDays[dayOfWeek];
266 }
267
268 /**
269 * 获取日期时间字符串
270 *
271 * @param temporal 需要转化的日期时间 可传入LocalDate
272 * @param pattern 时间格式
273 * @return String 日期时间字符串，例如 2015-08-11 09:51:53
274 */
275 public static String format(TemporalAccessor temporal, String pattern) {
276 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
277 return dateTimeFormatter.format(temporal);
278 }
279
280 /**
281 * 获取指定日期前一天
282 *
283 * @return 2019-08-26
284 */
285 public static String getBeforeDay(Date date) {
286
287 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
288 Calendar calendar = Calendar.getInstance();
289 calendar.setTime(date);
290 calendar.add(Calendar.DAY_OF_MONTH, -1);
291 date = calendar.getTime();
292 return sdf.format(date);
293 }
294
295 /**
296 * 获取指定日期往前最近七天
297 *
298 * @param date 指定时间
299 * @return
300 */
301 public static String getServen(Date date) {
302 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
303 Calendar c = Calendar.getInstance();
304 c.setTime(date);
305 c.add(Calendar.DATE, -7);
306 Date monday = c.getTime();
307 String preMonday = sdf.format(monday);
308 return preMonday;
309 }
310
311 /**
312 * 获取最近一个月
313 *
314 * @param date 指定时间
315 * @return
316 */
317 public static String getOneMonth(Date date) {
318 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
319 Calendar c = Calendar.getInstance();
320 c.setTime(date);
321 c.add(Calendar.MONTH, -1);
322 Date monday = c.getTime();
323 String preMonday = sdf.format(monday);
324 return preMonday;
325 }
326
327 /**
328 * 获取最近三个月
329 *
330 * @param date 指定时间
331 * @return
332 */
333 public static String getThreeMonth(Date date) {
334 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
335 Calendar c = Calendar.getInstance();
336 c.setTime(date);
337 c.add(Calendar.MONTH, -3);
338 Date monday = c.getTime();
339 String preMonday = sdf.format(monday);
340 return preMonday;
341 }
342
343
344 /**
345 * 获取最近一年
346 *
347 * @param date 指定时间
348 * @return
349 */
350 public static String getOneYear(Date date) {
351 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
352 Calendar c = Calendar.getInstance();
353 c.setTime(date);
354 c.add(Calendar.YEAR, -1);
355 Date start = c.getTime();
356 String startDay = sdf.format(start);
357 return startDay;
358 }
359
360 /**
361 * 日期时间字符串转换为日期时间(java.time.LocalDateTime)
362 *
363 * @param localDateTimeStr 日期时间字符串
364 * @param pattern 日期时间格式 例如DATETIME_PATTERN
365 * @return LocalDateTime 日期时间
366 */
367 public static LocalDateTime parseLocalDateTime(String localDateTimeStr, String pattern) {
368 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
369 return LocalDateTime.parse(localDateTimeStr, dateTimeFormatter);
370 }
371
372 /**
373 * 日期字符串转换为日期(java.time.LocalDate)
374 *
375 * @param localDateStr 日期字符串
376 * @param pattern 日期格式 例如DATE_PATTERN
377 * @return LocalDate 日期
378 */
379 public static LocalDate parseLocalDate(String localDateStr, String pattern) {
380 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern);
381 return LocalDate.parse(localDateStr, dateTimeFormatter);
382 }
383
384 /**
385 * 获取指定日期时间加上指定数量日期时间单位之后的日期时间.
386 *
387 * @param localDateTime 日期时间
388 * @param num 数量
389 * @param chronoUnit 日期时间单位
390 * @return LocalDateTime 新的日期时间
391 */
392 public static LocalDateTime plus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) {
393 return localDateTime.plus(num, chronoUnit);
394 }
395
396 /**
397 * 获取指定日期时间减去指定数量日期时间单位之后的日期时间.
398 *
399 * @param localDateTime 日期时间
400 * @param num 数量
401 * @param chronoUnit 日期时间单位
402 * @return LocalDateTime 新的日期时间
403 */
404 public static LocalDateTime minus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) {
405 return localDateTime.minus(num, chronoUnit);
406 }
407
408 /**
409 * 根据ChronoUnit计算两个日期时间之间相隔日期时间
410 *
411 * @param start 开始日期时间
412 * @param end 结束日期时间
413 * @param chronoUnit 日期时间单位
414 * @return long 相隔日期时间
415 */
416 public static long getChronoUnitBetween(LocalDateTime start, LocalDateTime end, ChronoUnit chronoUnit) {
417 return Math.abs(start.until(end, chronoUnit));
418 }
419
420 /**
421 * 根据ChronoUnit计算两个日期之间相隔年数或月数或天数
422 *
423 * @param start 开始日期
424 * @param end 结束日期
425 * @param chronoUnit 日期时间单位,(ChronoUnit.YEARS,ChronoUnit.MONTHS,ChronoUnit.WEEKS,ChronoUnit.DAYS)
426 * @return long 相隔年数或月数或天数
427 */
428 public static long getChronoUnitBetween(LocalDate start, LocalDate end, ChronoUnit chronoUnit) {
429 return Math.abs(start.until(end, chronoUnit));
430 }
431
432 /**
433 * 获取本年第一天的日期字符串
434 *
435 * @return String 格式：yyyy-MM-dd 00:00:00
436 */
437 public static String getFirstDayOfYearStr() {
438 return getFirstDayOfYearStr(LocalDateTime.now());
439 }
440
441 /**
442 * 获取本年最后一天的日期字符串
443 *
444 * @return String 格式：yyyy-MM-dd 23:59:59
445 */
446 public static String getLastDayOfYearStr() {
447 return getLastDayOfYearStr(LocalDateTime.now());
448 }
449
450 /**
451 * 获取指定日期当年第一天的日期字符串
452 *
453 * @param localDateTime 指定日期时间
454 * @return String 格式：yyyy-MM-dd 00:00:00
455 */
456 public static String getFirstDayOfYearStr(LocalDateTime localDateTime) {
457 return getFirstDayOfYearStr(localDateTime, DATETIME_PATTERN);
458 }
459
460 /**
461 * 获取指定日期当年最后一天的日期字符串
462 *
463 * @param localDateTime 指定日期时间
464 * @return String 格式：yyyy-MM-dd 23:59:59
465 */
466 public static String getLastDayOfYearStr(LocalDateTime localDateTime) {
467 return getLastDayOfYearStr(localDateTime, DATETIME_PATTERN);
468 }
469
470 /**
471 * 获取指定日期当年第一天的日期字符串,带日期格式化参数
472 *
473 * @param localDateTime 指定日期时间
474 * @param pattern 日期时间格式
475 * @return String 格式：yyyy-MM-dd 00:00:00
476 */
477 public static String getFirstDayOfYearStr(LocalDateTime localDateTime, String pattern) {
478 return format(localDateTime.withDayOfYear(1).withHour(0).withMinute(0).withSecond(0), pattern);
479 }
480
481 /**
482 * 获取指定日期当年最后一天的日期字符串,带日期格式化参数
483 *
484 * @param localDateTime 指定日期时间
485 * @param pattern 日期时间格式
486 * @return String 格式：yyyy-MM-dd 23:59:59
487 */
488 public static String getLastDayOfYearStr(LocalDateTime localDateTime, String pattern) {
489 return format(localDateTime.with(TemporalAdjusters.lastDayOfYear()).withHour(23).withMinute(59).withSecond(59), pattern);
490 }
491
492 /**
493 * 获取本月第一天的日期字符串
494 *
495 * @return String 格式：yyyy-MM-dd 00:00:00
496 */
497 public static String getFirstDayOfMonthStr() {
498 return getFirstDayOfMonthStr(LocalDateTime.now());
499 }
500
501 /**
502 * 获取本月最后一天的日期字符串
503 *
504 * @return String 格式：yyyy-MM-dd 23:59:59
505 */
506 public static String getLastDayOfMonthStr() {
507 return getLastDayOfMonthStr(LocalDateTime.now());
508 }
509
510 /**
511 * 获取指定日期当月第一天的日期字符串
512 *
513 * @param localDateTime 指定日期时间
514 * @return String 格式：yyyy-MM-dd 23:59:59
515 */
516 public static String getFirstDayOfMonthStr(LocalDateTime localDateTime) {
517 return getFirstDayOfMonthStr(localDateTime, DATETIME_PATTERN);
518 }
519
520 /**
521 * 获取指定日期当月最后一天的日期字符串
522 *
523 * @param localDateTime 指定日期时间
524 * @return String 格式：yyyy-MM-dd 23:59:59
525 */
526 public static String getLastDayOfMonthStr(LocalDateTime localDateTime) {
527 return getLastDayOfMonthStr(localDateTime, DATETIME_PATTERN);
528 }
529
530 /**
531 * 获取指定日期当月第一天的日期字符串,带日期格式化参数
532 *
533 * @param localDateTime 指定日期时间
534 * @return String 格式：yyyy-MM-dd 00:00:00
535 */
536 public static String getFirstDayOfMonthStr(LocalDateTime localDateTime, String pattern) {
537 return format(localDateTime.withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0), pattern);
538 }
539
540 /**
541 * 获取指定日期当月最后一天的日期字符串,带日期格式化参数
542 *
543 * @param localDateTime 指定日期时间
544 * @param pattern 日期时间格式
545 * @return String 格式：yyyy-MM-dd 23:59:59
546 */
547 public static String getLastDayOfMonthStr(LocalDateTime localDateTime, String pattern) {
548 return format(localDateTime.with(TemporalAdjusters.lastDayOfMonth()).withHour(23).withMinute(59).withSecond(59), pattern);
549 }
550
551 /**
552 * 获取本周第一天的日期字符串
553 *
554 * @return String 格式：yyyy-MM-dd 00:00:00
555 */
556 public static String getFirstDayOfWeekStr() {
557 return getFirstDayOfWeekStr(LocalDateTime.now());
558 }
559
560 /**
561 * 获取本周最后一天的日期字符串
562 *
563 * @return String 格式：yyyy-MM-dd 23:59:59
564 */
565 public static String getLastDayOfWeekStr() {
566 return getLastDayOfWeekStr(LocalDateTime.now());
567 }
568
569 /**
570 * 获取指定日期当周第一天的日期字符串,这里第一天为周一
571 *
572 * @param localDateTime 指定日期时间
573 * @return String 格式：yyyy-MM-dd 00:00:00
574 */
575 public static String getFirstDayOfWeekStr(LocalDateTime localDateTime) {
576 return getFirstDayOfWeekStr(localDateTime, DATETIME_PATTERN);
577 }
578
579 /**
580 * 获取指定日期当周最后一天的日期字符串,这里最后一天为周日
581 *
582 * @param localDateTime 指定日期时间
583 * @return String 格式：yyyy-MM-dd 23:59:59
584 */
585 public static String getLastDayOfWeekStr(LocalDateTime localDateTime) {
586 return getLastDayOfWeekStr(localDateTime, DATETIME_PATTERN);
587 }
588
589 /**
590 * 获取指定日期当周第一天的日期字符串,这里第一天为周一,带日期格式化参数
591 *
592 * @param localDateTime 指定日期时间
593 * @param pattern 日期时间格式
594 * @return String 格式：yyyy-MM-dd 00:00:00
595 */
596 public static String getFirstDayOfWeekStr(LocalDateTime localDateTime, String pattern) {
597 return format(localDateTime.with(DayOfWeek.MONDAY).withHour(0).withMinute(0).withSecond(0), pattern);
598 }
599
600 /**
601 * 获取指定日期当周最后一天的日期字符串,这里最后一天为周日,带日期格式化参数
602 *
603 * @param localDateTime 指定日期时间
604 * @param pattern 日期时间格式
605 * @return String 格式：yyyy-MM-dd 23:59:59
606 */
607 public static String getLastDayOfWeekStr(LocalDateTime localDateTime, String pattern) {
608 return format(localDateTime.with(DayOfWeek.SUNDAY).withHour(23).withMinute(59).withSecond(59), pattern);
609 }
610
611 /**
612 * 获取今天开始时间的日期字符串
613 *
614 * @return String 格式：yyyy-MM-dd 00:00:00
615 */
616 public static String getStartTimeOfDayStr() {
617 return getStartTimeOfDayStr(LocalDateTime.now());
618 }
619
620 /**
621 * 获取今天结束时间的日期字符串
622 *
623 * @return String 格式：yyyy-MM-dd 23:59:59
624 */
625 public static String getEndTimeOfDayStr() {
626 return getEndTimeOfDayStr(LocalDateTime.now());
627 }
628
629 /**
630 * 获取指定日期开始时间的日期字符串
631 *
632 * @param localDateTime 指定日期时间
633 * @return String 格式：yyyy-MM-dd 00:00:00
634 */
635 public static String getStartTimeOfDayStr(LocalDateTime localDateTime) {
636 return getStartTimeOfDayStr(localDateTime, DATETIME_PATTERN);
637 }
638
639 /**
640 * 获取指定日期结束时间的日期字符串
641 *
642 * @param localDateTime 指定日期时间
643 * @return String 格式：yyyy-MM-dd 23:59:59
644 */
645 public static String getEndTimeOfDayStr(LocalDateTime localDateTime) {
646 return getEndTimeOfDayStr(localDateTime, DATETIME_PATTERN);
647 }
648
649 /**
650 * 获取指定日期开始时间的日期字符串,带日期格式化参数
651 *
652 * @param localDateTime 指定日期时间
653 * @param pattern 日期时间格式
654 * @return String 格式：yyyy-MM-dd HH:mm:ss
655 */
656 public static String getStartTimeOfDayStr(LocalDateTime localDateTime, String pattern) {
657 return format(localDateTime.withHour(0).withMinute(0).withSecond(0), pattern);
658 }
659
660 /**
661 * 获取指定日期结束时间的日期字符串,带日期格式化参数
662 *
663 * @param localDateTime 指定日期时间
664 * @param pattern 日期时间格式
665 * @return String 格式：yyyy-MM-dd 23:59:59
666 */
667 public static String getEndTimeOfDayStr(LocalDateTime localDateTime, String pattern) {
668 return format(localDateTime.withHour(23).withMinute(59).withSecond(59), pattern);
669 }
670
671 public static String dayComparePrecise(Date fromDate, Date toDate){
672 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
673 if(fromDate==null||toDate==null){
674 return "不足一个月";
675 }
676 Period period = Period.between(LocalDate.parse(format.format(fromDate)), LocalDate.parse(format.format(toDate)));
677
678 StringBuffer sb = new StringBuffer();
679 if(period.getYears()>0){
680 sb.append(period.getYears()).append("年");
681 }
682 if(period.getMonths()>0) {
683 sb.append(period.getMonths()).append("个月");
684 }
685 if(period.getYears()<=0&&period.getMonths()<=0){
686 sb.append("不足一个月");
687 }
688 return sb.toString();
689 }
690
691 /**
692 * Date转LocalDateTime类型
693 * localDateTime.toLocalDate();
694 * ocalDateTime.toLocalDate();
695 *
696 * @param date 指定日期
697 * @return
698 */
699 public static LocalDateTime dataToLocalDatetime(Date date){
700 if(date==null){
701 return null;
702 }
703 Instant instant = date.toInstant();
704 ZoneId zone = ZoneId.systemDefault();
705 //Date转换为LocalDateTime
706 LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
707 return localDateTime;
708 }
709
710 /**
711 * 切割日期。按照周期切割成小段日期段。例如： <br>
712 *
713 * @param startDate 开始日期（yyyy-MM-dd）
714 * @param endDate 结束日期（yyyy-MM-dd）
715 * @param period 周期（天，周，月，年）
716 * @return 切割之后的日期集合
717 * <li>startDate="2019-02-28",endDate="2019-03-05",period="day"</li>
718 * <li>结果为：[2019-02-28, 2019-03-01, 2019-03-02, 2019-03-03, 2019-03-04, 2019-03-05]</li><br>
719 * <li>startDate="2019-02-28",endDate="2019-03-25",period="week"</li>
720 * <li>结果为：[2019-02-28,2019-03-06, 2019-03-07,2019-03-13, 2019-03-14,2019-03-20,
721 * 2019-03-21,2019-03-25]</li><br>
722 * <li>startDate="2019-02-28",endDate="2019-05-25",period="month"</li>
723 * <li>结果为：[2019-02-28,2019-02-28, 2019-03-01,2019-03-31, 2019-04-01,2019-04-30,
724 * 2019-05-01,2019-05-25]</li><br>
725 * <li>startDate="2019-02-28",endDate="2020-05-25",period="year"</li>
726 * <li>结果为：[2019-02-28,2019-12-31, 2020-01-01,2020-05-25]</li><br>
727 */
728 public static List<String> listDateStrs(String startDate, String endDate, String period) {
729 List<String> result = new ArrayList<>();
730 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DATE_PATTERN);
731 LocalDate end = LocalDate.parse(endDate, dateTimeFormatter);
732 LocalDate start = LocalDate.parse(startDate, dateTimeFormatter);
733 LocalDate tmp = start;
734 switch (period) {
735 case DAY:
736 while (start.isBefore(end) || start.isEqual(end)) {
737 result.add(start.toString());
738 start = start.plusDays(1);
739 }
740 break;
741 case WEEK:
742 while (tmp.isBefore(end) || tmp.isEqual(end)) {
743 if (tmp.plusDays(6).isAfter(end)) {
744 result.add(tmp.toString() + "," + end);
745 } else {
746 result.add(tmp.toString() + "," + tmp.plusDays(6));
747 }
748 tmp = tmp.plusDays(7);
749 }
750 break;
751 case MONTH:
752 while (tmp.isBefore(end) || tmp.isEqual(end)) {
753 LocalDate lastDayOfMonth = tmp.with(TemporalAdjusters.lastDayOfMonth());
754 if (lastDayOfMonth.isAfter(end)) {
755 result.add(tmp.toString() + "," + end);
756 } else {
757 result.add(tmp.toString() + "," + lastDayOfMonth);
758 }
759 tmp = lastDayOfMonth.plusDays(1);
760 }
761 break;
762 case YEAR:
763 while (tmp.isBefore(end) || tmp.isEqual(end)) {
764 LocalDate lastDayOfYear = tmp.with(TemporalAdjusters.lastDayOfYear());
765 if (lastDayOfYear.isAfter(end)) {
766 result.add(tmp.toString() + "," + end);
767 } else {
768 result.add(tmp.toString() + "," + lastDayOfYear);
769 }
770 tmp = lastDayOfYear.plusDays(1);
771 }
772 break;
773 default:
774 break;
775 }
776 return result;
777 }
778
779 public static void main(String[] args) {
780 // System.out.println(getLocalDateTimeStr());
781 // System.out.println(getLocalDateStr());
782 // System.out.println(getSystemTime());
783 // System.out.println(getLocalTimeStr());
784 // System.out.println(getDayOfWeekStr());
785 // System.out.println(getDayOfWeekStr(LocalDate.now()));
786 //
787 // System.out.println("========");
788 // System.out.println(format(LocalDate.now(), UNSIGNED_DATE_PATTERN));
789
790 // System.out.println("========");
791 // System.out.println(parseLocalDateTime("2020-12-13 11:14:12", DATETIME_PATTERN));
792 // System.out.println(parseLocalDate("2020-12-13", DATE_PATTERN));
793
794 // System.out.println("========");
795 // System.out.println(plus(LocalDateTime.now(), 3, ChronoUnit.HOURS));
796 // System.out.println(minus(LocalDateTime.now(), 4, ChronoUnit.DAYS));
797 //
798 // System.out.println("========");
799 // System.out.println(getChronoUnitBetween(LocalDateTime.now(), parseLocalDateTime("2020-12-12 12:03:12", DATETIME_PATTERN), ChronoUnit.MINUTES));
800 // System.out.println(getChronoUnitBetween(LocalDate.now(), parseLocalDate("2021-12-12", DATE_PATTERN), ChronoUnit.WEEKS));
801 //
802 // System.out.println("========");
803 // System.out.println(getFirstDayOfYearStr());
804 // System.out.println(getFirstDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
805 // System.out.println(getFirstDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
806 //
807 // System.out.println(getLastDayOfYearStr());
808 // System.out.println(getLastDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
809 // System.out.println(getLastDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
810 //
811 // System.out.println("========");
812 // System.out.println(getFirstDayOfMonthStr());
813 // System.out.println(getFirstDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
814 // System.out.println(getFirstDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
815 //
816 // System.out.println(getLastDayOfMonthStr());
817 // System.out.println(getLastDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
818 // System.out.println(getLastDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
819 //
820 // System.out.println("========");
821 // System.out.println(getFirstDayOfWeekStr());
822 // System.out.println(getFirstDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
823 // System.out.println(getFirstDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
824 //
825 // System.out.println(getLastDayOfWeekStr());
826 // System.out.println(getLastDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
827 // System.out.println(getLastDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
828 //
829 // System.out.println("========");
830 // System.out.println(getStartTimeOfDayStr());
831 // System.out.println(getStartTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
832 // System.out.println(getStartTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
833 //
834 // System.out.println(getEndTimeOfDayStr());
835 // System.out.println(getEndTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));
836 // System.out.println(getEndTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));
837 //
838 // System.out.println("========");
839 // List<String> dateStrs = listDateStrs("2019-01-30", "2020-12-13", YEAR);
840 // for (String dateStr : dateStrs) {
841 // System.out.println(dateStr);
842 // }
843 //
844 // System.out.println("========");
845 // List<String> dateStrs1 = listDateStrs("2019-01-30", "2020-12-13", MONTH);
846 // for (String dateStr : dateStrs1) {
847 // System.out.println(dateStr);
848 // }
849 //
850 // System.out.println("========");
851 // List<String> dateStrs2 = listDateStrs("2020-12-01", "2020-12-13", DAY);
852 // for (String dateStr : dateStrs2) {
853 // System.out.println(dateStr);
854 // }
855
856 System.out.println(getThreeMonth(new Date()));
857 System.out.println(getNowDay(new Date()));
858 System.out.println(getNowYear(new Date()));
859 }
860 }
package jm.tsc.tsirm.common.helper;
import java.text.SimpleDateFormat;import java.time.*;import java.time.format.DateTimeFormatter;import java.time.temporal.ChronoUnit;import java.time.temporal.TemporalAccessor;import java.time.temporal.TemporalAdjusters;import java.util.ArrayList;import java.util.Calendar;import java.util.Date;import java.util.List;
/** * @PACKAGE_NAME: jm.tsc.tsirm.common.helper * @NAME: DateUtils * @USER: liul * @TIME: 2022/10/27 10:30 * @DAY_NAME_SHORT: 周四 */public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
/** * 显示年月日时分秒，例如 2015-08-11 09:51:53. */ public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
/** * 仅显示年月日，例如 2015-08-11. */ public static final String DATE_PATTERN = "yyyy-MM-dd";
/** * 仅显示时分秒，例如 09:51:53. */ public static final String TIME_PATTERN = "HH:mm:ss";
/** * 显示年月日时分秒(无符号)，例如 20150811095153. */ public static final String UNSIGNED_DATETIME_PATTERN = "yyyyMMddHHmmss";
/** * 仅显示年月日(无符号)，例如 20150811. */ public static final String UNSIGNED_DATE_PATTERN = "yyyyMMdd";
/** * 春天; */ public static final Integer SPRING = 1;
/** * 夏天; */ public static final Integer SUMMER = 2;
/** * 秋天; */ public static final Integer AUTUMN = 3;
/** * 冬天; */ public static final Integer WINTER = 4;
/** * 星期日; */ public static final String SUNDAY = "星期日";
/** * 星期一; */ public static final String MONDAY = "星期一";
/** * 星期二; */ public static final String TUESDAY = "星期二";
/** * 星期三; */ public static final String WEDNESDAY = "星期三";
/** * 星期四; */ public static final String THURSDAY = "星期四";
/** * 星期五; */ public static final String FRIDAY = "星期五";
/** * 星期六; */ public static final String SATURDAY = "星期六";
/** * 年 */ private static final String YEAR = "year";
/** * 月 */ private static final String MONTH = "month";
/** * 周 */ private static final String WEEK = "week";
/** * 日 */ private static final String DAY = "day";
/** * 时 */ private static final String HOUR = "hour";
/** * 分 */ private static final String MINUTE = "minute";
/** * 秒 */ private static final String SECOND = "second";
/** * 获取当前日期和时间字符串. * * @return String 日期时间字符串，例如 2015-08-11 09:51:53 */ public static String getLocalDateTimeStr() { return format(LocalDateTime.now(), DATETIME_PATTERN); }
/** * 获取系统当前时间戳 * * @return 1566889186583 */ public static String getSystemTime() { String current = String.valueOf(System.currentTimeMillis()); return current; }
/** * 获取当前日期 yy-MM-dd * * @return 2019-08-27 */ public static String getLocalDateStr() { Date date = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); return sdf.format(date); } /** * 获取当前时间字符串. * * @return String 时间字符串，例如 09:51:53 */ public static String getLocalTimeStr() { return format(LocalTime.now(), TIME_PATTERN); } /** * 获取当前月份 */ public static int getNowMonth(Date date) { Calendar calendar = Calendar.getInstance(); calendar.setTime(date); return calendar.get(Calendar.MONTH) + 1; }
/** * 获取当前日 */ public static int getNowDay(Date date) { Calendar calendar = Calendar.getInstance(); calendar.setTime(date); return calendar.get(Calendar.DATE); }
/** * 获取当前年份 */ public static int getNowYear(Date date) { Calendar calendar = Calendar.getInstance(); calendar.setTime(date); return calendar.get(Calendar.YEAR); }
/** * 获取本月份的天数 */ public static int getNowDaysOfMonth() { Calendar calendar = Calendar.getInstance(); return daysOfMonth(calendar.get(Calendar.YEAR), calendar.get(Calendar.DATE) + 1); }
/** * 获取指定月份的天数 * * @param year 年份 * @param month 月份 * @return 对应天数 */ public static int daysOfMonth(int year, int month) { switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: return 31; case 4: case 6: case 9: case 11: return 30; case 2: if ((year % 4 == 0 && year % 100 == 0) || year % 400 != 0) { return 29; } else { return 28; } default: return -1; } }
/** * 获取当前星期字符串. * * @return String 当前星期字符串，例如 星期二 */ public static String getDayOfWeekStr() { return format(LocalDate.now(), "E"); }
/** * 获取指定日期是星期几 * * @param localDate 日期 * @return String 星期几 */ public static String getDayOfWeekStr(LocalDate localDate) { String[] weekOfDays = {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY}; int dayOfWeek = localDate.getDayOfWeek().getValue() - 1; return weekOfDays[dayOfWeek]; }
/** * 获取日期时间字符串 * * @param temporal 需要转化的日期时间 可传入LocalDate * @param pattern 时间格式 * @return String 日期时间字符串，例如 2015-08-11 09:51:53 */ public static String format(TemporalAccessor temporal, String pattern) { DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern); return dateTimeFormatter.format(temporal); }
/** * 获取指定日期前一天 * * @return 2019-08-26 */ public static String getBeforeDay(Date date) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Calendar calendar = Calendar.getInstance(); calendar.setTime(date); calendar.add(Calendar.DAY_OF_MONTH, -1); date = calendar.getTime(); return sdf.format(date); }
/** * 获取指定日期往前最近七天 * * @param date 指定时间 * @return */ public static String getServen(Date date) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Calendar c = Calendar.getInstance(); c.setTime(date); c.add(Calendar.DATE, -7); Date monday = c.getTime(); String preMonday = sdf.format(monday); return preMonday; }
/** * 获取最近一个月 * * @param date 指定时间 * @return */ public static String getOneMonth(Date date) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Calendar c = Calendar.getInstance(); c.setTime(date); c.add(Calendar.MONTH, -1); Date monday = c.getTime(); String preMonday = sdf.format(monday); return preMonday; }
/** * 获取最近三个月 * * @param date 指定时间 * @return */ public static String getThreeMonth(Date date) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Calendar c = Calendar.getInstance(); c.setTime(date); c.add(Calendar.MONTH, -3); Date monday = c.getTime(); String preMonday = sdf.format(monday); return preMonday; }
/** * 获取最近一年 * * @param date 指定时间 * @return */ public static String getOneYear(Date date) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Calendar c = Calendar.getInstance(); c.setTime(date); c.add(Calendar.YEAR, -1); Date start = c.getTime(); String startDay = sdf.format(start); return startDay; }
/** * 日期时间字符串转换为日期时间(java.time.LocalDateTime) * * @param localDateTimeStr 日期时间字符串 * @param pattern 日期时间格式 例如DATETIME_PATTERN * @return LocalDateTime 日期时间 */ public static LocalDateTime parseLocalDateTime(String localDateTimeStr, String pattern) { DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern); return LocalDateTime.parse(localDateTimeStr, dateTimeFormatter); }
/** * 日期字符串转换为日期(java.time.LocalDate) * * @param localDateStr 日期字符串 * @param pattern 日期格式 例如DATE_PATTERN * @return LocalDate 日期 */ public static LocalDate parseLocalDate(String localDateStr, String pattern) { DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(pattern); return LocalDate.parse(localDateStr, dateTimeFormatter); }
/** * 获取指定日期时间加上指定数量日期时间单位之后的日期时间. * * @param localDateTime 日期时间 * @param num 数量 * @param chronoUnit 日期时间单位 * @return LocalDateTime 新的日期时间 */ public static LocalDateTime plus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) { return localDateTime.plus(num, chronoUnit); }
/** * 获取指定日期时间减去指定数量日期时间单位之后的日期时间. * * @param localDateTime 日期时间 * @param num 数量 * @param chronoUnit 日期时间单位 * @return LocalDateTime 新的日期时间 */ public static LocalDateTime minus(LocalDateTime localDateTime, int num, ChronoUnit chronoUnit) { return localDateTime.minus(num, chronoUnit); }
/** * 根据ChronoUnit计算两个日期时间之间相隔日期时间 * * @param start 开始日期时间 * @param end 结束日期时间 * @param chronoUnit 日期时间单位 * @return long 相隔日期时间 */ public static long getChronoUnitBetween(LocalDateTime start, LocalDateTime end, ChronoUnit chronoUnit) { return Math.abs(start.until(end, chronoUnit)); }
/** * 根据ChronoUnit计算两个日期之间相隔年数或月数或天数 * * @param start 开始日期 * @param end 结束日期 * @param chronoUnit 日期时间单位,(ChronoUnit.YEARS,ChronoUnit.MONTHS,ChronoUnit.WEEKS,ChronoUnit.DAYS) * @return long 相隔年数或月数或天数 */ public static long getChronoUnitBetween(LocalDate start, LocalDate end, ChronoUnit chronoUnit) { return Math.abs(start.until(end, chronoUnit)); }
/** * 获取本年第一天的日期字符串 * * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getFirstDayOfYearStr() { return getFirstDayOfYearStr(LocalDateTime.now()); }
/** * 获取本年最后一天的日期字符串 * * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getLastDayOfYearStr() { return getLastDayOfYearStr(LocalDateTime.now()); }
/** * 获取指定日期当年第一天的日期字符串 * * @param localDateTime 指定日期时间 * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getFirstDayOfYearStr(LocalDateTime localDateTime) { return getFirstDayOfYearStr(localDateTime, DATETIME_PATTERN); }
/** * 获取指定日期当年最后一天的日期字符串 * * @param localDateTime 指定日期时间 * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getLastDayOfYearStr(LocalDateTime localDateTime) { return getLastDayOfYearStr(localDateTime, DATETIME_PATTERN); }
/** * 获取指定日期当年第一天的日期字符串,带日期格式化参数 * * @param localDateTime 指定日期时间 * @param pattern 日期时间格式 * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getFirstDayOfYearStr(LocalDateTime localDateTime, String pattern) { return format(localDateTime.withDayOfYear(1).withHour(0).withMinute(0).withSecond(0), pattern); }
/** * 获取指定日期当年最后一天的日期字符串,带日期格式化参数 * * @param localDateTime 指定日期时间 * @param pattern 日期时间格式 * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getLastDayOfYearStr(LocalDateTime localDateTime, String pattern) { return format(localDateTime.with(TemporalAdjusters.lastDayOfYear()).withHour(23).withMinute(59).withSecond(59), pattern); }
/** * 获取本月第一天的日期字符串 * * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getFirstDayOfMonthStr() { return getFirstDayOfMonthStr(LocalDateTime.now()); }
/** * 获取本月最后一天的日期字符串 * * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getLastDayOfMonthStr() { return getLastDayOfMonthStr(LocalDateTime.now()); }
/** * 获取指定日期当月第一天的日期字符串 * * @param localDateTime 指定日期时间 * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getFirstDayOfMonthStr(LocalDateTime localDateTime) { return getFirstDayOfMonthStr(localDateTime, DATETIME_PATTERN); }
/** * 获取指定日期当月最后一天的日期字符串 * * @param localDateTime 指定日期时间 * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getLastDayOfMonthStr(LocalDateTime localDateTime) { return getLastDayOfMonthStr(localDateTime, DATETIME_PATTERN); }
/** * 获取指定日期当月第一天的日期字符串,带日期格式化参数 * * @param localDateTime 指定日期时间 * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getFirstDayOfMonthStr(LocalDateTime localDateTime, String pattern) { return format(localDateTime.withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0), pattern); }
/** * 获取指定日期当月最后一天的日期字符串,带日期格式化参数 * * @param localDateTime 指定日期时间 * @param pattern 日期时间格式 * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getLastDayOfMonthStr(LocalDateTime localDateTime, String pattern) { return format(localDateTime.with(TemporalAdjusters.lastDayOfMonth()).withHour(23).withMinute(59).withSecond(59), pattern); }
/** * 获取本周第一天的日期字符串 * * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getFirstDayOfWeekStr() { return getFirstDayOfWeekStr(LocalDateTime.now()); }
/** * 获取本周最后一天的日期字符串 * * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getLastDayOfWeekStr() { return getLastDayOfWeekStr(LocalDateTime.now()); }
/** * 获取指定日期当周第一天的日期字符串,这里第一天为周一 * * @param localDateTime 指定日期时间 * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getFirstDayOfWeekStr(LocalDateTime localDateTime) { return getFirstDayOfWeekStr(localDateTime, DATETIME_PATTERN); }
/** * 获取指定日期当周最后一天的日期字符串,这里最后一天为周日 * * @param localDateTime 指定日期时间 * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getLastDayOfWeekStr(LocalDateTime localDateTime) { return getLastDayOfWeekStr(localDateTime, DATETIME_PATTERN); }
/** * 获取指定日期当周第一天的日期字符串,这里第一天为周一,带日期格式化参数 * * @param localDateTime 指定日期时间 * @param pattern 日期时间格式 * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getFirstDayOfWeekStr(LocalDateTime localDateTime, String pattern) { return format(localDateTime.with(DayOfWeek.MONDAY).withHour(0).withMinute(0).withSecond(0), pattern); }
/** * 获取指定日期当周最后一天的日期字符串,这里最后一天为周日,带日期格式化参数 * * @param localDateTime 指定日期时间 * @param pattern 日期时间格式 * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getLastDayOfWeekStr(LocalDateTime localDateTime, String pattern) { return format(localDateTime.with(DayOfWeek.SUNDAY).withHour(23).withMinute(59).withSecond(59), pattern); }
/** * 获取今天开始时间的日期字符串 * * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getStartTimeOfDayStr() { return getStartTimeOfDayStr(LocalDateTime.now()); }
/** * 获取今天结束时间的日期字符串 * * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getEndTimeOfDayStr() { return getEndTimeOfDayStr(LocalDateTime.now()); }
/** * 获取指定日期开始时间的日期字符串 * * @param localDateTime 指定日期时间 * @return String 格式：yyyy-MM-dd 00:00:00 */ public static String getStartTimeOfDayStr(LocalDateTime localDateTime) { return getStartTimeOfDayStr(localDateTime, DATETIME_PATTERN); }
/** * 获取指定日期结束时间的日期字符串 * * @param localDateTime 指定日期时间 * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getEndTimeOfDayStr(LocalDateTime localDateTime) { return getEndTimeOfDayStr(localDateTime, DATETIME_PATTERN); }
/** * 获取指定日期开始时间的日期字符串,带日期格式化参数 * * @param localDateTime 指定日期时间 * @param pattern 日期时间格式 * @return String 格式：yyyy-MM-dd HH:mm:ss */ public static String getStartTimeOfDayStr(LocalDateTime localDateTime, String pattern) { return format(localDateTime.withHour(0).withMinute(0).withSecond(0), pattern); }
/** * 获取指定日期结束时间的日期字符串,带日期格式化参数 * * @param localDateTime 指定日期时间 * @param pattern 日期时间格式 * @return String 格式：yyyy-MM-dd 23:59:59 */ public static String getEndTimeOfDayStr(LocalDateTime localDateTime, String pattern) { return format(localDateTime.withHour(23).withMinute(59).withSecond(59), pattern); }
public static String dayComparePrecise(Date fromDate, Date toDate){ SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); if(fromDate==null||toDate==null){ return "不足一个月"; } Period period = Period.between(LocalDate.parse(format.format(fromDate)), LocalDate.parse(format.format(toDate)));
StringBuffer sb = new StringBuffer(); if(period.getYears()>0){ sb.append(period.getYears()).append("年"); } if(period.getMonths()>0) { sb.append(period.getMonths()).append("个月"); } if(period.getYears()<=0&&period.getMonths()<=0){ sb.append("不足一个月"); } return sb.toString(); }
/** * Date转LocalDateTime类型 * localDateTime.toLocalDate(); * ocalDateTime.toLocalDate(); * * @param date 指定日期 * @return */ public static LocalDateTime dataToLocalDatetime(Date date){ if(date==null){ return null; } Instant instant = date.toInstant(); ZoneId zone = ZoneId.systemDefault(); //Date转换为LocalDateTime LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone); return localDateTime; }
/** * 切割日期。按照周期切割成小段日期段。例如： <br> * * @param startDate 开始日期（yyyy-MM-dd） * @param endDate 结束日期（yyyy-MM-dd） * @param period 周期（天，周，月，年） * @return 切割之后的日期集合 * <li>startDate="2019-02-28",endDate="2019-03-05",period="day"</li> * <li>结果为：[2019-02-28, 2019-03-01, 2019-03-02, 2019-03-03, 2019-03-04, 2019-03-05]</li><br> * <li>startDate="2019-02-28",endDate="2019-03-25",period="week"</li> * <li>结果为：[2019-02-28,2019-03-06, 2019-03-07,2019-03-13, 2019-03-14,2019-03-20, * 2019-03-21,2019-03-25]</li><br> * <li>startDate="2019-02-28",endDate="2019-05-25",period="month"</li> * <li>结果为：[2019-02-28,2019-02-28, 2019-03-01,2019-03-31, 2019-04-01,2019-04-30, * 2019-05-01,2019-05-25]</li><br> * <li>startDate="2019-02-28",endDate="2020-05-25",period="year"</li> * <li>结果为：[2019-02-28,2019-12-31, 2020-01-01,2020-05-25]</li><br> */ public static List<String> listDateStrs(String startDate, String endDate, String period) { List<String> result = new ArrayList<>(); DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(DATE_PATTERN); LocalDate end = LocalDate.parse(endDate, dateTimeFormatter); LocalDate start = LocalDate.parse(startDate, dateTimeFormatter); LocalDate tmp = start; switch (period) { case DAY: while (start.isBefore(end) || start.isEqual(end)) { result.add(start.toString()); start = start.plusDays(1); } break; case WEEK: while (tmp.isBefore(end) || tmp.isEqual(end)) { if (tmp.plusDays(6).isAfter(end)) { result.add(tmp.toString() + "," + end); } else { result.add(tmp.toString() + "," + tmp.plusDays(6)); } tmp = tmp.plusDays(7); } break; case MONTH: while (tmp.isBefore(end) || tmp.isEqual(end)) { LocalDate lastDayOfMonth = tmp.with(TemporalAdjusters.lastDayOfMonth()); if (lastDayOfMonth.isAfter(end)) { result.add(tmp.toString() + "," + end); } else { result.add(tmp.toString() + "," + lastDayOfMonth); } tmp = lastDayOfMonth.plusDays(1); } break; case YEAR: while (tmp.isBefore(end) || tmp.isEqual(end)) { LocalDate lastDayOfYear = tmp.with(TemporalAdjusters.lastDayOfYear()); if (lastDayOfYear.isAfter(end)) { result.add(tmp.toString() + "," + end); } else { result.add(tmp.toString() + "," + lastDayOfYear); } tmp = lastDayOfYear.plusDays(1); } break; default: break; } return result; }
public static void main(String[] args) {// System.out.println(getLocalDateTimeStr());// System.out.println(getLocalDateStr());// System.out.println(getSystemTime());// System.out.println(getLocalTimeStr());// System.out.println(getDayOfWeekStr());// System.out.println(getDayOfWeekStr(LocalDate.now()));//// System.out.println("========");// System.out.println(format(LocalDate.now(), UNSIGNED_DATE_PATTERN));
// System.out.println("========");// System.out.println(parseLocalDateTime("2020-12-13 11:14:12", DATETIME_PATTERN));// System.out.println(parseLocalDate("2020-12-13", DATE_PATTERN));
// System.out.println("========");// System.out.println(plus(LocalDateTime.now(), 3, ChronoUnit.HOURS));// System.out.println(minus(LocalDateTime.now(), 4, ChronoUnit.DAYS));//// System.out.println("========");// System.out.println(getChronoUnitBetween(LocalDateTime.now(), parseLocalDateTime("2020-12-12 12:03:12", DATETIME_PATTERN), ChronoUnit.MINUTES));// System.out.println(getChronoUnitBetween(LocalDate.now(), parseLocalDate("2021-12-12", DATE_PATTERN), ChronoUnit.WEEKS));//// System.out.println("========");// System.out.println(getFirstDayOfYearStr());// System.out.println(getFirstDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));// System.out.println(getFirstDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));//// System.out.println(getLastDayOfYearStr());// System.out.println(getLastDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));// System.out.println(getLastDayOfYearStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));//// System.out.println("========");// System.out.println(getFirstDayOfMonthStr());// System.out.println(getFirstDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));// System.out.println(getFirstDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));//// System.out.println(getLastDayOfMonthStr());// System.out.println(getLastDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));// System.out.println(getLastDayOfMonthStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));//// System.out.println("========");// System.out.println(getFirstDayOfWeekStr());// System.out.println(getFirstDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));// System.out.println(getFirstDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));//// System.out.println(getLastDayOfWeekStr());// System.out.println(getLastDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));// System.out.println(getLastDayOfWeekStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));//// System.out.println("========");// System.out.println(getStartTimeOfDayStr());// System.out.println(getStartTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));// System.out.println(getStartTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));//// System.out.println(getEndTimeOfDayStr());// System.out.println(getEndTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN)));// System.out.println(getEndTimeOfDayStr(parseLocalDateTime("2021-12-12 12:03:12", DATETIME_PATTERN), UNSIGNED_DATETIME_PATTERN));//// System.out.println("========");// List<String> dateStrs = listDateStrs("2019-01-30", "2020-12-13", YEAR);// for (String dateStr : dateStrs) {// System.out.println(dateStr);// }//// System.out.println("========");// List<String> dateStrs1 = listDateStrs("2019-01-30", "2020-12-13", MONTH);// for (String dateStr : dateStrs1) {// System.out.println(dateStr);// }//// System.out.println("========");// List<String> dateStrs2 = listDateStrs("2020-12-01", "2020-12-13", DAY);// for (String dateStr : dateStrs2) {// System.out.println(dateStr);// }
System.out.println(getThreeMonth(new Date())); System.out.println(getNowDay(new Date())); System.out.println(getNowYear(new Date())); }} 标签：12,return,String,日期,static,工具,public From： https://www.cnblogs.com/liulsky/p/17447716.html