devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

日期工具类（格式化日期）_calendar 格式化

作者：Monodyee | 2024-04-06 13:44:14

赞

踩

calendar 格式化
  1. package com.atc.frame.base.utils;
  2.  
  3. import org.slf4j.Logger;
  4.  
  5. import java.text.ParseException;
  6. import java.text.SimpleDateFormat;
  7. import java.time.Instant;
  8. import java.util.*;
  9.  
  10. /**
  11.  * 日期工具类
  12.  *
  13.  * @author yechao
  14.  * @date 2013年12月12日
  15.  */
  16. public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
  17.  
  18.     private static final Logger logger = LogUtils.getLogger(DateUtils.class);
  19.  
  20.     /**
  21.      * 前端效期格式
  22.      */
  23.     public static String yyyyMMddEXPIRYDATE = "yyyyMMdd";
  24.  
  25.     public static String MMMdd_comma_yyyyhhmmaa = "MMM dd,yyyy hh:mm aa";
  26.  
  27.     public static String MMMdd_comma_yyyyHHmmaa = "MMM dd,yyyy HH:mm aa";
  28.  
  29.     public static String MMMdd_comma_yyyy_comma_hhmmaa = "MMM dd,yyyy, hh:mm aa";
  30.  
  31.     public static String MMMdd_comma_yyyy_comma_HHmmaa = "MMM dd,yyyy, HH:mm aa";
  32.  
  33.     public final static String YYYYMMDD_HH24MISS = "yyyy-MM-DD HH24:MI:SS";
  34.  
  35.     public final static String D1970 = "1970-01-01 00:00:00";
  36.     public final static Date DATE1970 = parse(D1970);
  37.  
  38.     /**
  39.      * 日期格式，精确到年份
  40.      */
  41.     public static final String DF_YYYY = "yyyy";
  42.     /**
  43.      * 日期格式，精确到月份
  44.      */
  45.     public static final String YYYY_MM = "yyyy-MM";
  46.     /**
  47.      * 日期格式，精确到天数
  48.      */
  49.     public static final String YYYY_MM_DD = "yyyy-MM-dd";
  50.     /**
  51.      * 日期格式,精确到小时
  52.      */
  53.     public static final String YYYY_MM_DD_HH = "yyyy-MM-dd HH";
  54.     /**
  55.      * 日期格式,精确到分钟
  56.      */
  57.     public static final String YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
  58.     /**
  59.      * 日期格式，精确到秒
  60.      */
  61.     public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
  62.     /**
  63.      * 日期格式，精确到毫秒
  64.      */
  65.     public static final String YYYY_MM_DD_HH_MM_SS_S = "yyyy-MM-dd HH:mm:ss.S";
  66.     /**
  67.      * 日期格式，精确到毫秒
  68.      */
  69.     public static final String YYYY_MM_DD_HH_MM_SS_SS = "yyyy-MM-dd HH:mm:ss.SS";
  70.     /**
  71.      * 日期格式，精确到毫秒
  72.      */
  73.     public static final String YYYY_MM_DD_HH_MM_SS_SSS = "yyyy-MM-dd HH:mm:ss.SSS";
  74.  
  75.     /**
  76.      * 无‘-’分隔符日期格式，精确到天数
  77.      */
  78.     public static final String YYYYMMDD = "yyyyMMdd";
  79.  
  80.     /**
  81.      * 无‘-’分隔符日期格式,精确到分钟
  82.      */
  83.     public static final String YYYYMMDDHHMM = "yyyyMMddHHmm";
  84.     /**
  85.      * 无‘-’分隔符日期格式,精确到秒
  86.      */
  87.     public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
  88.     /**
  89.      * 无‘-’分隔符日期格式,精确到毫秒
  90.      */
  91.     public static final String YYYYMMDDHHMMSSSSS = "yyyyMMddHHmmssSSS";
  92.  
  93.     /**
  94.      * @Description 私有构造方法
  95.      * @Para[][]
  96.      * @Author weibin
  97.      * @D2018/12/17211:531:44
  98.      * @Return
  99.      **/
  100.     private DateUtils() {
  101.     }
  102.  
  103.     /**
  104.      * 字符串的日期类型 转换称 Date 类型
  105.      *
  106.      * @param timeContent 字符串的日期类型
  107.      * @param formatStyle 日期格式
  108.      * @return
  109.      */
  110.     public static Date stringConvertDate(String timeContent, String formatStyle) {
  111.         if (StringUtils.isEmpty(timeContent)) {
  112.             return null;
  113.         }
  114.         SimpleDateFormat format = new SimpleDateFormat(formatStyle);
  115.         try {
  116.             return format.parse(timeContent);
  117.         } catch (Exception e) {
  118.             e.printStackTrace();
  119.         }
  120.         return null;
  121.     }
  122.  
  123.     /**
  124.      * 检查日期格式
  125.      *
  126.      * @param time
  127.      * @param format
  128.      * @return
  129.      */
  130.     public static boolean checkDate(String time, String format) {
  131.         if (stringConvertDate(time, format) == null) {
  132.             return false;
  133.         }
  134.         return true;
  135.     }
  136.  
  137.     /**
  138.      * Date 转化成 String 类型的字符串日期格式
  139.      *
  140.      * @param date
  141.      * @param formatStyle 转化成 什么格式
  142.      * @return
  143.      */
  144.     public static String dateConvertString(Date date, String formatStyle) {
  145.         if (date == null) {
  146.             return null;
  147.         }
  148.         SimpleDateFormat format = new SimpleDateFormat(formatStyle);
  149.         return format.format(date);
  150.     }
  151.  
  152.     public static String dateConvertStringForExpiryDate(Date date) {
  153.         SimpleDateFormat format = new SimpleDateFormat(YYYY_MM_DD);
  154.         if (date == null) {
  155.             return format.format(new Date());
  156.         }
  157.         return format.format(date);
  158.     }
  159.  
  160.     /**
  161.      * 字符串日期格式 转换成 带 地区标识的 Date 类型
  162.      *
  163.      * @param strDate
  164.      * @param locale
  165.      * @param formatStyle
  166.      * @return
  167.      */
  168.     public static Date stringConvertLocalDate(String strDate, Locale locale, String formatStyle) {
  169.         SimpleDateFormat srcsdf = new SimpleDateFormat(formatStyle, locale);
  170.         try {
  171.             return srcsdf.parse(strDate);
  172.         } catch (ParseException e) {
  173.             e.printStackTrace();
  174.         }
  175.         return null;
  176.     }
  177.  
  178.     /**
  179.      * 获取本地时间相对的UTC | GMT时间
  180.      *
  181.      * @return
  182.      */
  183.     public static Date getUtcTime() {
  184.         // 1、取得本地时间：
  185.         Calendar calendar = java.util.Calendar.getInstance();
  186.         // 2、取得时间偏移量：
  187.         final int zoneOffset = calendar.get(java.util.Calendar.ZONE_OFFSET);
  188.         // 3、取得夏令时差：
  189.         final int dstOffset = calendar.get(java.util.Calendar.DST_OFFSET);
  190.         // 4、从本地时间里扣除这些差量，即可以取得UTC时间：
  191.         calendar.add(java.util.Calendar.MILLISECOND, -(zoneOffset + dstOffset));
  192.         return calendar.getTime();
  193.     }
  194.  
  195.  
  196.     /**
  197.      * 获取本地时间相对的UTC | GMT时间
  198.      *
  199.      * @return
  200.      */
  201.     public static int getOffset() {
  202.         // 1、取得本地时间：
  203.         Calendar calendar = java.util.Calendar.getInstance();
  204.         // 2、取得时间偏移量：
  205.         int zoneOffset = calendar.get(java.util.Calendar.ZONE_OFFSET);
  206.         return zoneOffset;
  207.     }
  208.  
  209.     /**
  210.      * 获取2个时间相差多少秒
  211.      *
  212.      * @param date1
  213.      * @param date2
  214.      * @return
  215.      */
  216.     public static Long getDiffSeconds(Date date1, Date date2) {
  217.         long milliseconds1 = date1.getTime();
  218.         long milliseconds2 = date2.getTime();
  219.         long diff = milliseconds1 - milliseconds2;
  220.         if (diff < 0) {
  221.             diff = -diff;
  222.         }
  223.         long diffSeconds = diff / (1000);
  224.         return diffSeconds;
  225.     }
  226.  
  227.     /**
  228.      * 获取2个时间相差多少分钟
  229.      *
  230.      * @param date1
  231.      * @param date2
  232.      * @return
  233.      */
  234.     public static Long getDiffMinutes(Date date1, Date date2) {
  235.         Long diffMinutes = getDiffSeconds(date1, date2) / 60;
  236.         return diffMinutes;
  237.     }
  238.  
  239.     /**
  240.      * 获取2个时间直接 相差多少小时
  241.      *
  242.      * @param date1
  243.      * @param date2
  244.      * @return
  245.      */
  246.     public static Long getDiffHours(Date date1, Date date2) {
  247.         Long diffHours = getDiffMinutes(date1, date2) / 60;
  248.         return diffHours;
  249.     }
  250.  
  251.     /**
  252.      * 获取2个时间直接 相差多少天
  253.      *
  254.      * @param date1
  255.      * @param date2
  256.      * @return
  257.      */
  258.     public static Long getDiffDays(Date date1, Date date2) {
  259.         Long diffDays = getDiffHours(date1, date2) / 24;
  260.         return diffDays;
  261.     }
  262.  
  263.     /**
  264.      * 获取相差月数
  265.      *
  266.      * @param date1
  267.      * @param date2
  268.      * @return
  269.      */
  270.     public static int getDiffMonths(Date date1, Date date2) {
  271.         Calendar c1 = Calendar.getInstance();
  272.         Calendar c2 = Calendar.getInstance();
  273.         c1.setTime(date1);
  274.         c2.setTime(date2);
  275.         int year1 = c1.get(Calendar.YEAR);
  276.         int year2 = c2.get(Calendar.YEAR);
  277.         int month1 = c1.get(Calendar.MONTH);
  278.         int month2 = c2.get(Calendar.MONTH);
  279.         int day1 = c1.get(Calendar.DAY_OF_MONTH);
  280.         int day2 = c2.get(Calendar.DAY_OF_MONTH);
  281.         // 获取年的差值 
  282.         int yearInterval = year1 - year2;
  283.         // 如果 d1的 月-日 小于 d2的 月-日 那么 yearInterval-- 这样就得到了相差的年数
  284.         if (month1 < month2 || month1 == month2 && day1 < day2) {
  285.             yearInterval--;
  286.         }
  287.         // 获取月数差值
  288.         int monthInterval = (month1 + 12) - month2;
  289.         if (day1 < day2) {
  290.             monthInterval--;
  291.         }
  292.         monthInterval %= 12;
  293.         int monthsDiff = Math.abs(yearInterval * 12 + monthInterval);
  294.         return monthsDiff;
  295.     }
  296.  
  297.     /**
  298.      * 获取相差年数
  299.      *
  300.      * @param date1
  301.      * @param date2
  302.      * @return
  303.      */
  304.     public static int getDiffYears(Date date1, Date date2) {
  305.         Calendar c1 = Calendar.getInstance();
  306.         Calendar c2 = Calendar.getInstance();
  307.         c1.setTime(date1);
  308.         c2.setTime(date2);
  309.         int year1 = c1.get(Calendar.YEAR);
  310.         int year2 = c2.get(Calendar.YEAR);
  311.         return Math.abs(year1 - year2);
  312.     }
  313.  
  314.     /**
  315.      * 多少天以前,日期+ 00:00:00
  316.      *
  317.      * @param ago
  318.      * @return
  319.      */
  320.     public static String getDaysAgoStart(int ago) {
  321.         Calendar calendar = Calendar.getInstance();
  322.         calendar.add(Calendar.DAY_OF_YEAR, -ago);
  323.         String time = DateUtils.dateConvertString(calendar.getTime(), DateUtils.YYYY_MM_DD);
  324.         String timeFrom = time + " 00:00:00";
  325.         return timeFrom;
  326.     }
  327.  
  328.     /**
  329.      * 多少天以前,日期+ 23:59:59
  330.      *
  331.      * @param ago
  332.      * @return
  333.      */
  334.     public static String getDaysAgoEnd(int ago) {
  335.         Calendar calendar = Calendar.getInstance();
  336.         calendar.add(Calendar.DAY_OF_YEAR, -ago);
  337.         String time = DateUtils.dateConvertString(calendar.getTime(), DateUtils.YYYY_MM_DD);
  338.         String timeFrom = time + " 23:59:59";
  339.         return timeFrom;
  340.     }
  341.  
  342.     /**
  343.      * 判断time1 是否早于time2
  344.      *
  345.      * @param time1
  346.      * @param time2
  347.      * @return
  348.      */
  349.     public static boolean isBefore(String time1, String time2) {
  350.         Date date1 = DateUtils.stringConvertDate(time1, DateUtils.YYYY_MM_DD_HH_MM_SS);
  351.         Date date2 = DateUtils.stringConvertDate(time2, DateUtils.YYYY_MM_DD_HH_MM_SS);
  352.  
  353.         return date1.before(date2);
  354.     }
  355.  
  356.     /**
  357.      * 获得当前系统时间
  358.      *
  359.      * @return
  360.      */
  361.     public static String getSystemDate() {
  362.         SimpleDateFormat sdf = new SimpleDateFormat(DateUtils.YYYY_MM_DD_HH_MM_SS);
  363.         return sdf.format(new Date());
  364.     }
  365.  
  366.     public static boolean isEqual(Date d1, Date d2) {
  367.         if (d1 == null) {
  368.             if (d2 == null) {
  369.                 return true;
  370.             } else {
  371.                 return false;
  372.             }
  373.         }
  374.         if (d2 == null) {
  375.             if (d1 != null) {
  376.                 return false;
  377.             }
  378.         }
  379.         return d1.equals(d2);
  380.     }
  381.  
  382.  
  383.     /**
  384.      * @param dateTimeStr yyyy/MM/dd [HH:mm:ss[.SSS]] 或 yyyy-MM-dd [HH:mm:ss[.SSS]]
  385.      * @return
  386.      */
  387.     public static Date parse(String dateTimeStr) {
  388.         if (null == dateTimeStr || dateTimeStr.trim().length() == 0) {
  389.             return null;
  390.         }
  391.         try {
  392.             String str = dateTimeStr.replaceAll("/", "-").replace("T", " ").trim();
  393.             switch (str.length()) {
  394.                 case 8:
  395.                     return stringConvertDate(str, "yyyyMMdd");
  396.                 case 10:
  397.                     return stringConvertDate(str, YYYY_MM_DD);
  398.                 case 16:
  399.                     return stringConvertDate(str, YYYY_MM_DD_HH_MM);
  400.                 case 19:
  401.                     return stringConvertDate(str, YYYY_MM_DD_HH_MM_SS);
  402.                 case 21:
  403.                     return stringConvertDate(str, YYYY_MM_DD_HH_MM_SS_S);
  404.                 case 22:
  405.                     return stringConvertDate(str, YYYY_MM_DD_HH_MM_SS_SS);
  406.                 case 23:
  407.                     return stringConvertDate(str, YYYY_MM_DD_HH_MM_SS_SSS);
  408.                 default:
  409.                     long timestamp = Long.parseLong(str);
  410.                     return new Date(timestamp);
  411.             }
  412.         } catch (Exception e) {
  413.             e.printStackTrace();
  414.         }
  415.         return null;
  416.     }
  417.  
  418.  
  419.     /**
  420.      * @Description 获取当前时间，返回毫秒值，高并发量会存在性能问题，后续待优化
  421.      * @Param []
  422.      * @Author weibin
  423.      * @Date 2018/11/23 16:19
  424.      * @Return long
  425.      **/
  426.     public static long getNowTime() {
  427.         return System.currentTimeMillis();
  428.     }
  429.  
  430.     /**
  431.      * 获取日期类的实例
  432.      * 如果传入参数为空，则取当前系统时间
  433.      *
  434.      * @param date 日期对象
  435.      * @return
  436.      */
  437.     private static final Calendar getCalendarInstance(Date date) {
  438.         Calendar cl = Calendar.getInstance();
  439.         if (null != date) {
  440.             cl.setTime(date);
  441.         }
  442.         return cl;
  443.     }
  444.  
  445.     /**
  446.      * 获得指定日期之后，指定天数的日期
  447.      * 如果日期为空，则获取当前日期之后，指定天数的日期
  448.      *
  449.      * @return
  450.      * @throws Exception
  451.      */
  452.     public static final Date getNextDate(Date nowDate, int days) {
  453.         if (days <= 0) {
  454.             throw new RuntimeException(StringUtils.concat("天数【", days, "】不可以小于等于0"));
  455.         }
  456.         Calendar cl = getCalendarInstance(nowDate);
  457.         cl.set(Calendar.DAY_OF_MONTH, cl.get(Calendar.DAY_OF_MONTH) + days);
  458.         return cl.getTime();
  459.     }
  460.  
  461.     /**
  462.      * 获得指定日期之前，指定天数的日期
  463.      * 如果日期为空，则获取当前日期之前，指定天数的日期
  464.      *
  465.      * @return
  466.      * @throws Exception
  467.      */
  468.     public static final Date getPrevDate(Date nowDate, int days) {
  469.         if (days <= 0) {
  470.             throw new RuntimeException(StringUtils.concat("天数【", days, "】不可以小于等于0"));
  471.         }
  472.         Calendar cl = getCalendarInstance(nowDate);
  473.         cl.set(Calendar.DAY_OF_MONTH, cl.get(Calendar.DAY_OF_MONTH) - days);
  474.         return cl.getTime();
  475.     }
  476.  
  477.     /**
  478.      * 将时间字符串转换为日期
  479.      *
  480.      * @param dateStr 时间字符串
  481.      * @param format  日期格式化
  482.      * @return 日期
  483.      * @throws Exception
  484.      */
  485.     public static final Date strToDate(String dateStr, String format) {
  486.         try {
  487.             AssertUtils.allNotNullAndEmpty(dateStr, format);
  488.             SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
  489.             return sdf.parse(dateStr);
  490.         } catch (ParseException e) {
  491.             e.printStackTrace();
  492.         }
  493.         return null;
  494.     }
  495.  
  496.     /**
  497.      * 按照参数format的格式，日期转字符串
  498.      *
  499.      * @param date   日期
  500.      * @param format 日期格式化
  501.      * @return 日期格式化后的字符串，例如：2018-07-12
  502.      * @throws Exception
  503.      */
  504.     public static String dateToStr(Date date, String format) {
  505.         AssertUtils.notNull(date);
  506.         AssertUtils.notNullAndEmpty(format);
  507.         SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
  508.         return sdf.format(date);
  509.     }
  510.  
  511.     /**
  512.      * 通过指定日期获取其年份，如果日期为空值则获取当前系统时间的年份
  513.      *
  514.      * @param date 日期
  515.      * @return 年
  516.      */
  517.     public static final int getYear(Date date) {
  518.         Calendar cal = getCalendarInstance(date);
  519.         return cal.get(Calendar.YEAR);
  520.     }
  521.  
  522.     /**
  523.      * 获取指定日期的月份，如果日期为空值则获取当前系统时间的月份
  524.      *
  525.      * @param date 日期
  526.      * @return 月
  527.      */
  528.     public static final int getMonth(Date date) {
  529.         Calendar cal = getCalendarInstance(date);
  530.         return cal.get(Calendar.MONTH) + 1;
  531.     }
  532.  
  533.     /**
  534.      * 获取指定日期所在月份的具体的天数，如果日期为空值则获取当前系统时间月份当天的天数
  535.      *
  536.      * @param date 日期
  537.      * @return 日期所在月份具体的某一天
  538.      */
  539.     public static final int getDay(Date date) {
  540.         Calendar cal = getCalendarInstance(date);
  541.         return cal.get(Calendar.DAY_OF_MONTH);
  542.     }
  543.  
  544.     /**
  545.      * 获取指定日期所在月份的总天数，如果日期为空则取当前系统时间所在月份的总天数
  546.      *
  547.      * @param date 日期
  548.      * @return 日期对应月份的总天数
  549.      */
  550.     public static final int getDaysOfMonth(Date date) {
  551.         Calendar cal = getCalendarInstance(date);
  552.         return cal.getActualMaximum(Calendar.DAY_OF_MONTH);
  553.     }
  554.  
  555.     /**
  556.      * 获取指定日期的小时数，如果日期为空值则获取当前系统时间的小时数
  557.      *
  558.      * @param date
  559.      * @return
  560.      */
  561.     public static final int getHour(Date date) {
  562.         Calendar cal = getCalendarInstance(date);
  563.         return cal.get(Calendar.HOUR_OF_DAY);
  564.     }
  565.  
  566.     /**
  567.      * 获取指定日期所在分钟数，如果日期为空值则获取当前系统时间的分钟数
  568.      *
  569.      * @param date
  570.      * @return
  571.      */
  572.     public static final int getMinute(Date date) {
  573.         Calendar cal = getCalendarInstance(date);
  574.         return cal.get(Calendar.MINUTE);
  575.     }
  576.  
  577.     /**
  578.      * 获取指定日期所在月份的第一天的日期
  579.      *
  580.      * @param date 日期
  581.      * @return 当月的第一天的日期
  582.      */
  583.     public static final Date getFirstDayOfMonth(Date date) {
  584.         Calendar cal = getCalendarInstance(date);
  585.         cal.set(Calendar.DAY_OF_MONTH, 1);
  586.         return cal.getTime();
  587.     }
  588.  
  589.     /**
  590.      * 获取指定日期所在月份的最后一天
  591.      *
  592.      * @param date 日期
  593.      * @return 当月最后一天的日期
  594.      */
  595.     public static final Date getLastDayOfMonthDate(Date date) {
  596.         Calendar cal = getCalendarInstance(date);
  597.         cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
  598.         cal.set(Calendar.DAY_OF_MONTH, 1);
  599.         cal.add(Calendar.DAY_OF_MONTH, -1);
  600.         return cal.getTime();
  601.     }
  602.  
  603.     /**
  604.      * 获取指定日期，下个月的第一天，时间为空则取当前系统时间
  605.      *
  606.      * @param date 日期
  607.      * @return 下个月第一天的日期
  608.      */
  609.     public static final Date getFirstDayOfNextMonth(Date date) {
  610.         Calendar cal = getCalendarInstance(date);
  611.         cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
  612.         cal.set(Calendar.DAY_OF_MONTH, 1);
  613.         return cal.getTime();
  614.     }
  615.  
  616.     /**
  617.      * 获取指定日期，上个月的第一天的日期，时间为空则取当前系统时间
  618.      *
  619.      * @param date 日期
  620.      * @return 上个月第一天的日期
  621.      */
  622.     public static final Date getFirstDayOfPrevMonth(Date date) {
  623.         Calendar cal = getCalendarInstance(date);
  624.         cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 1);
  625.         cal.set(Calendar.DAY_OF_MONTH, 1);
  626.         return cal.getTime();
  627.     }
  628.  
  629.     /**
  630.      * 获取指定日期，本月的最后一天，如果日期为空，则取系统时间对应的月份最后一天
  631.      *
  632.      * @param date 日期
  633.      * @return 当月最后一天的日期
  634.      */
  635.     public static final int getLastDayOfMonth(Date date) {
  636.         Calendar cal = getCalendarInstance(date);
  637.         cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
  638.         cal.set(Calendar.DAY_OF_MONTH, 1);
  639.         cal.add(Calendar.DAY_OF_MONTH, -1);
  640.         return cal.get(Calendar.DAY_OF_MONTH);
  641.     }
  642.  
  643.     /**
  644.      * 通过生日获取年龄
  645.      *
  646.      * @param birthday
  647.      * @return
  648.      */
  649.     public static final int getAge(Date birthday) {
  650.         Calendar nowTime = getCalendarInstance(null);
  651.         Calendar birthdayTime = getCalendarInstance(birthday);
  652.         return nowTime.get(Calendar.YEAR) - birthdayTime.get(Calendar.YEAR);
  653.     }
  654.  
  655.     /**
  656.      * 是否小于或等于90天
  657.      *
  658.      * @return
  659.      */
  660.     public static final boolean overNinety(Date startDate, Date endDate) {
  661.  
  662.         long date = (endDate.getTime() - startDate.getTime()) / (1000 * 3600 * 24);
  663.         if (date > 90) {
  664.             return true;
  665.         }
  666.         return false;
  667.     }
  668.  
  669.     /**
  670.      * 通过传入秒值获取对应的日期
  671.      *
  672.      * @param seconds
  673.      * @return
  674.      */
  675.     public static final Date getDate(Long seconds) {
  676.         if (null == seconds || seconds == 0) {
  677.             return null;
  678.         } else {
  679.             return Date.from(Instant.ofEpochSecond(seconds));
  680.         }
  681.     }
  682.  
  683.     /**
  684.      * @Description 获取当前日期所在周，周一的日期
  685.      * @Param [tranferTime]
  686.      * @Author weibin
  687.      * @Date 2019/3/8 17:49
  688.      * @Return java.util.Date
  689.      **/
  690.     public static Date getFirstDayOfWeek(Date date) {
  691.         Calendar cal = getCalendarInstance(date);
  692.         cal.setFirstDayOfWeek(Calendar.MONDAY);
  693.         int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
  694.         if (dayWeek == 1) {
  695.             dayWeek = 8;
  696.         }
  697.         cal.set(Calendar.DATE, cal.get(Calendar.DATE) - dayWeek + 2);
  698.         return cal.getTime();
  699.     }
  700.  
  701.     /**
  702.      * @Description 获取指定月数的日期
  703.      * @Param [date, num]
  704.      * @Author weibin
  705.      * @Date 2019/3/8 18:29
  706.      * @Return java.util.Date
  707.      **/
  708.     public static Date getMonth(Date date, int num) {
  709.         Calendar cal = getCalendarInstance(date);
  710.         cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + num);
  711.         return cal.getTime();
  712.     }
  713.  
  714.     /**
  715.      * @Description 获取指定年的周数
  716.      * @Param [year]
  717.      * @Author weibin
  718.      * @Date 2019/3/8 19:45
  719.      * @Return int
  720.      **/
  721.     public static int getWeeks(int year) {
  722.         Calendar cal = getCalendarInstance(null);
  723.         cal.setFirstDayOfWeek(Calendar.MONDAY);
  724.         cal.setMinimalDaysInFirstWeek(7);
  725.         cal.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
  726.         return cal.get(Calendar.WEEK_OF_YEAR);
  727.     }
  728.  
  729.     /**
  730.      * 将时间字符串转换为yyyyMMddHH特定字段串
  731.      *
  732.      * @param dateStr 时间字符串
  733.      * @param format  日期格式化
  734.      * @return 日期
  735.      * @throws Exception
  736.      */
  737.     public static final String strToStr(String dateStr, String format) throws Exception {
  738.         AssertUtils.allNotNullAndEmpty(dateStr, format);
  739.         SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
  740.         Date date = sdf.parse(dateStr);
  741.         return dateToStr(date, "yyyyMMddHH");
  742.     }
  743.  
  744.     /**
  745.      * 将intFormat时间字符串转换为outFormat特定字段串
  746.      *
  747.      * @param dateStr   时间字符串
  748.      * @param intFormat 输入日期格式化
  749.      * @param outFormat 输出日期格式化
  750.      * @return 日期
  751.      * @throws Exception
  752.      */
  753.     public static final String strToStrInOut(String dateStr, String intFormat, String outFormat) {
  754.         AssertUtils.allNotNullAndEmpty(dateStr, intFormat, outFormat);
  755.         SimpleDateFormat sdf = new SimpleDateFormat(intFormat, Locale.CHINA);
  756.         try {
  757.             Date date = sdf.parse(dateStr);
  758.             return dateToStr(date, outFormat);
  759.         } catch (Exception e) {
  760.             logger.error(e.toString());
  761.         }
  762.         return null;
  763.     }
  764.  
  765.  
  766.     /**
  767.      * 功能：判断字符串是否为日期格式
  768.      *
  769.      * @param strDate
  770.      * @return
  771.      */
  772.     public static Date parseDate(String strDate) {
  773.         Date d = null;
  774.         if (StringUtils.isBlank(strDate)) {
  775.             return d;
  776.         }
  777.         List<String> parsePatterns = new ArrayList<>();
  778.         parsePatterns.add(YYYYMMDD);
  779.         parsePatterns.add(YYYY_MM);
  780.         parsePatterns.add(YYYY_MM_DD);
  781.         parsePatterns.add(YYYY_MM_DD_HH_MM);
  782.         parsePatterns.add(YYYY_MM_DD_HH_MM_SS);
  783.         try {
  784.             d = DateUtils.parseDate(strDate, parsePatterns.toArray(new String[parsePatterns.size()]));
  785.         } catch (ParseException e) {
  786.             d = null;
  787.         }
  788.         return d;
  789.     }
  790.  
  791.     /**
  792.      * 获取当前时间星期几
  793.      *
  794.      * @return int
  795.      * @author YY
  796.      * @date 2019-05-08 16:52
  797.      */
  798.     public static int getWeekOfDate() {
  799.         return getWeekOfDate(new Date());
  800.     }
  801.  
  802.     /**
  803.      * 获取当前时间是星期几
  804.      *
  805.      * @param date
  806.      * @return int
  807.      * @author YY
  808.      * @date 2019-05-08 16:52
  809.      */
  810.     public static int getWeekOfDate(Date date) {
  811.         Calendar cal = Calendar.getInstance();
  812.         cal.setTime(date);
  813.         return cal.get(Calendar.DAY_OF_WEEK) - 1;
  814.     }
  815.  
  816.     /**
  817.      * 判断是否是“1970-01-01”
  818.      *
  819.      * @param date
  820.      * @return
  821.      */
  822.     public static boolean isMinDate(Date date) {
  823.         return "1970-01-01".equals(dateToStr(date, DateUtils.YYYY_MM_DD));
  824.     }
  825. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/372277
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号