日期时间工具类

冷不防 2024-03-17 12:06 210阅读 0赞

直接调用下方法即可获取当前时间：

  1. new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());

使用工具类获取当前时间（需引入下面的DateUtils工具类）：

  1. DateUtils.formatDateTime(new Date());
  1. package com.zyq.util.date;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.ArrayList;
  6. import java.util.Calendar;
  7. import java.util.Collections;
  8. import java.util.Date;
  9. import java.util.HashMap;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.Objects;
  14. /**
  15.  * 创作者链接：https://blog.csdn.net/sunnyzyq/article/details/125377621
  16.  * @author zyq
  17.  * @since 2022/6/17
  18.  */
  19. public class DateUtils {
  21.     /** 一星期的天数 */
  22.     public static final int WEEK_DAYS = 7;
  23.     /** 一年的月份数 */
  24.     public static final int YEAR_MONTHS = 12;
  25.     /** 一天的小时数 */
  26.     public static final int DAY_HOURS = 24;
  27.     /** 一小时分钟数 */
  28.     public static final int HOUR_MINUTES = 60;
  29.     /** 一天分钟数 (24 * 60) */
  30.     public static final int DAY_MINUTES = 1440;
  31.     /** 一分钟的秒数 */
  32.     public static final int MINUTE_SECONDS = 60;
  33.     /** 一个小时的秒数 (60 * 60) */
  34.     public static final int HOUR_SECONDS = 3600;
  35.     /** 一天的秒数 (24 * 60 * 60) */
  36.     public static final int DAY_SECONDS = 86400;
  37.     /** 一秒的毫秒数 */
  38.     public static final long SECOND_MILLISECONDS = 1000L;
  39.     /** 一分钟的毫秒数（60 * 1000） */
  40.     public static final long MINUTE_MILLISECONDS = 60000L;
  41.     /** 一小时的毫秒数（60 * 60 * 1000） */
  42.     public static final long HOUR_MILLISECONDS = 3600000L;
  43.     /** 一天的毫秒数（24 * 60* 60* 1000） */
  44.     public static final long DAY_MILLISECONDS = 86400000L;
  45.     /** 星期一 */
  46.     public static final int WEEK_1_MONDAY = 1;
  47.     /** 星期二 */
  48.     public static final int WEEK_2_TUESDAY = 2;
  49.     /** 星期三 */
  50.     public static final int WEEK_3_WEDNESDAY = 3;
  51.     /** 星期四 */
  52.     public static final int WEEK_4_THURSDAY = 4;
  53.     /** 星期五 */
  54.     public static final int WEEK_5_FRIDAY = 5;
  55.     /** 星期六 */
  56.     public static final int WEEK_6_SATURDAY = 6;
  57.     /** 星期天 */
  58.     public static final int WEEK_7_SUNDAY = 7;
  59.     /** 一月 */
  60.     public static final int MONTH_1_JANUARY = 1;
  61.     /** 二月 */
  62.     public static final int MONTH_2_FEBRUARY = 2;
  63.     /** 三月 */
  64.     public static final int MONTH_3_MARCH = 3;
  65.     /** 四月 */
  66.     public static final int MONTH_4_APRIL= 4;
  67.     /** 五月 */
  68.     public static final int MONTH_5_MAY = 5;
  69.     /** 六月 */
  70.     public static final int MONTH_6_JUNE = 6;
  71.     /** 七月 */
  72.     public static final int MONTH_7_JULY = 7;
  73.     /** 八月 */
  74.     public static final int MONTH_8_AUGUST = 8;
  75.     /** 九月 */
  76.     public static final int MONTH_9_SEPTEMBER = 9;
  77.     /** 十月 */
  78.     public static final int MONTH_10_OCTOBER = 10;
  79.     /** 十一月 */
  80.     public static final int MONTH_11_NOVEMBER = 11;
  81.     /** 十二月 */
  82.     public static final int MONTH_12_DECEMBER= 12;
  83.     /** 显示到日期 */
  84.     public static final String FORMAT_DATE = "yyyy-MM-dd";
  85.     /** 显示到小时 */
  86.     public static final String FORMAT_HOUR = "yyyy-MM-dd HH";
  87.     /** 显示到分 */
  88.     public static final String FORMAT_MINUTE = "yyyy-MM-dd HH:mm";
  89.     /** 显示到秒 */
  90.     public static final String FORMAT_SECOND = "yyyy-MM-dd HH:mm:ss";
  91.     /** 显示到毫秒 */
  92.     public static final String FORMAT_MILLISECOND = "yyyy-MM-dd HH:mm:ss:SSS";
  93.     /** 显示到日期（数字格式） */
  94.     public static final String FORMAT_NO_DATE = "yyyyMMdd";
  95.     /** 显示到小时（数字格式） */
  96.     public static final String FORMAT_NO_HOUR = "yyyyMMddHH";
  97.     /** 显示到分（数字格式） */
  98.     public static final String FORMAT_NO_MINUTE = "yyyyMMddHHmm";
  99.     /** 显示到秒（数字格式） */
  100.     public static final String FORMAT_NO_SECOND = "yyyyMMddHHmmss";
  101.     /** 显示到毫秒（数字格式） */
  102.     public static final String FORMAT_NO_MILLISECOND = "yyyyMMddHHmmssSSS";
  105.     /**
  106.      * 获取指定时间格式化器
  107.      *
  108.      * @param formatStyle 时间格式
  109.      * @return 时间格式化器
  110.      */
  111.     private static SimpleDateFormat getSimpleDateFormat(String formatStyle) {
  112.         return new SimpleDateFormat(formatStyle);
  113.     }
  115.     /**
  116.      * 将 Date 格式时间转化为指定格式时间
  117.      *
  118.      * @param date        Date 格式时间
  119.      * @param formatStyle 转化指定格式（如: yyyy-MM-dd HH:mm:ss）
  120.      * @return 转化格式时间
  121.      */
  122.     public static String format(Date date, String formatStyle) {
  123.         if (Objects.isNull(date)) {
  124.             return "";
  125.         }
  126.         return getSimpleDateFormat(formatStyle).format(date);
  127.     }
  129.     /**
  130.      * 将 Date 格式时间转化为 yyyy-MM-dd 格式时间
  131.      *
  132.      * @param date Date 格式时间
  133.      * @return yyyy-MM-dd 格式时间（如：2022-06-17）
  134.      */
  135.     public static String formatDate(Date date) {
  136.         return format(date, FORMAT_DATE);
  137.     }
  139.     /**
  140.      * 将 Date 格式时间转化为 yyyy-MM-dd HH:mm:ss 格式时间
  141.      *
  142.      * @param date Date 格式时间
  143.      * @return yyyy-MM-dd HH:mm:ss 格式时间（如：2022-06-17 16:06:17）
  144.      */
  145.     public static String formatDateTime(Date date) {
  146.         return format(date, FORMAT_SECOND);
  147.     }
  149.     /**
  150.      * 将 Date 格式时间转化为 yyyy-MM-dd HH:mm:ss:SSS 格式时间
  151.      *
  152.      * @param date Date 格式时间
  153.      * @return yyyy-MM-dd HH:mm:ss:SSS 格式时间（如：2022-06-17 16:06:17:325）
  154.      */
  155.     public static String formatDateTimeStamp(Date date) {
  156.         return format(date, FORMAT_MILLISECOND);
  157.     }
  159.     /**
  160.      * 将 yyyy-MM-dd 格式时间转化为 Date 格式时间
  161.      * 
  162.      * @param dateString yyyy-MM-dd 格式时间（如：2022-06-17）
  163.      * @return Date 格式时间
  164.      */
  165.     public static Date parseDate(String dateString) {
  166.         return parse(dateString, FORMAT_DATE);
  167.     }
  169.     /**
  170.      * 将 yyyy-MM-dd HH:mm:ss 格式时间转化为 Date 格式时间
  171.      * 
  172.      * @param dateTimeStr yyyy-MM-dd HH:mm:ss 格式时间（如：2022-06-17 16:06:17）
  173.      * @return Date 格式时间
  174.      */
  175.     public static Date parseDateTime(String dateTimeStr) {
  176.         return parse(dateTimeStr, FORMAT_SECOND);
  177.     }
  179.     /**
  180.      * 将 yyyy-MM-dd HH:mm:ss:SSS 格式时间转化为 Date 格式时间
  181.      * 
  182.      * @param dateTimeStr yyyy-MM-dd HH:mm:ss:SSS 格式时间（如：2022-06-17 16:06:17）
  183.      * @return Date 格式时间
  184.      */
  185.     public static Date parseDateTimeStamp(String dateTimeStampStr) {
  186.         return parse(dateTimeStampStr, FORMAT_MILLISECOND);
  187.     }
  189.     /**
  190.      * 将字符串格式时间转化为 Date 格式时间
  191.      * 
  192.      * @param dateString 字符串时间（如：2022-06-17 16:06:17）
  193.      * @return formatStyle 格式内容
  194.      * @return Date 格式时间
  195.      */
  196.     public static Date parse(String dateString, String formatStyle) {
  197.         String s = getString(dateString);
  198.         if (s.isEmpty()) {
  199.             return null;
  200.         }
  201.         try {
  202.             return getSimpleDateFormat(formatStyle).parse(dateString);
  203.         } catch (ParseException e) {
  204.             e.printStackTrace();
  205.             return null;
  206.         }
  207.     }
  209.     /**
  210.      * 获取字符串有效内容
  211.      * 
  212.      * @param s 字符串
  213.      * @return 有效内容
  214.      */
  215.     private static String getString(String s) {
  216.         return Objects.isNull(s) ? "" : s.trim();
  217.     }
  219.     /**
  220.      * 获取一天的开始时间（即：0 点 0 分 0 秒 0 毫秒）
  221.      * 
  222.      * @param date 指定时间
  223.      * @return 当天的开始时间
  224.      */
  225.     public static Date getDateStart(Date date) {
  226.         if (Objects.isNull(date)) {
  227.             return null;
  228.         }
  229.         Calendar calendar = Calendar.getInstance();
  230.         calendar.setTime(date);
  231.         calendar.set(Calendar.HOUR_OF_DAY, 0);
  232.         calendar.set(Calendar.MINUTE, 0);
  233.         calendar.set(Calendar.SECOND, 0);
  234.         calendar.set(Calendar.MILLISECOND, 0);
  235.         return calendar.getTime();
  236.     }
  238.     /**
  239.      * 获取一天的截止时间（即：23 点 59 分 59 秒 999 毫秒）
  240.      * 
  241.      * @param date 指定时间
  242.      * @return 当天的开始时间
  243.      */
  244.     public static Date getDateEnd(Date date) {
  245.         if (Objects.isNull(date)) {
  246.             return null;
  247.         }
  248.         Calendar calendar = Calendar.getInstance();
  249.         calendar.setTime(date);
  250.         calendar.set(Calendar.HOUR_OF_DAY, 23);
  251.         calendar.set(Calendar.MINUTE, 59);
  252.         calendar.set(Calendar.SECOND, 59);
  253.         calendar.set(Calendar.MILLISECOND, 999);
  254.         return calendar.getTime();
  255.     }
  257.     /**
  258.      * 获取日期数字
  259.      * 
  260.      * @param date 日期
  261.      * @return 日期数字
  262.      */
  263.     public static int getDateNo(Date date) {
  264.         if (Objects.isNull(date)) {
  265.             return 0;
  266.         }
  267.         return Integer.valueOf(format(date, FORMAT_NO_DATE));
  268.     }
  270.     /**
  271.      * 获取日期时间数字（到秒）
  272.      * 
  273.      * @param date 日期
  274.      * @return 日期数字
  275.      */
  276.     public static long getDateTimeNo(Date date) {
  277.         if (Objects.isNull(date)) {
  278.             return 0L;
  279.         }
  280.         return Long.valueOf(format(date, FORMAT_NO_SECOND));
  281.     }
  283.     /**
  284.      * 获取日期时间数字（到毫秒）
  285.      * 
  286.      * @param date 日期
  287.      * @return 日期数字
  288.      */
  289.     public static long getDateTimeStampNo(Date date) {
  290.         if (Objects.isNull(date)) {
  291.             return 0L;
  292.         }
  293.         return Long.valueOf(format(date, FORMAT_NO_MILLISECOND));
  294.     }
  296.     /**
  297.      * 获取星期几
  298.      * 
  299.      * @param date 时间
  300.      * @return 0（时间为空）， 1（周一）， 2（周二），3（周三），4（周四），5（周五），6（周六），7（周日）
  301.      */
  302.     public static int getWeek(Date date) {
  303.         if (Objects.isNull(date)) {
  304.             return 0;
  305.         }
  306.         Calendar calendar = Calendar.getInstance();
  307.         calendar.setTime(date);
  308.         return getWeek(calendar);
  309.     }
  311.     /**
  312.      * 获取星期几
  313.      * 
  314.      * @param date 时间
  315.      * @return 0（时间为空）， 1（周一）， 2（周二），3（周三），4（周四），5（周五），6（周六），7（周日）
  316.      */
  317.     private static int getWeek(Calendar calendar) {
  318.         switch (calendar.get(Calendar.DAY_OF_WEEK)) {
  319.         case Calendar.MONDAY:
  320.             return 1;
  321.         case Calendar.TUESDAY:
  322.             return 2;
  323.         case Calendar.WEDNESDAY:
  324.             return 3;
  325.         case Calendar.THURSDAY:
  326.             return 4;
  327.         case Calendar.FRIDAY:
  328.             return 5;
  329.         case Calendar.SATURDAY:
  330.             return 6;
  331.         case Calendar.SUNDAY:
  332.             return 7;
  333.         default:
  334.             return 0;
  335.         }
  336.     }
  338.     /**
  339.      * 获取该日期是今年的第几周（以本年的周一为第1周，详见下面说明）<br>
  340.      * 
  341.      * 【说明】<br>
  342.      * 比如 2022-01-01（周六）和 2022-01-02（周日）虽然在 2022 年里，但他们两天则属于 2021 年最后一周，<br>
  343.      * 那么这两天不会算在 2022 年第 1 周里，此时会返回 0 ；而 2022 年第 1 周将从 2022-01-03（周一） 开始计算。<br>
  344.      * 
  345.      * @param date 时间
  346.      * @return -1（时间为空）， 0（为上个年的最后一周），其他数字（今年的第几周）
  347.      */
  348.     public static int getWeekOfYear(Date date) {
  349.         if (Objects.isNull(date)) {
  350.             return -1;
  351.         }
  352.         int weeks = getWeekOfYearIgnoreLastYear(date);
  353.         Calendar calendar = Calendar.getInstance();
  354.         calendar.setTime(date);
  355.         calendar.set(Calendar.MONTH, Calendar.JANUARY);
  356.         calendar.set(Calendar.DAY_OF_MONTH, 1);
  357.         int week = getWeek(calendar);
  358.         if (week == 1) {
  359.             return weeks;
  360.         }
  361.         return weeks - 1;
  362.     }
  364.     /**
  365.      * 获取今年的第几周（以本年的1月1日为第1周第1天）<br>
  366.      * 
  367.      * @param date 时间
  368.      * @return -1（时间为空），其他数字（今年的第几周）
  369.      */
  370.     public static int getWeekOfYearIgnoreLastYear(Date date) {
  371.         if (Objects.isNull(date)) {
  372.             return -1;
  373.         }
  374.         Calendar calendar = Calendar.getInstance();
  375.         calendar.setTime(date);
  376.         int days = calendar.get(Calendar.DAY_OF_YEAR);
  377.         int weeks = days / 7;
  378.         // 如果是 7 的倍数，则表示恰好是多少周
  379.         if (days % 7 == 0) {
  380.             return weeks;
  381.         }
  382.         // 如果有余数，则需要再加 1
  383.         return weeks + 1;
  384.     }
  386.     /**
  387.      * 获取时间节点对象
  388.      * 
  389.      * @param date 时间对象
  390.      * @return DateNode
  391.      */
  392.     public static DateNode getDateNode(Date date) {
  393.         if (Objects.isNull(date)) {
  394.             return null;
  395.         }
  396.         Calendar calendar = Calendar.getInstance();
  397.         calendar.setTime(date);
  398.         DateNode node = new DateNode();
  399.         node.setTime(format(date, FORMAT_MILLISECOND));
  400.         node.setYear(calendar.get(Calendar.YEAR));
  401.         node.setMonth(calendar.get(Calendar.MONTH) + 1);
  402.         node.setDay(calendar.get(Calendar.DAY_OF_MONTH));
  403.         node.setHour(calendar.get(Calendar.HOUR_OF_DAY));
  404.         node.setMinute(calendar.get(Calendar.MINUTE));
  405.         node.setSecond(calendar.get(Calendar.SECOND));
  406.         node.setMillisecond(calendar.get(Calendar.MILLISECOND));
  407.         node.setWeek(getWeek(calendar));
  408.         node.setDayOfYear(calendar.get(Calendar.DAY_OF_YEAR));
  409.         node.setWeekOfYear(getWeekOfYear(date));
  410.         node.setWeekOfYearIgnoreLastYear(getWeekOfYearIgnoreLastYear(date));
  411.         node.setMillisecondStamp(date.getTime());
  412.         node.setSecondStamp(node.getMillisecondStamp() / 1000);
  413.         return node;
  414.     }
  416.     /**
  417.      * 日期变更
  418.      * 
  419.      * @param date   指定日期
  420.      * @param field  变更属性（如变更年份，则该值为 Calendar.DAY_OF_YEAR）
  421.      * @param amount 变更大小（大于 0 时增加，小于 0 时减少）
  422.      * @return 变更后的日期时间
  423.      */
  424.     public static Date add(Date date, int field, int amount) {
  425.         if (Objects.isNull(date)) {
  426.             return null;
  427.         }
  428.         Calendar calendar = Calendar.getInstance();
  429.         calendar.setTime(date);
  430.         calendar.add(field, amount);
  431.         return calendar.getTime();
  432.     }
  434.     /**
  435.      * 指定日期加减年份
  436.      * 
  437.      * @param date 指定日期
  438.      * @param year 变更年份（大于 0 时增加，小于 0 时减少）
  439.      * @return 变更年份后的日期
  440.      */
  441.     public static Date addYear(Date date, int year) {
  442.         return add(date, Calendar.YEAR, year);
  443.     }
  445.     /**
  446.      * 指定日期加减月份
  447.      * 
  448.      * @param date  指定日期
  449.      * @param month 变更月份（大于 0 时增加，小于 0 时减少）
  450.      * @return 变更月份后的日期
  451.      */
  452.     public static Date addMonth(Date date, int month) {
  453.         return add(date, Calendar.MONTH, month);
  454.     }
  456.     /**
  457.      * 指定日期加减天数
  458.      * 
  459.      * @param date 指定日期
  460.      * @param day  变更天数（大于 0 时增加，小于 0 时减少）
  461.      * @return 变更天数后的日期
  462.      */
  463.     public static Date addDay(Date date, int day) {
  464.         return add(date, Calendar.DAY_OF_YEAR, day);
  465.     }
  467.     /**
  468.      * 指定日期加减星期
  469.      * 
  470.      * @param date 指定日期
  471.      * @param week 变更星期数（大于 0 时增加，小于 0 时减少）
  472.      * @return 变更星期数后的日期
  473.      */
  474.     public static Date addWeek(Date date, int week) {
  475.         return add(date, Calendar.WEEK_OF_YEAR, week);
  476.     }
  478.     /**
  479.      * 指定日期加减小时
  480.      * 
  481.      * @param date 指定日期时间
  482.      * @param hour 变更小时数（大于 0 时增加，小于 0 时减少）
  483.      * @return 变更小时数后的日期时间
  484.      */
  485.     public static Date addHour(Date date, int hour) {
  486.         return add(date, Calendar.HOUR_OF_DAY, hour);
  487.     }
  489.     /**
  490.      * 指定日期加减分钟
  491.      * 
  492.      * @param date   指定日期时间
  493.      * @param minute 变更分钟数（大于 0 时增加，小于 0 时减少）
  494.      * @return 变更分钟数后的日期时间
  495.      */
  496.     public static Date addMinute(Date date, int minute) {
  497.         return add(date, Calendar.MINUTE, minute);
  498.     }
  500.     /**
  501.      * 指定日期加减秒
  502.      * 
  503.      * @param date   指定日期时间
  504.      * @param second 变更秒数（大于 0 时增加，小于 0 时减少）
  505.      * @return 变更秒数后的日期时间
  506.      */
  507.     public static Date addSecond(Date date, int second) {
  508.         return add(date, Calendar.SECOND, second);
  509.     }
  511.     /**
  512.      * 指定日期加减秒
  513.      * 
  514.      * @param date   指定日期时间
  515.      * @param minute 变更毫秒数（大于 0 时增加，小于 0 时减少）
  516.      * @return 变更毫秒数后的日期时间
  517.      */
  518.     public static Date addMillisecond(Date date, int millisecond) {
  519.         return add(date, Calendar.MILLISECOND, millisecond);
  520.     }
  522.     /**
  523.      * 获取该日期所在周指定星期的日期
  524.      * 
  525.      * @param date 日期所在时间
  526.      * @return index 指定星期（1 - 7 分别对应星期一到星期天）
  527.      */
  528.     public static Date getWeekDate(Date date, int index) {
  529.         if (index < WEEK_1_MONDAY || index > WEEK_7_SUNDAY) {
  530.             return null;
  531.         }
  532.         int week = getWeek(date);
  533.         return addDay(date, index - week);
  534.     }
  536.     /**
  537.      * 获取该日期所在周开始日期
  538.      * 
  539.      * @param date 日期所在时间
  540.      * @return 所在周开始日期
  541.      */
  542.     public static Date getWeekDateStart(Date date) {
  543.         return getDateStart(getWeekDate(date, WEEK_1_MONDAY));
  544.     }
  546.     /**
  547.      * 获取该日期所在周开始日期
  548.      * 
  549.      * @param date 日期所在时间
  550.      * @return 所在周开始日期
  551.      */
  552.     public static Date getWeekDateEnd(Date date) {
  553.         return getWeekDateEnd(getWeekDate(date, WEEK_7_SUNDAY));
  554.     }
  556.     /**
  557.      * 获取该日期所在周的所有日期（周一到周日）
  558.      * 
  559.      * @param Date 日期
  560.      * @return 该日照所在周的所有日期
  561.      */
  562.     public static List<Date> getWeekDateList(Date date) {
  563.         if (Objects.isNull(date)) {
  564.             return Collections.emptyList();
  565.         }
  566.         // 获取本周开始时间
  567.         Date weekFromDate = getWeekDateStart(date);
  568.         // 获取本周截止时间
  569.         Date weekeEndDate = getWeekDateEnd(date);
  570.         return getBetweenDateList(weekFromDate, weekeEndDate, true);
  571.     }
  573.     /**
  574.      * 获取该日期所在周的所有日期（周一到周日）
  575.      * 
  576.      * @param dateString
  577.      * @return 该日照所在周的所有日期
  578.      */
  579.     public static List<String> getWeekDateList(String dateString) {
  580.         Date date = parseDate(dateString);
  581.         if (Objects.isNull(date)) {
  582.             return Collections.emptyList();
  583.         }
  584.         return getDateStrList(getWeekDateList(date));
  585.     }
  587.     /**
  588.      * 获取该日期所在月的所有日期
  589.      * 
  590.      * @param dateString
  591.      * @return 该日照所月的所有日期
  592.      */
  593.     public static List<Date> getMonthDateList(Date date) {
  594.         if (Objects.isNull(date)) {
  595.             return Collections.emptyList();
  596.         }
  597.         Date monthDateStart = getMonthDateStart(date);
  598.         Date monthDateEnd = getMonthDateEnd(date);
  599.         return getBetweenDateList(monthDateStart, monthDateEnd, true);
  600.     }
  602.     /**
  603.      * 获取该日期所在月的所有日期
  604.      * 
  605.      * @param dateString
  606.      * @return 该日照所月的所有日期
  607.      */
  608.     public static List<String> getMonthDateList(String dateString) {
  609.         Date date = parseDate(dateString);
  610.         if (Objects.isNull(date)) {
  611.             return Collections.emptyList();
  612.         }
  613.         return getDateStrList(getMonthDateList(date));
  614.     }
  616.     /**
  617.      * 获取本日期所在月第一天
  618.      * 
  619.      * @param date 日期
  620.      * @return 本日期所在月第一天
  621.      */
  622.     public static Date getMonthDateStart(Date date) {
  623.         if (Objects.isNull(date)) {
  624.             return null;
  625.         }
  626.         Calendar calendar = Calendar.getInstance();
  627.         calendar.setTime(date);
  628.         calendar.set(Calendar.DAY_OF_MONTH, 1);
  629.         return getDateStart(calendar.getTime());
  630.     }
  632.     /**
  633.      * 获取本日期所在月最后一天
  634.      * 
  635.      * @param date 日期
  636.      * @return 本日期所在月最后一天
  637.      */
  638.     public static Date getMonthDateEnd(Date date) {
  639.         if (Objects.isNull(date)) {
  640.             return null;
  641.         }
  642.         Date monthDateStart = getMonthDateStart(date);
  643.         Date nextMonthDateStart = getMonthDateStart(addMonth(monthDateStart, 1));
  644.         return getDateEnd(addDay(nextMonthDateStart, -1));
  645.     }
  647.     /**
  648.      * 获取两个日期相差的天数（以日期为单位计算，不以24小时制计算，详见下面说明）<br>
  649.      * 
  650.      * 【说明】比如 2022-06-17 23:00:00 和 2022-06-17 01:00:00，两者虽然只相差 2 个小时，但也算相差 1 天 <br>
  651.      * 
  652.      * @param date1 日期1
  653.      * @param date2 日期2
  654.      * @return 相差天数（若返回 -1，则至少有一个日期存在为空，此时不能进行比较）
  655.      */
  656.     public static int countBetweenDays(Date date1, Date date2) {
  657.         if (Objects.isNull(date1) || Objects.isNull(date2)) {
  658.             return -1;
  659.         }
  660.         // 获取两个日期 0 点 0 时 0 分 0 秒 0 毫秒时的时间戳（毫秒级）
  661.         long t1 = getDateStart(date1).getTime();
  662.         long t2 = getDateStart(date2).getTime();
  663.         // 相差天数 = 相差的毫秒数 / 一天的毫秒数
  664.         return (int) (Math.abs(t1 - t2) / DAY_MILLISECONDS);
  665.     }
  667.     /**
  668.      * 获取两个日期之间的所有日期
  669.      * 
  670.      * @param date1 日期1
  671.      * @param date2 日期2
  672.      * @return 两个日期之间的所有日期的开始时间
  673.      */
  674.     public static List<Date> getBetweenDateList(Date date1, Date date2) {
  675.         return getBetweenDateList(date1, date2, false);
  676.     }
  678.     /**
  679.      * 获取两个日期之间的所有日期
  680.      * 
  681.      * @param date1 日期1
  682.      * @param date2 日期2
  683.      * @return 两个日期之间的所有日期的开始时间
  684.      */
  685.     public static List<Date> getBetweenDateList(Date date1, Date date2, boolean isContainParams) {
  686.         if (Objects.isNull(date1) || Objects.isNull(date2)) {
  687.             return Collections.emptyList();
  688.         }
  689.         // 确定前后日期
  690.         Date fromDate = date1;
  691.         Date toDate = date2;
  692.         if (date2.before(date1)) {
  693.             fromDate = date2;
  694.             toDate = date1;
  695.         }
  696.         // 获取两个日期每天的开始时间
  697.         Date from = getDateStart(fromDate);
  698.         Date to = getDateStart(toDate);
  699.         // 获取日期，开始循环
  700.         List<Date> dates = new ArrayList<Date>();
  701.         if (isContainParams) {
  702.             dates.add(from);
  703.         }
  704.         Date date = from;
  705.         boolean isBefore = true;
  706.         while (isBefore) {
  707.             date = addDay(date, 1);
  708.             isBefore = date.before(to);
  709.             if (isBefore) {
  710.                 dates.add(getDateStart(date));
  711.             }
  712.         }
  713.         if (isContainParams) {
  714.             dates.add(to);
  715.         }
  716.         return dates;
  717.     }
  719.     /**
  720.      * 获取两个日期之间的所有日期
  721.      * 
  722.      * @param dateString1 日期1（如：2022-06-20）
  723.      * @param dateString2 日期2（如：2022-07-15）
  724.      * @return 两个日期之间的所有日期（不包含参数日期）
  725.      */
  726.     public static List<String> getBetweenDateList(String dateString1, String dateString2) {
  727.         return getBetweenDateList(dateString1, dateString2, false);
  728.     }
  730.     /**
  731.      * 获取两个日期之间的所有日期
  732.      * 
  733.      * @param dateString1     日期1（如：2022-06-20）
  734.      * @param dateString2     日期2（如：2022-07-15）
  735.      * @param isContainParams 是否包含参数的两个日期
  736.      * @return 两个日期之间的所有日期的开始时间
  737.      */
  738.     public static List<String> getBetweenDateList(String dateString1, String dateString2, boolean isContainParams) {
  739.         Date date1 = parseDate(dateString1);
  740.         Date date2 = parseDate(dateString2);
  741.         List<Date> dates = getBetweenDateList(date1, date2, isContainParams);
  742.         return getDateStrList(dates);
  743.     }
  745.     /**
  746.      * List<Date> 转 List<String>
  747.      * 
  748.      * @param dates 日期集合
  749.      * @return 日期字符串集合
  750.      */
  751.     public static List<String> getDateStrList(List<Date> dates) {
  752.         if (dates.isEmpty()) {
  753.             return Collections.emptyList();
  754.         }
  755.         List<String> dateList = new ArrayList<String>();
  756.         for (Date date : dates) {
  757.             dateList.add(formatDate(date));
  758.         }
  759.         return dateList;
  760.     }
  762.     static class DateNode {
  763.         /** 年 */
  764.         private int year;
  765.         /** 月 */
  766.         private int month;
  767.         /** 日 */
  768.         private int day;
  769.         /** 时 */
  770.         private int hour;
  771.         /** 分 */
  772.         private int minute;
  773.         /** 秒 */
  774.         private int second;
  775.         /** 毫秒 */
  776.         private int millisecond;
  777.         /** 星期几（ 1 - 7 对应周一到周日） */
  778.         private int week;
  779.         /** 当年第几天 */
  780.         private int dayOfYear;
  781.         /** 当年第几周（本年周 1 为第 1 周，0 则表示属于去年最后一周） */
  782.         private int weekOfYear;
  783.         /** 当年第几周（本年周 1 为第 1 周，0 则表示属于去年最后一周） */
  784.         private int weekOfYearIgnoreLastYear;
  785.         /** 时间戳（秒级） */
  786.         private long secondStamp;
  787.         /** 时间戳（毫秒级） */
  788.         private long millisecondStamp;
  789.         /** 显示时间 */
  790.         private String time;
  792.         public int getYear() {
  793.             return year;
  794.         }
  796.         public void setYear(int year) {
  797.             this.year = year;
  798.         }
  800.         public int getMonth() {
  801.             return month;
  802.         }
  804.         public void setMonth(int month) {
  805.             this.month = month;
  806.         }
  808.         public int getDay() {
  809.             return day;
  810.         }
  812.         public void setDay(int day) {
  813.             this.day = day;
  814.         }
  816.         public int getHour() {
  817.             return hour;
  818.         }
  820.         public void setHour(int hour) {
  821.             this.hour = hour;
  822.         }
  824.         public int getMinute() {
  825.             return minute;
  826.         }
  828.         public void setMinute(int minute) {
  829.             this.minute = minute;
  830.         }
  832.         public int getSecond() {
  833.             return second;
  834.         }
  836.         public void setSecond(int second) {
  837.             this.second = second;
  838.         }
  840.         public int getMillisecond() {
  841.             return millisecond;
  842.         }
  844.         public void setMillisecond(int millisecond) {
  845.             this.millisecond = millisecond;
  846.         }
  848.         public int getWeek() {
  849.             return week;
  850.         }
  852.         public void setWeek(int week) {
  853.             this.week = week;
  854.         }
  856.         public int getDayOfYear() {
  857.             return dayOfYear;
  858.         }
  860.         public void setDayOfYear(int dayOfYear) {
  861.             this.dayOfYear = dayOfYear;
  862.         }
  864.         public int getWeekOfYear() {
  865.             return weekOfYear;
  866.         }
  868.         public void setWeekOfYear(int weekOfYear) {
  869.             this.weekOfYear = weekOfYear;
  870.         }
  872.         public int getWeekOfYearIgnoreLastYear() {
  873.             return weekOfYearIgnoreLastYear;
  874.         }
  876.         public void setWeekOfYearIgnoreLastYear(int weekOfYearIgnoreLastYear) {
  877.             this.weekOfYearIgnoreLastYear = weekOfYearIgnoreLastYear;
  878.         }
  880.         public long getSecondStamp() {
  881.             return secondStamp;
  882.         }
  884.         public void setSecondStamp(long secondStamp) {
  885.             this.secondStamp = secondStamp;
  886.         }
  888.         public long getMillisecondStamp() {
  889.             return millisecondStamp;
  890.         }
  892.         public void setMillisecondStamp(long millisecondStamp) {
  893.             this.millisecondStamp = millisecondStamp;
  894.         }
  896.         public String getTime() {
  897.             return time;
  898.         }
  900.         public void setTime(String time) {
  901.             this.time = time;
  902.         }
  904.     }
  905. }

发表评论

表情：
评论列表 （有 0 条评论，210人围观）

还没有评论，来说两句吧...

相关阅读