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

爱被打了一巴掌 2024-03-31 13:20 146阅读 0赞

package com.atc.frame.base.utils;
    
    import org.slf4j.Logger;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.time.Instant;
    import java.util.*;
    
    /**
     * 日期工具类
     *
     * @author yechao
     * @date 2013年12月12日
     */
    public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
    
        private static final Logger logger = LogUtils.getLogger(DateUtils.class);
    
        /**
         * 前端效期格式
         */
        public static String yyyyMMddEXPIRYDATE = "yyyyMMdd";
    
        public static String MMMdd_comma_yyyyhhmmaa = "MMM dd,yyyy hh:mm aa";
    
        public static String MMMdd_comma_yyyyHHmmaa = "MMM dd,yyyy HH:mm aa";
    
        public static String MMMdd_comma_yyyy_comma_hhmmaa = "MMM dd,yyyy, hh:mm aa";
    
        public static String MMMdd_comma_yyyy_comma_HHmmaa = "MMM dd,yyyy, HH:mm aa";
    
        public final static String YYYYMMDD_HH24MISS = "yyyy-MM-DD HH24:MI:SS";
    
        public final static String D1970 = "1970-01-01 00:00:00";
        public final static Date DATE1970 = parse(D1970);
    
        /**
         * 日期格式，精确到年份
         */
        public static final String DF_YYYY = "yyyy";
        /**
         * 日期格式，精确到月份
         */
        public static final String YYYY_MM = "yyyy-MM";
        /**
         * 日期格式，精确到天数
         */
        public static final String YYYY_MM_DD = "yyyy-MM-dd";
        /**
         * 日期格式,精确到小时
         */
        public static final String YYYY_MM_DD_HH = "yyyy-MM-dd HH";
        /**
         * 日期格式,精确到分钟
         */
        public static final String YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
        /**
         * 日期格式，精确到秒
         */
        public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
        /**
         * 日期格式，精确到毫秒
         */
        public static final String YYYY_MM_DD_HH_MM_SS_S = "yyyy-MM-dd HH:mm:ss.S";
        /**
         * 日期格式，精确到毫秒
         */
        public static final String YYYY_MM_DD_HH_MM_SS_SS = "yyyy-MM-dd HH:mm:ss.SS";
        /**
         * 日期格式，精确到毫秒
         */
        public static final String YYYY_MM_DD_HH_MM_SS_SSS = "yyyy-MM-dd HH:mm:ss.SSS";
    
        /**
         * 无‘-’分隔符日期格式，精确到天数
         */
        public static final String YYYYMMDD = "yyyyMMdd";
    
        /**
         * 无‘-’分隔符日期格式,精确到分钟
         */
        public static final String YYYYMMDDHHMM = "yyyyMMddHHmm";
        /**
         * 无‘-’分隔符日期格式,精确到秒
         */
        public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
        /**
         * 无‘-’分隔符日期格式,精确到毫秒
         */
        public static final String YYYYMMDDHHMMSSSSS = "yyyyMMddHHmmssSSS";
    
        /**
         * @Description 私有构造方法
         * @Para[][]
         * @Author weibin
         * @D2018/12/17211:531:44
         * @Return
         **/
        private DateUtils() {
        }
    
        /**
         * 字符串的日期类型 转换称 Date 类型
         *
         * @param timeContent 字符串的日期类型
         * @param formatStyle 日期格式
         * @return
         */
        public static Date stringConvertDate(String timeContent, String formatStyle) {
            if (StringUtils.isEmpty(timeContent)) {
                return null;
            }
            SimpleDateFormat format = new SimpleDateFormat(formatStyle);
            try {
                return format.parse(timeContent);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 检查日期格式
         *
         * @param time
         * @param format
         * @return
         */
        public static boolean checkDate(String time, String format) {
            if (stringConvertDate(time, format) == null) {
                return false;
            }
            return true;
        }
    
        /**
         * Date 转化成 String 类型的字符串日期格式
         *
         * @param date
         * @param formatStyle 转化成 什么格式
         * @return
         */
        public static String dateConvertString(Date date, String formatStyle) {
            if (date == null) {
                return null;
            }
            SimpleDateFormat format = new SimpleDateFormat(formatStyle);
            return format.format(date);
        }
    
        public static String dateConvertStringForExpiryDate(Date date) {
            SimpleDateFormat format = new SimpleDateFormat(YYYY_MM_DD);
            if (date == null) {
                return format.format(new Date());
            }
            return format.format(date);
        }
    
        /**
         * 字符串日期格式 转换成 带 地区标识的 Date 类型
         *
         * @param strDate
         * @param locale
         * @param formatStyle
         * @return
         */
        public static Date stringConvertLocalDate(String strDate, Locale locale, String formatStyle) {
            SimpleDateFormat srcsdf = new SimpleDateFormat(formatStyle, locale);
            try {
                return srcsdf.parse(strDate);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 获取本地时间相对的UTC | GMT时间
         *
         * @return
         */
        public static Date getUtcTime() {
            // 1、取得本地时间：
            Calendar calendar = java.util.Calendar.getInstance();
            // 2、取得时间偏移量：
            final int zoneOffset = calendar.get(java.util.Calendar.ZONE_OFFSET);
            // 3、取得夏令时差：
            final int dstOffset = calendar.get(java.util.Calendar.DST_OFFSET);
            // 4、从本地时间里扣除这些差量，即可以取得UTC时间：
            calendar.add(java.util.Calendar.MILLISECOND, -(zoneOffset + dstOffset));
            return calendar.getTime();
        }
    
    
        /**
         * 获取本地时间相对的UTC | GMT时间
         *
         * @return
         */
        public static int getOffset() {
            // 1、取得本地时间：
            Calendar calendar = java.util.Calendar.getInstance();
            // 2、取得时间偏移量：
            int zoneOffset = calendar.get(java.util.Calendar.ZONE_OFFSET);
            return zoneOffset;
        }
    
        /**
         * 获取2个时间相差多少秒
         *
         * @param date1
         * @param date2
         * @return
         */
        public static Long getDiffSeconds(Date date1, Date date2) {
            long milliseconds1 = date1.getTime();
            long milliseconds2 = date2.getTime();
            long diff = milliseconds1 - milliseconds2;
            if (diff < 0) {
                diff = -diff;
            }
            long diffSeconds = diff / (1000);
            return diffSeconds;
        }
    
        /**
         * 获取2个时间相差多少分钟
         *
         * @param date1
         * @param date2
         * @return
         */
        public static Long getDiffMinutes(Date date1, Date date2) {
            Long diffMinutes = getDiffSeconds(date1, date2) / 60;
            return diffMinutes;
        }
    
        /**
         * 获取2个时间直接 相差多少小时
         *
         * @param date1
         * @param date2
         * @return
         */
        public static Long getDiffHours(Date date1, Date date2) {
            Long diffHours = getDiffMinutes(date1, date2) / 60;
            return diffHours;
        }
    
        /**
         * 获取2个时间直接 相差多少天
         *
         * @param date1
         * @param date2
         * @return
         */
        public static Long getDiffDays(Date date1, Date date2) {
            Long diffDays = getDiffHours(date1, date2) / 24;
            return diffDays;
        }
    
        /**
         * 获取相差月数
         *
         * @param date1
         * @param date2
         * @return
         */
        public static int getDiffMonths(Date date1, Date date2) {
            Calendar c1 = Calendar.getInstance();
            Calendar c2 = Calendar.getInstance();
            c1.setTime(date1);
            c2.setTime(date2);
            int year1 = c1.get(Calendar.YEAR);
            int year2 = c2.get(Calendar.YEAR);
            int month1 = c1.get(Calendar.MONTH);
            int month2 = c2.get(Calendar.MONTH);
            int day1 = c1.get(Calendar.DAY_OF_MONTH);
            int day2 = c2.get(Calendar.DAY_OF_MONTH);
            // 获取年的差值 
            int yearInterval = year1 - year2;
            // 如果 d1的 月-日 小于 d2的 月-日 那么 yearInterval-- 这样就得到了相差的年数
            if (month1 < month2 || month1 == month2 && day1 < day2) {
                yearInterval--;
            }
            // 获取月数差值
            int monthInterval = (month1 + 12) - month2;
            if (day1 < day2) {
                monthInterval--;
            }
            monthInterval %= 12;
            int monthsDiff = Math.abs(yearInterval * 12 + monthInterval);
            return monthsDiff;
        }
    
        /**
         * 获取相差年数
         *
         * @param date1
         * @param date2
         * @return
         */
        public static int getDiffYears(Date date1, Date date2) {
            Calendar c1 = Calendar.getInstance();
            Calendar c2 = Calendar.getInstance();
            c1.setTime(date1);
            c2.setTime(date2);
            int year1 = c1.get(Calendar.YEAR);
            int year2 = c2.get(Calendar.YEAR);
            return Math.abs(year1 - year2);
        }
    
        /**
         * 多少天以前,日期+ 00:00:00
         *
         * @param ago
         * @return
         */
        public static String getDaysAgoStart(int ago) {
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.DAY_OF_YEAR, -ago);
            String time = DateUtils.dateConvertString(calendar.getTime(), DateUtils.YYYY_MM_DD);
            String timeFrom = time + " 00:00:00";
            return timeFrom;
        }
    
        /**
         * 多少天以前,日期+ 23:59:59
         *
         * @param ago
         * @return
         */
        public static String getDaysAgoEnd(int ago) {
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.DAY_OF_YEAR, -ago);
            String time = DateUtils.dateConvertString(calendar.getTime(), DateUtils.YYYY_MM_DD);
            String timeFrom = time + " 23:59:59";
            return timeFrom;
        }
    
        /**
         * 判断time1 是否早于time2
         *
         * @param time1
         * @param time2
         * @return
         */
        public static boolean isBefore(String time1, String time2) {
            Date date1 = DateUtils.stringConvertDate(time1, DateUtils.YYYY_MM_DD_HH_MM_SS);
            Date date2 = DateUtils.stringConvertDate(time2, DateUtils.YYYY_MM_DD_HH_MM_SS);
    
            return date1.before(date2);
        }
    
        /**
         * 获得当前系统时间
         *
         * @return
         */
        public static String getSystemDate() {
            SimpleDateFormat sdf = new SimpleDateFormat(DateUtils.YYYY_MM_DD_HH_MM_SS);
            return sdf.format(new Date());
        }
    
        public static boolean isEqual(Date d1, Date d2) {
            if (d1 == null) {
                if (d2 == null) {
                    return true;
                } else {
                    return false;
                }
            }
            if (d2 == null) {
                if (d1 != null) {
                    return false;
                }
            }
            return d1.equals(d2);
        }
    
    
        /**
         * @param dateTimeStr yyyy/MM/dd [HH:mm:ss[.SSS]] 或 yyyy-MM-dd [HH:mm:ss[.SSS]]
         * @return
         */
        public static Date parse(String dateTimeStr) {
            if (null == dateTimeStr || dateTimeStr.trim().length() == 0) {
                return null;
            }
            try {
                String str = dateTimeStr.replaceAll("/", "-").replace("T", " ").trim();
                switch (str.length()) {
                    case 8:
                        return stringConvertDate(str, "yyyyMMdd");
                    case 10:
                        return stringConvertDate(str, YYYY_MM_DD);
                    case 16:
                        return stringConvertDate(str, YYYY_MM_DD_HH_MM);
                    case 19:
                        return stringConvertDate(str, YYYY_MM_DD_HH_MM_SS);
                    case 21:
                        return stringConvertDate(str, YYYY_MM_DD_HH_MM_SS_S);
                    case 22:
                        return stringConvertDate(str, YYYY_MM_DD_HH_MM_SS_SS);
                    case 23:
                        return stringConvertDate(str, YYYY_MM_DD_HH_MM_SS_SSS);
                    default:
                        long timestamp = Long.parseLong(str);
                        return new Date(timestamp);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
    
        /**
         * @Description 获取当前时间，返回毫秒值，高并发量会存在性能问题，后续待优化
         * @Param []
         * @Author weibin
         * @Date 2018/11/23 16:19
         * @Return long
         **/
        public static long getNowTime() {
            return System.currentTimeMillis();
        }
    
        /**
         * 获取日期类的实例
         * 如果传入参数为空，则取当前系统时间
         *
         * @param date 日期对象
         * @return
         */
        private static final Calendar getCalendarInstance(Date date) {
            Calendar cl = Calendar.getInstance();
            if (null != date) {
                cl.setTime(date);
            }
            return cl;
        }
    
        /**
         * 获得指定日期之后，指定天数的日期
         * 如果日期为空，则获取当前日期之后，指定天数的日期
         *
         * @return
         * @throws Exception
         */
        public static final Date getNextDate(Date nowDate, int days) {
            if (days <= 0) {
                throw new RuntimeException(StringUtils.concat("天数【", days, "】不可以小于等于0"));
            }
            Calendar cl = getCalendarInstance(nowDate);
            cl.set(Calendar.DAY_OF_MONTH, cl.get(Calendar.DAY_OF_MONTH) + days);
            return cl.getTime();
        }
    
        /**
         * 获得指定日期之前，指定天数的日期
         * 如果日期为空，则获取当前日期之前，指定天数的日期
         *
         * @return
         * @throws Exception
         */
        public static final Date getPrevDate(Date nowDate, int days) {
            if (days <= 0) {
                throw new RuntimeException(StringUtils.concat("天数【", days, "】不可以小于等于0"));
            }
            Calendar cl = getCalendarInstance(nowDate);
            cl.set(Calendar.DAY_OF_MONTH, cl.get(Calendar.DAY_OF_MONTH) - days);
            return cl.getTime();
        }
    
        /**
         * 将时间字符串转换为日期
         *
         * @param dateStr 时间字符串
         * @param format  日期格式化
         * @return 日期
         * @throws Exception
         */
        public static final Date strToDate(String dateStr, String format) {
            try {
                AssertUtils.allNotNullAndEmpty(dateStr, format);
                SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
                return sdf.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 按照参数format的格式，日期转字符串
         *
         * @param date   日期
         * @param format 日期格式化
         * @return 日期格式化后的字符串，例如：2018-07-12
         * @throws Exception
         */
        public static String dateToStr(Date date, String format) {
            AssertUtils.notNull(date);
            AssertUtils.notNullAndEmpty(format);
            SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
            return sdf.format(date);
        }
    
        /**
         * 通过指定日期获取其年份，如果日期为空值则获取当前系统时间的年份
         *
         * @param date 日期
         * @return 年
         */
        public static final int getYear(Date date) {
            Calendar cal = getCalendarInstance(date);
            return cal.get(Calendar.YEAR);
        }
    
        /**
         * 获取指定日期的月份，如果日期为空值则获取当前系统时间的月份
         *
         * @param date 日期
         * @return 月
         */
        public static final int getMonth(Date date) {
            Calendar cal = getCalendarInstance(date);
            return cal.get(Calendar.MONTH) + 1;
        }
    
        /**
         * 获取指定日期所在月份的具体的天数，如果日期为空值则获取当前系统时间月份当天的天数
         *
         * @param date 日期
         * @return 日期所在月份具体的某一天
         */
        public static final int getDay(Date date) {
            Calendar cal = getCalendarInstance(date);
            return cal.get(Calendar.DAY_OF_MONTH);
        }
    
        /**
         * 获取指定日期所在月份的总天数，如果日期为空则取当前系统时间所在月份的总天数
         *
         * @param date 日期
         * @return 日期对应月份的总天数
         */
        public static final int getDaysOfMonth(Date date) {
            Calendar cal = getCalendarInstance(date);
            return cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        }
    
        /**
         * 获取指定日期的小时数，如果日期为空值则获取当前系统时间的小时数
         *
         * @param date
         * @return
         */
        public static final int getHour(Date date) {
            Calendar cal = getCalendarInstance(date);
            return cal.get(Calendar.HOUR_OF_DAY);
        }
    
        /**
         * 获取指定日期所在分钟数，如果日期为空值则获取当前系统时间的分钟数
         *
         * @param date
         * @return
         */
        public static final int getMinute(Date date) {
            Calendar cal = getCalendarInstance(date);
            return cal.get(Calendar.MINUTE);
        }
    
        /**
         * 获取指定日期所在月份的第一天的日期
         *
         * @param date 日期
         * @return 当月的第一天的日期
         */
        public static final Date getFirstDayOfMonth(Date date) {
            Calendar cal = getCalendarInstance(date);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return cal.getTime();
        }
    
        /**
         * 获取指定日期所在月份的最后一天
         *
         * @param date 日期
         * @return 当月最后一天的日期
         */
        public static final Date getLastDayOfMonthDate(Date date) {
            Calendar cal = getCalendarInstance(date);
            cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            cal.add(Calendar.DAY_OF_MONTH, -1);
            return cal.getTime();
        }
    
        /**
         * 获取指定日期，下个月的第一天，时间为空则取当前系统时间
         *
         * @param date 日期
         * @return 下个月第一天的日期
         */
        public static final Date getFirstDayOfNextMonth(Date date) {
            Calendar cal = getCalendarInstance(date);
            cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return cal.getTime();
        }
    
        /**
         * 获取指定日期，上个月的第一天的日期，时间为空则取当前系统时间
         *
         * @param date 日期
         * @return 上个月第一天的日期
         */
        public static final Date getFirstDayOfPrevMonth(Date date) {
            Calendar cal = getCalendarInstance(date);
            cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 1);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            return cal.getTime();
        }
    
        /**
         * 获取指定日期，本月的最后一天，如果日期为空，则取系统时间对应的月份最后一天
         *
         * @param date 日期
         * @return 当月最后一天的日期
         */
        public static final int getLastDayOfMonth(Date date) {
            Calendar cal = getCalendarInstance(date);
            cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + 1);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            cal.add(Calendar.DAY_OF_MONTH, -1);
            return cal.get(Calendar.DAY_OF_MONTH);
        }
    
        /**
         * 通过生日获取年龄
         *
         * @param birthday
         * @return
         */
        public static final int getAge(Date birthday) {
            Calendar nowTime = getCalendarInstance(null);
            Calendar birthdayTime = getCalendarInstance(birthday);
            return nowTime.get(Calendar.YEAR) - birthdayTime.get(Calendar.YEAR);
        }
    
        /**
         * 是否小于或等于90天
         *
         * @return
         */
        public static final boolean overNinety(Date startDate, Date endDate) {
    
            long date = (endDate.getTime() - startDate.getTime()) / (1000 * 3600 * 24);
            if (date > 90) {
                return true;
            }
            return false;
        }
    
        /**
         * 通过传入秒值获取对应的日期
         *
         * @param seconds
         * @return
         */
        public static final Date getDate(Long seconds) {
            if (null == seconds || seconds == 0) {
                return null;
            } else {
                return Date.from(Instant.ofEpochSecond(seconds));
            }
        }
    
        /**
         * @Description 获取当前日期所在周，周一的日期
         * @Param [tranferTime]
         * @Author weibin
         * @Date 2019/3/8 17:49
         * @Return java.util.Date
         **/
        public static Date getFirstDayOfWeek(Date date) {
            Calendar cal = getCalendarInstance(date);
            cal.setFirstDayOfWeek(Calendar.MONDAY);
            int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
            if (dayWeek == 1) {
                dayWeek = 8;
            }
            cal.set(Calendar.DATE, cal.get(Calendar.DATE) - dayWeek + 2);
            return cal.getTime();
        }
    
        /**
         * @Description 获取指定月数的日期
         * @Param [date, num]
         * @Author weibin
         * @Date 2019/3/8 18:29
         * @Return java.util.Date
         **/
        public static Date getMonth(Date date, int num) {
            Calendar cal = getCalendarInstance(date);
            cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) + num);
            return cal.getTime();
        }
    
        /**
         * @Description 获取指定年的周数
         * @Param [year]
         * @Author weibin
         * @Date 2019/3/8 19:45
         * @Return int
         **/
        public static int getWeeks(int year) {
            Calendar cal = getCalendarInstance(null);
            cal.setFirstDayOfWeek(Calendar.MONDAY);
            cal.setMinimalDaysInFirstWeek(7);
            cal.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
            return cal.get(Calendar.WEEK_OF_YEAR);
        }
    
        /**
         * 将时间字符串转换为yyyyMMddHH特定字段串
         *
         * @param dateStr 时间字符串
         * @param format  日期格式化
         * @return 日期
         * @throws Exception
         */
        public static final String strToStr(String dateStr, String format) throws Exception {
            AssertUtils.allNotNullAndEmpty(dateStr, format);
            SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
            Date date = sdf.parse(dateStr);
            return dateToStr(date, "yyyyMMddHH");
        }
    
        /**
         * 将intFormat时间字符串转换为outFormat特定字段串
         *
         * @param dateStr   时间字符串
         * @param intFormat 输入日期格式化
         * @param outFormat 输出日期格式化
         * @return 日期
         * @throws Exception
         */
        public static final String strToStrInOut(String dateStr, String intFormat, String outFormat) {
            AssertUtils.allNotNullAndEmpty(dateStr, intFormat, outFormat);
            SimpleDateFormat sdf = new SimpleDateFormat(intFormat, Locale.CHINA);
            try {
                Date date = sdf.parse(dateStr);
                return dateToStr(date, outFormat);
            } catch (Exception e) {
                logger.error(e.toString());
            }
            return null;
        }
    
    
        /**
         * 功能：判断字符串是否为日期格式
         *
         * @param strDate
         * @return
         */
        public static Date parseDate(String strDate) {
            Date d = null;
            if (StringUtils.isBlank(strDate)) {
                return d;
            }
            List<String> parsePatterns = new ArrayList<>();
            parsePatterns.add(YYYYMMDD);
            parsePatterns.add(YYYY_MM);
            parsePatterns.add(YYYY_MM_DD);
            parsePatterns.add(YYYY_MM_DD_HH_MM);
            parsePatterns.add(YYYY_MM_DD_HH_MM_SS);
            try {
                d = DateUtils.parseDate(strDate, parsePatterns.toArray(new String[parsePatterns.size()]));
            } catch (ParseException e) {
                d = null;
            }
            return d;
        }
    
        /**
         * 获取当前时间星期几
         *
         * @return int
         * @author YY
         * @date 2019-05-08 16:52
         */
        public static int getWeekOfDate() {
            return getWeekOfDate(new Date());
        }
    
        /**
         * 获取当前时间是星期几
         *
         * @param date
         * @return int
         * @author YY
         * @date 2019-05-08 16:52
         */
        public static int getWeekOfDate(Date date) {
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            return cal.get(Calendar.DAY_OF_WEEK) - 1;
        }
    
        /**
         * 判断是否是“1970-01-01”
         *
         * @param date
         * @return
         */
        public static boolean isMinDate(Date date) {
            return "1970-01-01".equals(dateToStr(date, DateUtils.YYYY_MM_DD));
        }
    }