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

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));
    }
}