• Java中时间工具类

    最近总结了一下时间相关的用法，如下。

    1、日期转换为字符串 默认"yyyy-MM-dd HH:mm:ss"

    2、任意类型日期字符串转时间

    3、获取当前对应格式的日期

    4、获取当前对应格式的日期 默认"yyyyMMddHHmmssSSS"

    5、计算该天是星期几

    6、获取星期几，java中一周中的数字 转 常规一周中的数字

    7、根据日期获取星期

    8、获取一个月的开始和结束时间

    9、获取一年的开始和结束时间

    10、获取季度

    11、获取某月 所有日期（yyyy-mm-dd格式字符串）

    12、获取一周的开始和结束时间

    13、获取某周 所有日期（yyyy-mm-dd格式字符串）

    14、 计算两个日期之间相差的秒数

    15、计算两个日期之间相差的天数

    16、根据日期判断是上午下午还是晚上

    17、获取该月有多少天

    18、计算开始时间和结束时间的差值，转成多少天

    ..........等等

    等等相关用方法，比较感兴趣，可以参照具体方法具体查看。

    1.  
    2. import org.apache.commons.lang3.StringUtils;
    3. import org.springframework.util.Assert;
    4.  
    5. import java.math.BigDecimal;
    6. import java.sql.Timestamp;
    7. import java.text.ParseException;
    8. import java.text.ParsePosition;
    9. import java.text.SimpleDateFormat;
    10. import java.time.LocalTime;
    11. import java.util.*;
    12.  
    13. /**
    14.  * 时间工具类
    15.  */
    16. public class DateUtils {
    17.  
    18.  
    19.     private static final String TIMESTAMP_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";
    20.     private static final String DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    21.     private static final String DATE_FORMAT = "yyyy-MM-dd";
    22.     private static final String DATE_SIMPLE_FORMAT = "yyyyMMdd";
    23.  
    24.     //====================================时间转换=======================================>>
    25.  
    26.     /**
    27.      * 时长转换
    28.      *
    29.      * @param time 通话时长（秒）
    30.      * @return 几小时几分钟几秒
    31.      */
    32.     public static String getStrTime(Integer time) {
    33.         if (time == null || time == 0) return "";
    34.         StringBuilder str = new StringBuilder();
    35.         int hour = time / 3600;
    36.         if (hour != 0) str.append(hour).append("小时");
    37.         int minutes = (time - hour * 3600) / 60;
    38.         if (minutes != 0) str.append(minutes).append("分钟");
    39.         int seconds = time - hour * 3600 - minutes * 60;
    40.         if (seconds != 0) str.append(seconds).append("秒");
    41.         return str.toString();
    42.     }
    43.  
    44.     public static String millisToStr(long time) {
    45.         if (time <= 0) return "0 秒";
    46.         if (time < 1000) {
    47.             return (time / 1000.0f) + "秒";
    48.         }
    49.         return getStrTime((int) time / 1000);
    50.     }
    51.  
    52.     public static String millisDiff(long time) {
    53.         return millisToStr(System.currentTimeMillis() - time);
    54.     }
    55.  
    56.     /**
    57.      * 日期转换为字符串 默认"yyyy-MM-dd HH:mm:ss"
    58.      *
    59.      * @param date 日期
    60.      */
    61.     public static String dateToStr(Date date) {
    62.         return dateToStr(date, null);
    63.     }
    64.  
    65.     /**
    66.      * 日期转换为字符串
    67.      *
    68.      * @param date   日期
    69.      * @param format 日期格式
    70.      */
    71.     public static String dateToStr(Date date, String format) {
    72.         if (date == null) return null;
    73.         // 如果没有指定字符串转换的格式，则用默认格式进行转换
    74.         if (null == format || "".equals(format) || "Datetime".equals(format)) {
    75.             format = DATETIME_FORMAT;
    76.         } else if ("Timestamp".equals(format)) {
    77.             format = TIMESTAMP_FORMAT;
    78.         } else if ("Date".equals(format)) {
    79.             format = DATE_FORMAT;
    80.         } else if ("DateSimple".equals(format)) {
    81.             format = DATE_SIMPLE_FORMAT;
    82.         } else if ("Simple".equals(format)) {
    83.             format = DATE_SIMPLE_FORMAT;
    84.         }
    85.         SimpleDateFormat sdf = new SimpleDateFormat(format);
    86.         return sdf.format(date);
    87.     }
    88.  
    89.     /**
    90.      * 任意类型日期字符串转时间
    91.      */
    92.     public static Date strToDate(String time) {
    93.         if (StringUtils.isBlank(time)) return null;
    94.         SimpleDateFormat formatter;
    95.         int tempPos = time.indexOf("AD");
    96.         time = time.trim();
    97.         formatter = new SimpleDateFormat("yyyy.MM.dd G 'at' hh:mm:ss z");
    98.         if (tempPos > -1) {
    99.             time = time.substring(0, tempPos) +
    100.                     "公元" + time.substring(tempPos + "AD".length());//china
    101.             formatter = new SimpleDateFormat("yyyy.MM.dd G 'at' hh:mm:ss z");
    102.         }
    103.         if (time.contains(".")) time = time.replaceAll("\\.", "/");
    104.         if (time.contains("-")) time = time.replaceAll("-", "/");
    105.         if (!time.contains("/") && !time.contains(" ")) {
    106.             formatter = new SimpleDateFormat("yyyyMMddHHmmss");
    107.         } else if (time.contains("/")) {
    108.             if (time.contains("am") || time.contains("pm")) formatter = new SimpleDateFormat("yyyy/MM/dd KK:mm:ss a");
    109.             else if (time.contains(" ")) formatter = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    110.             else {
    111.                 String[] dateArr = time.split("/");
    112.                 if (dateArr.length == 2 || (dateArr.length == 3 && StringUtils.isBlank(dateArr[2])))
    113.                     formatter = new SimpleDateFormat("yyyy/MM");
    114.                 else formatter = new SimpleDateFormat("yyyy/MM/dd");
    115.             }
    116.         }
    117.         ParsePosition pos = new ParsePosition(0);
    118.         return formatter.parse(time, pos);
    119.     }
    120.  
    121.     public static Date strToDate(String time, String formatterString) {
    122.         if (StringUtils.isBlank(time) || StringUtils.isBlank(formatterString)) return null;
    123.         SimpleDateFormat formatter = new SimpleDateFormat(formatterString);
    124.         ParsePosition pos = new ParsePosition(0);
    125.         return formatter.parse(time, pos);
    126.     }
    127.  
    128.     public static Date strToDateThrow(String time) {
    129.         if (StringUtils.isBlank(time)) return null;
    130.         Date value = strToDate(time);
    131.         Assert.notNull(value, "无法识别日期格式: " + value);
    132.         return value;
    133.     }
    134.  
    135.     //====================================时间获取=======================================>>
    136.  
    137.     /**
    138.      * 获取当前对应格式的日期
    139.      */
    140.     public static String getDateStr() {
    141.         return getDateStr(null);
    142.     }
    143.  
    144.     /**
    145.      * 获取当前对应格式的日期 默认"yyyyMMddHHmmssSSS"
    146.      *
    147.      * @param format 日期格式
    148.      */
    149.     public static String getDateStr(String format) {
    150.         if (null == format || "".equals(format)) {
    151.             format = "yyyyMMddHHmmssSSS";
    152.         }
    153.         Date date = new Date();
    154.         SimpleDateFormat df = new SimpleDateFormat(format);
    155.         return df.format(date);
    156.     }
    157.  
    158.  
    159.  
    160.     /**
    161.      * 获取星期几，java中一周中的数字 转 常规一周中的数字
    162.      * java中 周日=1 周六=7
    163.      * eg:
    164.      * 周一 -> 1
    165.      * 周日 -> 7
    166.      *
    167.      * @param dayOfWeek java中一周中的数字
    168.      */
    169.     public static int getIsoDayOfWeek(int dayOfWeek) {
    170.         int result;
    171.         if (dayOfWeek == 1) {
    172.             result = 7;
    173.         } else {
    174.             result = dayOfWeek - 1;
    175.         }
    176.         return result;
    177.     }
    178.  
    179.  
    180.     /**
    181.      * 根据日期获取星期
    182.      */
    183.     public static String getWeekOfDate(Date date) {
    184.         String[] weekDays = {"sun", "mon", "tue", "wed", "thu", "fri", "sat"};
    185.         Calendar cal = Calendar.getInstance();
    186.         cal.setTime(date);
    187.         int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
    188.         if (w < 0) w = 0;
    189.         return weekDays[w];
    190.     }
    191.  
    192.     //获取一个月的开始和结束时间
    193.     public static List getMonthFirstAndEndDay(Date date) {
    194.         List result = new ArrayList<>();
    195.         Calendar c = Calendar.getInstance();
    196.         c.setTime(date);
    197.         c.set(Calendar.HOUR_OF_DAY, 0);
    198.         c.set(Calendar.MINUTE, 0);
    199.         c.set(Calendar.SECOND, 0);
    200.         c.set(Calendar.MILLISECOND, 0);
    201.  
    202.         c.set(Calendar.DAY_OF_MONTH, 1);//设置为1号
    203.         result.add(c.getTime());
    204.  
    205.         c.add(Calendar.MONTH, 1);//加一个月
    206.         c.add(Calendar.MILLISECOND, -1);//减一毫秒
    207.         result.add(c.getTime());
    208.  
    209.         return result;
    210.     }
    211.  
    212.     //获取一年的开始和结束时间
    213.     public static List getYearFirstAndEndDay(Date date) {
    214.         List result = new ArrayList<>();
    215.         Calendar c = Calendar.getInstance();
    216.         c.setTime(date);
    217.         c.set(Calendar.MONTH, 0);
    218.         c.set(Calendar.DATE, 1);
    219.         c.set(Calendar.HOUR_OF_DAY, 0);
    220.         c.set(Calendar.MINUTE, 0);
    221.         c.set(Calendar.SECOND, 0);
    222.         c.set(Calendar.MILLISECOND, 0);
    223.  
    224.         result.add(c.getTime());
    225.  
    226.         c.add(Calendar.YEAR, 1);//加一年
    227.         c.add(Calendar.MILLISECOND, -1);//减一毫秒
    228.         result.add(c.getTime());
    229.  
    230.         return result;
    231.     }
    232.  
    233.     public static Date getYearStartTime(Date date) {
    234.         Calendar calendar = Calendar.getInstance();
    235.         calendar.setTime(date);
    236.         calendar.add(Calendar.YEAR, 0);
    237.         calendar.add(Calendar.DATE, 0);
    238.         calendar.add(Calendar.MONTH, 0);
    239.         calendar.set(Calendar.DAY_OF_YEAR, 1);
    240.         calendar.set(Calendar.HOUR_OF_DAY, 0);
    241.         calendar.set(Calendar.MINUTE, 0);
    242.         calendar.set(Calendar.SECOND, 0);
    243.         calendar.set(Calendar.MILLISECOND, 0);
    244.         return calendar.getTime();
    245.     }
    246.  
    247.     /**
    248.      * 获取季度
    249.      */
    250.     public static int getQuarter(Date date) {
    251.         int quarter = 0;
    252.         Calendar c = Calendar.getInstance();
    253.         c.setTime(date);
    254.         int month = c.get(Calendar.MONTH);
    255.         switch (month) {
    256.             case Calendar.JANUARY:
    257.             case Calendar.FEBRUARY:
    258.             case Calendar.MARCH:
    259.                 quarter = 1;
    260.                 break;
    261.             case Calendar.APRIL:
    262.             case Calendar.MAY:
    263.             case Calendar.JUNE:
    264.                 quarter = 2;
    265.                 break;
    266.             case Calendar.JULY:
    267.             case Calendar.AUGUST:
    268.             case Calendar.SEPTEMBER:
    269.                 quarter = 3;
    270.                 break;
    271.             case Calendar.OCTOBER:
    272.             case Calendar.NOVEMBER:
    273.             case Calendar.DECEMBER:
    274.                 quarter = 4;
    275.                 break;
    276.         }
    277.         return quarter;
    278.     }
    279.  
    280.     /**
    281.      * 获取某月 所有日期（yyyy-mm-dd格式字符串）
    282.      */
    283.     public static List getMonthFullDay(Date date) {
    284.         SimpleDateFormat dateFormatYYYYMMDD = new SimpleDateFormat(DATE_FORMAT);
    285.         List fullDayList = new ArrayList<>();
    286.         // 获得当前日期对象
    287.         Calendar c = Calendar.getInstance();
    288.         c.setTime(date);
    289.         c.set(Calendar.HOUR_OF_DAY, 0);
    290.         c.set(Calendar.MINUTE, 0);
    291.         c.set(Calendar.SECOND, 0);
    292.         c.set(Calendar.MILLISECOND, 0);
    293.         // 当月1号
    294.         c.set(Calendar.DAY_OF_MONTH, 1);
    295.         int count = c.getActualMaximum(Calendar.DAY_OF_MONTH);
    296.         for (int j = 1; j <= count; j++) {
    297.             fullDayList.add(dateFormatYYYYMMDD.format(c.getTime()));
    298.             c.add(Calendar.DAY_OF_MONTH, 1);
    299.         }
    300.         return fullDayList;
    301.     }
    302.  
    303.  
    304.     /**
    305.      * 获取一周的开始和结束时间
    306.      */
    307.     public static List dateToWeekStartAndEnd(Date date) {
    308.         List result = new ArrayList<>();
    309.         Calendar c = Calendar.getInstance();
    310.         c.setTime(date);
    311.         c.set(Calendar.HOUR_OF_DAY, 0);
    312.         c.set(Calendar.MINUTE, 0);
    313.         c.set(Calendar.SECOND, 0);
    314.         c.set(Calendar.MILLISECOND, 0);
    315.  
    316.         c.set(Calendar.DAY_OF_WEEK, 2);//设置为星期1
    317.         result.add(c.getTime());
    318.  
    319.         c.add(Calendar.DAY_OF_WEEK_IN_MONTH, 1);//加一个周
    320.         c.add(Calendar.MILLISECOND, -1);//减一毫秒
    321.         result.add(c.getTime());
    322.  
    323.         return result;
    324.     }
    325.  
    326.     /**
    327.      * 获取某周 所有日期（yyyy-mm-dd格式字符串）
    328.      */
    329.     public static List getWeekFullDay(Date date) {
    330.         SimpleDateFormat dateFormatYYYYMMDD = new SimpleDateFormat(DATE_FORMAT);
    331.         List fullDayList = new ArrayList<>();
    332.         // 获得当前日期对象
    333.         Calendar c = Calendar.getInstance();
    334.         c.setTime(date);
    335.         c.set(Calendar.HOUR_OF_DAY, 0);
    336.         c.set(Calendar.MINUTE, 0);
    337.         c.set(Calendar.SECOND, 0);
    338.         c.set(Calendar.MILLISECOND, 0);
    339.         //周一
    340.         c.set(Calendar.DAY_OF_WEEK, 2);
    341.         int count = c.getActualMaximum(Calendar.DAY_OF_WEEK);
    342.         for (int j = 1; j <= count; j++) {
    343.             fullDayList.add(dateFormatYYYYMMDD.format(c.getTime()));
    344.             c.add(Calendar.DAY_OF_WEEK, 1);
    345.         }
    346.         return fullDayList;
    347.     }
    348.  
    349.     /**
    350.      * 获取当前date的上周的周一
    351.      */
    352.     public static Date getLastWeekMonday(Date date) {
    353.         Date monday = getWeekMonday(date);
    354.         Date lastDate = getLastSec(monday);
    355.         return getWeekMonday(lastDate);
    356.     }
    357.  
    358.     /**
    359.      * 获取当前date的所在周的周一
    360.      */
    361.     public static Date getWeekMonday(Date date) {
    362.         Calendar calendar = new GregorianCalendar();
    363.         calendar.setTime(date);
    364.         calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
    365.         calendar.set(Calendar.HOUR_OF_DAY, 0);
    366.         calendar.set(Calendar.MINUTE, 0);
    367.         calendar.set(Calendar.SECOND, 0);
    368.         calendar.set(Calendar.MILLISECOND, 0);
    369.         return calendar.getTime();
    370.     }
    371.  
    372.     /**
    373.      * 获取一天的开始时间和结束时间
    374.      */
    375.     public static List dateToDayStartAndEnd(Date date) {
    376.         List result = new ArrayList<>();
    377.         Calendar c = Calendar.getInstance();
    378.         c.setTime(date);
    379.         //将时分秒,毫秒域清零
    380.         c.set(Calendar.HOUR_OF_DAY, 0);
    381.         c.set(Calendar.MINUTE, 0);
    382.         c.set(Calendar.SECOND, 0);
    383.         c.set(Calendar.MILLISECOND, 0);
    384.         result.add(c.getTime());
    385.  
    386.         c.add(Calendar.DAY_OF_YEAR, 1);
    387.         c.add(Calendar.SECOND, -1);
    388.         result.add(c.getTime());
    389.         return result;
    390.     }
    391.  
    392.     /**
    393.      * 获取今天一天的开始时间和结束时间
    394.      */
    395.     public static List getToday() {
    396.         return dateToDayStartAndEnd(new Date());
    397.     }
    398.  
    399.     /**
    400.      * 获取 时间段内 所有日期（yyyy-mm-dd格式字符串）
    401.      */
    402.     public static List getFullDay(Date startTime, Date endTime) {
    403.         SimpleDateFormat dateFormatYYYYMMDD = new SimpleDateFormat(DATE_FORMAT);
    404.         List fullDayList = new ArrayList<>();
    405.         // 获得当前日期对象
    406.         Calendar s = Calendar.getInstance();
    407.         s.setTime(startTime);
    408.         s.set(Calendar.HOUR_OF_DAY, 0);
    409.         s.set(Calendar.MINUTE, 0);
    410.         s.set(Calendar.SECOND, 0);
    411.         s.set(Calendar.MILLISECOND, 0);
    412.         Calendar e = Calendar.getInstance();
    413.         e.setTime(endTime);
    414.         e.set(Calendar.HOUR_OF_DAY, 0);
    415.         e.set(Calendar.MINUTE, 0);
    416.         e.set(Calendar.SECOND, 0);
    417.         e.set(Calendar.MILLISECOND, 0);
    418.  
    419.         int daysBetween = getDaysBetween(s.getTime(), e.getTime());
    420.         for (int i = 0; i <= daysBetween; i++) {
    421.             fullDayList.add(dateFormatYYYYMMDD.format(s.getTime()));
    422.             s.add(Calendar.DAY_OF_MONTH, 1);
    423.         }
    424.         return fullDayList;
    425.     }
    426.  
    427.     //====================================时间计算=======================================>>
    428.  
    429.     /**
    430.      * 计算两个日期之间相差的秒数
    431.      *
    432.      * @param smdate 较小的时间
    433.      * @param bdate  较大的时间
    434.      * @return 相差秒数
    435.      */
    436.     public static int getSecsBetween(Date smdate, Date bdate) {
    437.         SimpleDateFormat sdf = new SimpleDateFormat(DATETIME_FORMAT);
    438.         try {
    439.             smdate = sdf.parse(sdf.format(smdate));
    440.             bdate = sdf.parse(sdf.format(bdate));
    441.         } catch (ParseException e) {
    442.             e.printStackTrace();
    443.         }
    444.         Calendar cal = Calendar.getInstance();
    445.         cal.setTime(smdate);
    446.         long time1 = cal.getTimeInMillis();
    447.         cal.setTime(bdate);
    448.         long time2 = cal.getTimeInMillis();
    449.         long between_days = (time2 - time1) / 1000;
    450.  
    451.         return Integer.parseInt(String.valueOf(between_days));
    452.     }
    453.  
    454.     /**
    455.      * 计算两个日期之间相差的天数
    456.      *
    457.      * @param smdate 较小的时间
    458.      * @param bdate  较大的时间
    459.      * @return 相差天数
    460.      */
    461.     public static int getDaysBetween(Date smdate, Date bdate) {
    462.         int second = getSecsBetween(smdate, bdate);
    463.         long between_days = second / 3600 / 24;
    464.  
    465.         return Integer.parseInt(String.valueOf(between_days));
    466.     }
    467.  
    468.     /**
    469.      * 根据日期判断是上午下午还是晚上
    470.      *
    471.      * @return 1:上午 2:下午 3:晚上
    472.      */
    473.     public static Integer getTimeByDate(Date date) {
    474.         if (date == null) return null;
    475.         Calendar c = Calendar.getInstance();
    476.         c.setTime(date);
    477.         int hour = c.get(Calendar.HOUR_OF_DAY);
    478.         if (hour <= 12) return 1;
    479.         else if (hour <= 18) return 2;
    480.         else return 3;
    481.     }
    482.  
    483.  
    484.     /**
    485.      * 该天是否为月末最后一天
    486.      */
    487.     public static boolean isLastDayOfMonth(Date date) {
    488.         Calendar calendar = Calendar.getInstance();
    489.         calendar.setTime(date);
    490.         calendar.set(Calendar.DATE, (calendar.get(Calendar.DATE) + 1));
    491.         return calendar.get(Calendar.DAY_OF_MONTH) == 1;
    492.     }
    493.  
    494.     /**
    495.      * 获取该月有多少天
    496.      */
    497.     public static int getDaysOfMonth(Date date) {
    498.         Calendar calendar = Calendar.getInstance();
    499.         calendar.setTime(date);
    500.         return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
    501.     }
    502.  
    503.  
    504.     /**
    505.      * 计算得到2个时间的差值，并转成中文
    506.      *
    507.      * @param startDate 开始时间
    508.      * @param endDate   结束时间
    509.      */
    510.     public static String getDateDiff(Date startDate, Date endDate) {
    511.         long nd = 1000 * 24 * 60 * 60;
    512.         long nh = 1000 * 60 * 60;
    513.         long nm = 1000 * 60;
    514.         long ns = 1000;
    515.         //long ns = 1000;
    516.         //获得两个时间的毫秒时间差异
    517.         long diff = endDate.getTime() - startDate.getTime();
    518.         //计算差多少天
    519.         long day = diff / nd;
    520.         //计算差多少小时
    521.         long hour = diff % nd / nh;
    522.         //计算差多少分钟
    523.         long min = diff % nd % nh / nm;
    524.         //计算差多少秒//输出结果
    525.         long sec = diff % nd % nh % nm / ns;
    526.         String result = "";
    527.         if (day > 0) result += day + "天";
    528.         if (hour > 0) result += hour + "小时";
    529.         if (min > 0) result += min + "分钟";
    530.         if (result.isEmpty()) result = sec + "秒";
    531.         return result;
    532.     }
    533.  
    534.     /**
    535.      * 计算开始时间和结束时间的差值，转成多少小时
    536.      *
    537.      * @param startDate 开始时间
    538.      * @param endDate   结束时间
    539.      * @return eg: 3.21 (小时)
    540.      */
    541.     public static BigDecimal getDateDiffHour(Date startDate, Date endDate) {
    542.         BigDecimal nh = new BigDecimal(1000 * 60 * 60);
    543.         BigDecimal diff = new BigDecimal(endDate.getTime() - startDate.getTime());
    544.         return diff.divide(nh, 2, BigDecimal.ROUND_HALF_UP);
    545.     }
    546.  
    547.     /**
    548.      * 计算开始时间和结束时间的差值，转成多少天
    549.      *
    550.      * @param startDate 开始时间
    551.      * @param endDate   结束时间
    552.      * @return eg: 3.21 (天)
    553.      */
    554.     public static BigDecimal getDateDiffDay(Date startDate, Date endDate) {
    555.         BigDecimal nh = new BigDecimal(1000 * 60 * 60 * 24);
    556.         BigDecimal diff = new BigDecimal(endDate.getTime() - startDate.getTime());
    557.         return diff.divide(nh, 2, BigDecimal.ROUND_HALF_UP);
    558.     }
    559.  
    560.  
    561.     //====================================获取时间段=======================================>>
    562.  
    563.     /**
    564.      * 获取这一周的date，从周一到周日
    565.      */
    566.     public static List dateToWeek(Date mdate) {
    567.         Calendar c = Calendar.getInstance();
    568.         c.setTime(mdate);
    569.         int b = c.get(Calendar.DAY_OF_WEEK) - 1;
    570.  
    571.         Date fdate;
    572.         List list = new ArrayList<>();
    573.         long fTime = mdate.getTime() - b * 24 * 3600000;
    574.         for (int a = 1; a <= 7; a++) {
    575.             fdate = new Date();
    576.             fdate.setTime(fTime + (a * 24 * 3600000));
    577.             list.add(a - 1, fdate);
    578.         }
    579.         return list;
    580.     }
    581.  
    582.     /**
    583.      * 获取前几天的date
    584.      */
    585.     public static List getDateListBefore(Date date, Integer num) {
    586.         if (date == null) return null;
    587.         List result = new ArrayList<>();
    588.         Calendar c = Calendar.getInstance();
    589.         c.setTime(date);
    590.         c.add(Calendar.DATE, -num);
    591.         for (int a = 1; a <= num; a++) {
    592.             c.add(Calendar.DATE, 1);
    593.             Date temp = c.getTime();
    594.             result.add(temp);
    595.         }
    596.         return result;
    597.     }
    598.  
    599.     /**
    600.      * 获取一周、月、年的date
    601.      */
    602.     public static List getDateListByKind(Date date, String kind) {
    603.         if (date == null || kind == null) return null;
    604.  
    605.         Calendar end = Calendar.getInstance();
    606.  
    607.         Calendar c = Calendar.getInstance();
    608.         c.setFirstDayOfWeek(Calendar.MONDAY);
    609.         c.setTime(date);
    610.         //将时分秒,毫秒域清零
    611.         c.set(Calendar.HOUR_OF_DAY, 0);
    612.         c.set(Calendar.MINUTE, 0);
    613.         c.set(Calendar.SECOND, 0);
    614.         c.set(Calendar.MILLISECOND, 0);
    615.         switch (kind) {
    616.             case "week":
    617.                 c.add(Calendar.DATE, c.getFirstDayOfWeek() - c.get(Calendar.DAY_OF_WEEK));
    618.                 end.setTime(c.getTime());
    619.                 end.add(Calendar.DATE, 7);
    620.                 break;
    621.             case "month":
    622.                 c.set(Calendar.DAY_OF_MONTH, 1);
    623.                 end.setTime(c.getTime());
    624.                 end.add(Calendar.MONTH, 1);
    625.                 break;
    626.             case "half":
    627.                 c.add(Calendar.MONTH, -6);
    628.                 c.set(Calendar.DAY_OF_MONTH, 1);
    629.                 end.setTime(date);
    630.                 end.set(Calendar.DAY_OF_MONTH, 1);
    631.                 end.add(Calendar.MONTH, 1);
    632.                 end.add(Calendar.DAY_OF_MONTH, -1);
    633.                 break;
    634.             case "year":
    635.                 c.set(Calendar.DAY_OF_YEAR, 1);
    636.                 end.setTime(c.getTime());
    637.                 end.add(Calendar.YEAR, 1);
    638.                 break;
    639.             default:
    640.                 return null;
    641.         }
    642.  
    643.         boolean setSec = false;
    644.         List result = new ArrayList<>();
    645.         while (c.before(end)) {
    646.             if (result.size() != 0 && !setSec) {
    647.                 //将时分秒,毫秒域清零
    648.                 c.set(Calendar.HOUR_OF_DAY, 23);
    649.                 c.set(Calendar.MINUTE, 59);
    650.                 c.set(Calendar.SECOND, 59);
    651.                 c.set(Calendar.MILLISECOND, 999);
    652.                 setSec = true;
    653.             }
    654.             result.add(c.getTime());
    655.             c.add(Calendar.DATE, 1);
    656.         }
    657.         return result;
    658.     }
    659.  
    660.     //====================================修改时间=======================================>>
    661.  
    662.     /**
    663.      * 获取前一秒
    664.      */
    665.     public static Date getLastSec(Date date) {
    666.         if (date == null) return null;
    667.         Calendar c = Calendar.getInstance();
    668.         c.setTime(date);
    669.         c.add(Calendar.SECOND, -1);
    670.         return c.getTime();
    671.     }
    672.  
    673.     /**
    674.      * 添加秒
    675.      */
    676.     public static Date getWhichSecs(Date date, int secs) {
    677.         if (date == null) return null;
    678.         Calendar c = Calendar.getInstance();
    679.         c.setTime(date);
    680.         c.add(Calendar.SECOND, secs);
    681.         return c.getTime();
    682.     }
    683.  
    684.     /**
    685.      * 添加分
    686.      */
    687.     public static Date getWhichMinute(Date date, int minute) {
    688.         if (date == null) return null;
    689.         Calendar c = Calendar.getInstance();
    690.         c.setTime(date);
    691.         c.add(Calendar.MINUTE, minute);
    692.         return c.getTime();
    693.     }
    694.  
    695.     /**
    696.      * 获取后一天
    697.      */
    698.     public static Date getNextDate(Date date) {
    699.         return addDay(date, 1);
    700.     }
    701.  
    702.     /**
    703.      * 添加天
    704.      */
    705.     public static Date addDay(Date date, Integer day) {
    706.         if (date == null || day == null) return null;
    707.         Calendar c = Calendar.getInstance();
    708.         c.setTime(date);
    709.         c.add(Calendar.DATE, day);
    710.         return c.getTime();
    711.     }
    712.  
    713.     /**
    714.      * 添加月
    715.      */
    716.     public static Date addMonth(Date date, Integer month) {
    717.         if (date == null || month == null) return null;
    718.         if (month == 0) return date;
    719.         Calendar c = Calendar.getInstance();
    720.         c.setTime(date);
    721.         c.add(Calendar.MONTH, month);
    722.         return c.getTime();
    723.     }
    724.  
    725.     /**
    726.      * 添加年
    727.      */
    728.     public static Date addYear(Date date, Integer year) {
    729.         if (date == null || year == null) return null;
    730.         Calendar c = Calendar.getInstance();
    731.         c.setTime(date);
    732.         c.add(Calendar.YEAR, year);
    733.         return c.getTime();
    734.     }
    735.  
    736.     /**
    737.      * 清除时分秒
    738.      */
    739.     public static Date clearTime(Date date) {
    740.         Calendar c = Calendar.getInstance();
    741.         c.setTime(date);
    742.         //将时分秒,毫秒域清零
    743.         c.set(Calendar.HOUR_OF_DAY, 0);
    744.         c.set(Calendar.MINUTE, 0);
    745.         c.set(Calendar.SECOND, 0);
    746.         c.set(Calendar.MILLISECOND, 0);
    747.         return c.getTime();
    748.     }
    749.  
    750.     /**
    751.      * 清除秒
    752.      */
    753.     public static Date clearSec(Date date) {
    754.         Calendar c = Calendar.getInstance();
    755.         c.setTime(date);
    756.         c.set(Calendar.SECOND, 0);
    757.         c.set(Calendar.MILLISECOND, 0);
    758.         return c.getTime();
    759.     }
    760.  
    761.     /**
    762.      * 将时分秒设置成当前时间
    763.      */
    764.     public static Date setTimeToNow(Date date) {
    765.         return setTime(date, new Date());
    766.     }
    767.  
    768.     /**
    769.      * 将时分秒设置成新时间
    770.      */
    771.     public static Date setTime(Date date, Date newDate) {
    772.         if (date == null) return null;
    773.         Calendar c = Calendar.getInstance();
    774.         c.setTime(date);
    775.         Calendar now = Calendar.getInstance();
    776.         now.setTime(newDate);
    777.         //将时分秒,毫秒域清零
    778.         c.set(Calendar.HOUR_OF_DAY, now.get(Calendar.HOUR_OF_DAY));
    779.         c.set(Calendar.MINUTE, now.get(Calendar.MINUTE));
    780.         c.set(Calendar.SECOND, now.get(Calendar.SECOND));
    781.         c.set(Calendar.MILLISECOND, now.get(Calendar.MILLISECOND));
    782.         return c.getTime();
    783.     }
    784.  
    785.     /**
    786.      * Timestamp时间戳转date
    787.      *
    788.      * @param timestamp 时间戳
    789.      */
    790.     public static Date timeToDate(Timestamp timestamp) {
    791.         // Timestamp -> String
    792.         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    793.         String dateString = formatter.format(timestamp);
    794.         return DateUtils.strToDate(dateString);
    795.     }
    796.  
    797.     public static boolean isWorkTime() {
    798.         LocalTime now = LocalTime.now();
    799.         return (now.isAfter(LocalTime.of(5, 0)) && now.isBefore(LocalTime.of(18, 0))) ||
    800.                 now.isAfter(LocalTime.of(0, 0)) && now.isBefore(LocalTime.of(1, 0));
    801.     }
    802.  
    803.     public static String ehrTimeTransform(String time) {
    804.         if (StringUtils.isBlank(time)) return null;
    805.         String format;
    806.         if (time.length() == 8) {
    807.             format = "yyyyMMdd";
    808.         } else if (time.length() == 14) {
    809.             format = "yyyyMMddHHmmss";
    810.         } else {
    811.             format = "yyyy-MM-dd HH:mm:ss";
    812.         }
    813.         return DateUtils.dateToStr(DateUtils.strToDate(time, format), "yyyy-MM-dd HH:mm:ss");
    814.     }
    815.  
    816.  
    817.     public static void awaitFreeTime() {
    818.         while (isWorkTime()) {
    819.             try {
    820.                 Thread.sleep(600000);
    821.             } catch (InterruptedException e) {
    822.                 throw new IllegalArgumentException("任务等待失败");
    823.             }
    824.         }
    825.         System.out.println("等待结束");
    826.     }
    827.  
    828. }

    以上就是时间相关的处理的方法，感兴趣的可以看看

  • 相关阅读:
    树莓派4B_OpenCv学习笔记15：OpenCv定位物体实时坐标
    基于AlexNet卷积神经网络的手写体数字倾斜校正系统研究-附Matlab代码
    redhat7.6安装weblogic12c
    nginx的location的优先级和匹配方式和nginx的重定向
    Vue3基础——数据双向绑定、常用指令、计算属性、watch监听数据变化、class类名&style样式多种操作方式
    Servlet开发-session和cookie理解案例-登录页面
    【小笔记】基于SpringBoot使用WebSocket进行前后端通信
    linux如何查看各个文件夹大小
    二叉树的OJ题——C++
    用visa进行仪表通信
  • 原文地址：https://blog.csdn.net/ProBaiXiaodi/article/details/126977770