日期工具类

import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.joda.time.Days;
import org.joda.time.LocalDate;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.springframework.util.StringUtils;
import tv.zhongchi.common.exception.BizException;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.*;

/**
 * @ClassName DateUtil
 * @Author ZhangRF
 * @CreateDate 2020/6/12
 * @Decription 时间工具类
 */
public class DateUtil {
    public static final long ONE_HOUR_TIME_LONG = 3600000;

    /**
     * 年(yyyy)
     */
    public static final String YEAR = "yyyy";

    /**
     * 年-月(yyyy-MM)
     */
    public static final String YEAR_MONTH = "yyyy-MM";

    /**
     * 年-月-日(yyyy-MM-dd)
     */
    public static final String YEAR_MONTH_DAY = "yyyy-MM-dd";

    /**
     * 年月日(yyyyMMdd)
     */
    public static final String YEAR_MONTH_DAY_SIMPLE = "yyyyMMdd";

    /**
     * 年-月-日 小时(yyyy-MM-dd HH)
     */
    public static final String YEAR_MONTH_DAY_HOUR = "yyyy-MM-dd HH";

    /**
     * 年-月-日 小时(yyyy-MM-dd HH)中文输出
     */
    public static final String YEAR_MONTH_DAY_HOUR_CN = "yyyy年MM月dd日HH时";

    /**
     * 年-月-日 小时:分钟(yyyy-MM-dd HH:mm)
     */
    public static final String YEAR_MONTH_DAY_HOUR_MINUTE = "yyyy-MM-dd HH:mm";

    /**
     * 年-月-日 小时:分钟:秒钟(yyyy-MM-dd HH:mm:ss)
     */
    public static final String YEAR_MONTH_DAY_HOUR_MINUTE_SECOND = "yyyy-MM-dd HH:mm:ss";

    /**
     * 年月日小时分钟(yyMMddHHmm)订单
     */
    public static final String YEAR_MONTH_DAY_HOUR_MINUTE_ORDER = "yyMMddHHmm";

    /**
     * 年月日小时分钟秒钟(yyyyMMddHHmmss)
     */
    public static final String YEAR_MONTH_DAY_HOUR_MINUTE_SECOND_SIMPLE = "yyyyMMddHHmmss";

    /**
     * 小时:分钟:秒钟(HH:mm:ss)
     */
    public static final String HOUR_MINUTE_SECOND = "HH:mm:ss";

    /**
     * 小时:分钟(HH:mm)
     */
    public static final String HOUR_MINUTE = "HH:mm";

    /**
     * 月.日(M.d)
     */
    public static final String MONTH_DAY = "M.d";
    public static final String REG_EXP_DATE = "^((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})-(((0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01]))|((0[469]|11)-(0[1-9]|[12][0-9]|30))|(02-(0[1-9]|[1][0-9]|2[0-8]))))|((([0-9]{2})(0[48]|[2468][048]|[13579][26])|((0[48]|[2468][048]|[3579][26])00))-02-29))\\s+([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$";
    /**
     * 一天的秒数
     */
    private static final int DAY_SECOND = 24 * 60 * 60;
    /**
     * 一小时的秒数
     */
    private static final int HOUR_SECOND = 60 * 60;
    /**
     * 一分钟的秒数
     */
    private static final int MINUTE_SECOND = 60;

    public DateUtil() {
        System.setProperty("user.timezone", "Asia/Shanghai");
    }

    /**
     * 获取当前时间
     *
     * @return 返回当前时间
     */
    public static Date getCurrent() {
        return new Date();
    }

    /**
     * 获取当前时间并格式化
     *
     * @return 返回当前时间
     */
    public static String getCurrentDate(String format) {
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(d);
    }

    /**
     * 获取下个月时间并格式化
     *
     * @return 返回当前时间
     */
    public static String getNextDate(String format) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, 1);
        SimpleDateFormat dft = new SimpleDateFormat(format);
        String preMonth = dft.format(cal.getTime());
        return preMonth;
    }

    /**
     * 格式化日期时间
     *
     * @param date    Date对象
     * @param pattern 模式
     * @return 格式化后的日期时间字符串
     */
    public static String format(Date date, String pattern) {
        if (date == null)
            return "";
        return new DateTime(date).toString(pattern);
    }

    /**
     * 格式化日期时间字符串
     *
     * @param dateString 日期时间字符串
     * @param pattern    模式
     * @return Date对象
     */
    public static Date formatDateString(String dateString, String pattern) {
        try {
            DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
            return dateTimeFormatter.parseDateTime(dateString).toDate();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 根据秒数获得x天x小时x分钟x秒字符串
     *
     * @param second 秒数
     * @return x天x小时x分钟x秒字符串
     */
    public static String getDayHourMinuteSecond(int second) {
        if (second == 0) {
            return "0秒";
        }
        StringBuilder sb = new StringBuilder();
        int days = second / DAY_SECOND;
        if (days > 0) {
            sb.append(days);
            sb.append("天");
            second -= days * DAY_SECOND;
        }

        int hours = second / HOUR_SECOND;
        if (hours > 0) {
            sb.append(hours);
            sb.append("小时");
            second -= hours * HOUR_SECOND;
        }

        int minutes = second / MINUTE_SECOND;
        if (minutes > 0) {
            sb.append(minutes);
            sb.append("分钟");
            second -= minutes * MINUTE_SECOND;
        }
        if (second > 0) {
            sb.append(second);
            sb.append("秒");
        }
        return sb.toString();
    }

    /**
     * 根据秒数获得x天x小时x分钟字符串
     *
     * @param second 秒数
     * @return x天x小时x分钟字符串
     */
    public static String getDayHourMinute(int second) {
        if (second == 0) {
            return "0分钟";
        }
        StringBuilder sb = new StringBuilder();
        int days = second / DAY_SECOND;
        if (days > 0) {
            sb.append(days);
            sb.append("天");
            second -= days * DAY_SECOND;
        }

        int hours = second / HOUR_SECOND;
        if (hours > 0) {
            sb.append(hours);
            sb.append("小时");
            second -= hours * HOUR_SECOND;
        }
        int minutes = second / MINUTE_SECOND;
        if (minutes > 0) {
            sb.append(minutes);
            sb.append("分钟");
        }
        return sb.toString();
    }

    /**
     * 获取只含有年月日的DateTime对象
     *
     * @param dateTime DateTime对象
     * @return 只含有年月日的DateTime对象
     */
    public static DateTime getDateOnly(DateTime dateTime) {
        return new DateTime(dateTime.toString(YEAR_MONTH_DAY));
    }

    /**
     * 获取当前周的周一和下周一
     *
     * @return 日期数组（索引0为周一，索引1为下周一）
     */
    public static Date[] getMondayAndNextMonday() {
        DateTime dateTime = getDateOnly(new DateTime());
        DateTime monday = dateTime.dayOfWeek().withMinimumValue();
        DateTime nextMonday = monday.plusDays(7);
        return new Date[]{monday.toDate(), nextMonday.toDate()};
    }

    /**
     * 获取指定时间的周一和周日
     *
     * @param dateTime DateTime对象
     * @return 日期数组（索引0为周一，索引1为周日）
     */
    public static Date[] getMondayAndSunday(DateTime dateTime) {
        dateTime = getDateOnly(dateTime);
        DateTime monday = dateTime.dayOfWeek().withMinimumValue();
        DateTime sunday = monday.plusDays(6);
        return new Date[]{monday.toDate(), sunday.toDate()};
    }

    /**
     * 和今天相比的天数差（正数为大于天数，负数为小于天数，零为同一天）
     *
     * @param date Date对象
     * @return 和今天相比的天数差
     */
    public static int compareDaysWithToday(Date date) {
        DateTime today = new DateTime();
        today = new DateTime(today.getYear(), today.getMonthOfYear(), today.getDayOfMonth(), 0, 0, 0, 0);
        DateTime compareDay = new DateTime(date);
        compareDay = new DateTime(compareDay.getYear(), compareDay.getMonthOfYear(), compareDay.getDayOfMonth(), 0, 0, 0, 0);
        return Days.daysBetween(today, compareDay).getDays();
    }

    /**
     * 比较时间a到时间b的天数差
     *
     * @param a 时间a
     * @param b 时间b
     * @return 相差天数
     */
    public static int compareDaysWithDay(Date a, Date b) {
        DateTime today = new DateTime(b);
        today = new DateTime(today.getYear(), today.getMonthOfYear(), today.getDayOfMonth(), 0, 0, 0, 0);
        DateTime compareDay = new DateTime(a);
        compareDay = new DateTime(compareDay.getYear(), compareDay.getMonthOfYear(), compareDay.getDayOfMonth(), 0, 0, 0, 0);
        return Days.daysBetween(today, compareDay).getDays();
    }

    /**
     * 比较两个时间是否相等（省略毫秒）
     *
     * @param date        Date对象
     * @param compareDate 比较Date对象
     * @return 是否相等
     */
    public static boolean compareDateIgnoreMillisecond(Date date, Date compareDate) {
        if (date == null && compareDate == null) {
            return true;
        } else if (date == null && compareDate != null) {
            return false;
        } else if (date != null && compareDate == null) {
            return false;
        }

        return (date.getTime() / 1000 == compareDate.getTime() / 1000);
    }

    /**
     * 根据秒数获取天数
     *
     * @param second 秒数
     * @return 天数
     */
    public static int getDay(int second) {
        return second / DAY_SECOND;
    }

    /**
     * 获取和今天相比的日期字符串
     *
     * @param date Date对象
     * @return 和今天相比的日期字符串
     */
    public static String getCompareWithTodayDateString(Date date) {
        int days = Math.abs(DateUtil.compareDaysWithToday(date));
        String dateString = "";
        if (days == 0) {
            dateString = "今天";
        } else if (days == 1) {
            dateString = "昨天";
        } else if (days == 2) {
            dateString = "2天前";
        } else if (days == 3) {
            dateString = "3天前";
        } else if (days == 4) {
            dateString = "4天前";
        } else if (days == 5) {
            dateString = "5天前";
        } else if (days == 6) {
            dateString = "6天前";
        } else if (days > 6 && days <= 14) {
            dateString = "1周前";
        } else if (days > 14 && days <= 21) {
            dateString = "2周前";
        } else if (days > 21 && days <= 30) {
            dateString = "3周前";
        } else if (days > 30) {
            dateString = "1月前";
        } else if (days > 365) {
            dateString = "1年前";
        } else if (days > 365 * 3) {
            dateString = "3年前";
        }
        return dateString;
    }

    /**
     * 比较两个时间相差分钟数
     *
     * @param now         当前时间
     * @param compareDate 比较时间
     * @return 相差分钟数
     */
    public static int compareMinutes(Date now, Date compareDate) {
        return (int) (now.getTime() - compareDate.getTime()) / 60000;
    }

    /**
     * 比较时间是本月的第几天
     *
     * @param date
     * @return
     */
    public static int getDayOfMonth(Date date) {
        DateTime dateTime = new DateTime(date);
        return dateTime.getDayOfMonth();
    }

    /**
     * 计算今天是今年第几天
     *
     * @return
     */
    public static Integer todayYearDayNum() {
        return -compareDaysWithToday(parse(year(new Date()) - 1 + "-12-31"));
    }

    /**
     * 计算当月有几天
     *
     * @param date
     * @return
     */
    public static int getDateOfMonth(Date date) {
        DateTime dateTime = new DateTime(date);
        return dateTime.dayOfMonth().getMaximumValue();
    }

    /**
     * 指定时间,判断该时间到现在时间的年数
     *
     * @param date 指定时间
     * @return 到现在时间的年数
     */
    public static int compareYear(Date date) {
        DateTime btd = new DateTime(date);
        DateTime nowDate = new DateTime();
        int year = 0;
        if (nowDate.getMonthOfYear() > btd.getMonthOfYear()) {
            year = nowDate.getYear() - btd.getYear();
        } else if (nowDate.getMonthOfYear() < btd.getMonthOfYear()) {
            year = nowDate.getYear() - btd.getYear() - 1;
        } else if (nowDate.getMonthOfYear() == btd.getMonthOfYear()) {
            if (nowDate.getDayOfMonth() >= btd.getDayOfMonth()) {
                year = nowDate.getYear() - btd.getYear();
            } else {
                year = nowDate.getYear() - btd.getYear() - 1;
            }
        }
        return year;
    }

    /**
     * 获取两个日期相差的月数
     */
    public static int getMonthDiff(Date d1, Date d2) {
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        c1.setTime(d1);
        c2.setTime(d2);
        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 startDate
     * @param endDate
     * @return
     */
    public static int compareYear(Date startDate, Date endDate) {
        DateTime btd = new DateTime(startDate);
        DateTime nowDate = new DateTime(endDate);
        int year = 0;
        if (nowDate.getMonthOfYear() > btd.getMonthOfYear()) {
            year = nowDate.getYear() - btd.getYear();
        } else if (nowDate.getMonthOfYear() < btd.getMonthOfYear()) {
            year = nowDate.getYear() - btd.getYear() - 1;
        } else if (nowDate.getMonthOfYear() == btd.getMonthOfYear()) {
            if (nowDate.getDayOfMonth() >= btd.getDayOfMonth()) {
                year = nowDate.getYear() - btd.getYear();
            } else {
                year = nowDate.getYear() - btd.getYear() - 1;
            }
        }
        return year;
    }

    /**
     * 判断2个时间的时间差 返回字符串形式
     *
     * @param date  要对比的字符串
     * @param date2 要对比的字符串
     * @return 字符串形式 如1小时 ，2天2小时
     */
    public static String compareDaysWithDate(Date date, Date date2) {
        StringBuilder msg = new StringBuilder();
        int minutes = (int) Math.abs((date.getTime() - date2.getTime()) / 60000);
        if (minutes / 60 > 0 && minutes / 60 / 24 <= 0) {
            msg.append(minutes / 60 + "小时");
        }
        if (minutes / 60 / 24 > 0) {
            msg.append(minutes / 60 / 24 + "天");
            msg.append(minutes / 60 % 24 + "小时");
        }
        return msg.toString();
    }

    /**
     * 自动解析多种格式的时间字符串为时间对象<br>
     * 支持格式为：yyyy-MM-dd HH:mm:ss 支持多种分隔符，以及多种日期精度。 如yyyy年MM月。 HH时mm分ss秒
     *
     * @param dateString 时间字符串 <br>
     * @return 格式正确则返回对应的java.util.Date对象 格式错误返回null
     */
    public static Date formatUnknownString2Date(String dateString) {
        try {
            if (StringUtil.isEmpty(dateString)) {
                return null;
            }
            dateString = dateString.replace("T", " ");
            String hms = "00:00:00";
            dateString = dateString.trim();
            if (dateString.contains(" ")) {
                // 截取时分秒
                hms = dateString.substring(dateString.indexOf(" ") + 1);
                // 重置日期
                dateString = dateString.substring(0, dateString.indexOf(" "));
                // 多中分隔符的支持
                hms = hms.replace("：", ":");
                hms = hms.replace("时", ":");
                hms = hms.replace("分", ":");
                hms = hms.replace("秒", ":");
                hms = hms.replace("-", ":");
                hms = hms.replace("－", ":");
                // 时间不同精确度的支持
                if (hms.endsWith(":")) {
                    hms = hms.substring(0, hms.length() - 1);
                }
                if (hms.split(":").length == 1) {
                    hms += ":00:00";
                }
                if (hms.split(":").length == 2) {
                    hms += ":00";
                }
            }
            String[] hmsarr = hms.split(":");
            // 不同日期分隔符的支持
            dateString = dateString.replace(".", "-");
            dateString = dateString.replace("/", "-");
            dateString = dateString.replace("－", "-");
            dateString = dateString.replace("年", "-");
            dateString = dateString.replace("月", "-");
            dateString = dateString.replace("日", "");
            // 切割年月日
            String yearStr, monthStr, dateStr;
            // 截取日期
            String[] ymd = dateString.split("-");
            // 判断日期精确度
            yearStr = ymd[0];
            monthStr = ymd.length > 1 ? ymd[1] : "";
            dateStr = ymd.length > 2 ? ymd[2] : "";
            monthStr = monthStr == "" ? Integer.toString(1) : monthStr;
            if (monthStr.length() == 1) {
                monthStr = 0 + monthStr;
            }
            dateStr = dateStr == "" ? Integer.toString(1) : dateStr;
            if (dateStr.length() == 1) {
                dateStr = 0 + dateStr;
            }
            String dtr = (yearStr + "-" + monthStr + "-" + dateStr + " " + hms);
            if (!dtr.matches(REG_EXP_DATE))
                return null;
            // 返回日期
            return new DateTime(Integer.parseInt(yearStr.trim()), Integer.parseInt(monthStr.trim()), Integer.parseInt(dateStr.trim()), Integer.parseInt(hmsarr[0].trim()), Integer.parseInt(hmsarr[1].trim()), Integer.parseInt(hmsarr[2].trim()), 0).toDate();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 解析多个时间，指定时间之间的分隔符和时间的格式符 分隔符不能与格式符相同
     *
     * @param dateString 传入一个时间段字符串
     * @param spaceChar  指定格式符
     * @param splitChar  指定分隔符
     * @return 格式正确返回分割后的时间对象数组 格式错误返回null <br>
     * 指定了格式符为. 分隔符为- 返回值为 时间长度为2的Date类型数组<br>
     * 时间转换的方式详见 {@link DateTimeUtils#formatUnknownString2Date(String dateString)}
     */
    public static Date[] formatDatesByString(String dateString, String spaceChar, String splitChar) {
        if (spaceChar.equals(splitChar)) {
            return null;
        }
        String[] dateStrs = dateString.split(splitChar);
        Date[] dates = new Date[dateStrs.length];
        for (int i = 0, size = dateStrs.length; i < size; i++) {
            dates[i] = formatUnknownString2Date(dateStrs[i]);
        }
        return dates;
    }

    /**
     * 身份证号转生日
     *
     * @param identityCard 身份证
     * @return 生日
     */
    public static Date identityCard2Date(String identityCard) {
        try {
            String dateStr;
            if (identityCard.length() == 18) {
                dateStr = identityCard.substring(6, 14);// 截取18位身份证身份证中生日部分
                return formatDateString(dateStr, "yyyyMMdd");
            }
            if (identityCard.length() == 15) {
                dateStr = identityCard.substring(6, 12);// 截取15位身份证中生日部分
                return formatDateString(dateStr, "yyMMdd");
            }
            return null;
        } catch (Exception e) {
            return null;
        }
    }

    public static boolean validDate(String str) {
        try {
            Date date = formatUnknownString2Date(str);
            return date != null;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 根据周数，获取开始日期、结束日期
     *
     * @param week 周期  0本周，-1上周，-2上上周，1下周，2下下周
     * @return 返回date[0]开始日期、date[1]结束日期
     */
    public static Date[] getWeekStartAndEnd(int week) {
        DateTime dateTime = new DateTime();
        LocalDate date = new LocalDate(dateTime.plusWeeks(week));

        date = date.dayOfWeek().withMinimumValue();
        Date beginDate = date.toDate();
        Date endDate = date.plusDays(6).toDate();
        return new Date[]{beginDate, endDate};
    }

    /**
     * 对日期的【秒】进行加/减
     *
     * @param date    日期
     * @param seconds 秒数，负数为减
     * @return 加/减几秒后的日期
     */
    public static Date addDateSeconds(Date date, int seconds) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusSeconds(seconds).toDate();
    }

    /**
     * 对日期的【分钟】进行加/减
     *
     * @param date    日期
     * @param minutes 分钟数，负数为减
     * @return 加/减几分钟后的日期
     */
    public static Date addDateMinutes(Date date, int minutes) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusMinutes(minutes).toDate();
    }

    /**
     * 对日期的【小时】进行加/减
     *
     * @param date  日期
     * @param hours 小时数，负数为减
     * @return 加/减几小时后的日期
     */
    public static Date addDateHours(Date date, int hours) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusHours(hours).toDate();
    }

    /**
     * 对日期的【天】进行加/减
     *
     * @param date 日期
     * @param days 天数，负数为减
     * @return 加/减几天后的日期
     */
    public static Date addDateDays(Date date, int days) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusDays(days).toDate();
    }

    /**
     * 对日期的【周】进行加/减
     *
     * @param date  日期
     * @param weeks 周数，负数为减
     * @return 加/减几周后的日期
     */
    public static Date addDateWeeks(Date date, int weeks) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusWeeks(weeks).toDate();
    }

    /**
     * 对日期的【月】进行加/减
     *
     * @param date   日期
     * @param months 月数，负数为减
     * @return 加/减几月后的日期
     */
    public static Date addDateMonths(Date date, int months) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusMonths(months).toDate();
    }

    /**
     * 对日期的【年】进行加/减
     *
     * @param date  日期
     * @param years 年数，负数为减
     * @return 加/减几年后的日期
     */
    public static Date addDateYears(Date date, int years) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusYears(years).toDate();
    }

    public static String toString(Date date, String format) {
        String dateStr = null;
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            dateStr = sdf.format(date);
        } catch (Exception e) {
        }
        return dateStr;
    }

    public static Date parseDate(String dateStr, String format) {
        Date date = null;
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            date = sdf.parse(dateStr);
        } catch (Exception e) {
        }
        return date;
    }

    /**
     * 获取日期当天的最小时间日期,0点
     */
    public static Date getMinTimeDateByDate(Date date) {
        if (date == null)
            return null;
        String datestr = toString(date, "yyyyMMdd");
        return parseDate(datestr, "yyyyMMdd");
    }

    /**
     * 获取日期当天的最大时间日期,12点整
     */
    public static Date getMaxTimeDateByDate(Date date) {
        if (date == null)
            return null;
        String datestr = toString(date, "yyyyMMdd");
        Date d = parseDate(datestr, "yyyyMMdd");
        return new Date(d.getTime() + 24L * 60L * 60L * 1000L - 1L);
    }

    public static long subTime(Date startDate, Date endDate) {
        return endDate.getTime() - startDate.getTime();
    }

    public static long getTime(Date date) {
        return date.getTime();
    }

    /**
     * 获取上月第一天最早时间
     *
     * @return Date
     */
    public static Date getLastMonthFirstDay() {
        Calendar cal_1 = Calendar.getInstance();// 获取当前日期
        cal_1.setTime(getMinTimeDateByDate(new Date()));
        cal_1.add(Calendar.MONTH, -1);
        cal_1.set(Calendar.DAY_OF_MONTH, 1);
        return cal_1.getTime();
    }

    /**
     * 获取上月最后一天最晚时间
     *
     * @return Date
     */
    public static Date getLastMonthLastDay() {
        Calendar cale = Calendar.getInstance();
        cale.setTime(getMinTimeDateByDate(new Date()));
        cale.add(Calendar.MONTH, -1);
        cale.set(Calendar.DAY_OF_MONTH, cale.getActualMaximum(Calendar.DAY_OF_MONTH));
        return new Date(cale.getTime().getTime() + 1000L * 60L * 60L * 24L - 1L);
    }

    /**
     * 获取本月第一天最早时间
     *
     * @return Date
     */
    public static Date getNowMonthFirstDay() {
        Calendar cal_1 = Calendar.getInstance();// 获取当前日期
        cal_1.setTime(getMinTimeDateByDate(new Date()));
        cal_1.add(Calendar.MONTH, 0);
        cal_1.set(Calendar.DAY_OF_MONTH, 1);
        return cal_1.getTime();
    }

    /**
     * 获取本月最后一天最晚时间
     *
     * @return Date
     */
    public static Date getNowMonthLastDay() {
        Calendar cale = Calendar.getInstance();
        cale.setTime(getMinTimeDateByDate(new Date()));
        cale.set(Calendar.DAY_OF_MONTH, cale.getActualMaximum(Calendar.DAY_OF_MONTH));
        return new Date(cale.getTime().getTime() + 1000L * 60L * 60L * 24L - 1L);
    }

    /**
     * 获取月最后一天最晚时间
     *
     * @return Date
     */
    public static Date getNowMonthLastDay(Date date) {
        Calendar cale = Calendar.getInstance();
        cale.setTime(getMinTimeDateByDate(date));
        cale.set(Calendar.DAY_OF_MONTH, cale.getActualMaximum(Calendar.DAY_OF_MONTH));
        return new Date(cale.getTime().getTime() + 1000L * 60L * 60L * 24L - 1L);
    }

    /**
     * 获取本月最后一天
     *
     * @return Date
     */
    public static Date getTheMonthLastDay(Date date) {
        if (date == null) {
            return null;
        }
        Calendar cale = Calendar.getInstance();
        cale.setTime(date);
        cale.set(Calendar.DAY_OF_MONTH, cale.getActualMaximum(Calendar.DAY_OF_MONTH));
        cale.set(Calendar.HOUR, 0);
        cale.set(Calendar.HOUR_OF_DAY, 0);
        cale.set(Calendar.MINUTE, 0);
        cale.set(Calendar.SECOND, 0);
        cale.set(Calendar.MILLISECOND, 0);
        return cale.getTime();
    }

    /**
     * 获取格式化的时间，默认是yyyy-MM-dd HH:mm:ss此格式
     *
     * @return
     */
    public static String GetFormatTime() {
        DateTime dateTime = new DateTime().withZone(DateTimeZone.forID("Asia/Shanghai")).toLocalDateTime().toDateTime();
        try {
            return dateTime.toString("yyyy-MM-dd HH:mm:ss");
        } catch (Exception ex) {
            ex.printStackTrace();
            return dateTime.toString();
        }
    }

    /**
     * 获取格式化的时间
     *
     * @param formatter 时间格式化字符串
     * @return
     */
    public static String GetFormatTime(String formatter) {
        DateTime dateTime = new DateTime().withZone(DateTimeZone.forID("Asia/Shanghai")).toLocalDateTime().toDateTime();
        try {
            return dateTime.toString(formatter);
        } catch (Exception ex) {
            ex.printStackTrace();
            return dateTime.toString("yyyy-MM-dd HH:mm:ss");
        }
    }

    /**
     * 获取格式化的时间字符串
     *
     * @param formatTime 自定义时间
     * @param formatter  格式化规则
     * @return
     */
    public static String GetFormatTime(Date formatTime, String formatter) {
        SimpleDateFormat sdf = new SimpleDateFormat(formatter);
        try {
            return sdf.format(formatTime);
        } catch (Exception ex) {
            return GetFormatTime(formatter);
        }
    }

    public static String GetFormatTime(Date formatTime) {
//        YEAR_MONTH_DAY_HOUR_MINUTE
        SimpleDateFormat sdf = new SimpleDateFormat(YEAR_MONTH_DAY_HOUR_MINUTE);
        try {
            return sdf.format(formatTime);
        } catch (Exception ex) {
            return GetFormatTime(YEAR_MONTH_DAY_HOUR_MINUTE);
        }
    }

    /**
     * 短时间变长时间
     *
     * @param tmp 格式：20190301
     * @return
     */
    public static String sortTimeToLongTime(String tmp) {
        return tmp.substring(0, 4) + "-" + tmp.substring(4, 6) + "-" + tmp.substring(6, 8);
    }

    /**
     * 获取今天开始时间
     *
     * @return
     */
    public static Date getTodayStart() {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            return sdf.parse(sdf.format(new Date()));
        } catch (Exception e) {

        }
        return null;
    }

    /**
     * 获取今天结束时间
     *
     * @return
     */
    public static Date getTodayEnd() {
        LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(new Date().getTime()),
                ZoneId.systemDefault());
        LocalDateTime endOfDay = localDateTime.with(LocalTime.MAX);
        return Date.from(endOfDay.atZone(ZoneId.systemDefault()).toInstant());
    }

    public static Date parse(String strDate) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return sdf.parse(strDate);
        } catch (Exception e) {
        }
        return null;
    }

    public static Integer year(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            String format = sdf.format(date);
            return Integer.valueOf(format.substring(0, 4));
        } catch (Exception e) {
        }
        return null;
    }

    public static Integer month(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            String format = sdf.format(date);
            return Integer.valueOf(format.substring(5, 7));
        } catch (Exception e) {
        }
        return null;
    }

    public static Integer day(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            String format = sdf.format(date);
            return Integer.valueOf(format.substring(9, 10));
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * 时分秒转int
     *
     * @param time hh:mm:ss
     * @return hhmmss
     */
    public static Integer getIntTime(String time) {
        if (time.contains("-")) {
            throw new BizException("时间参数错误，请重试");
        }
        boolean a = time.contains(":");
        boolean b = time.contains("：");
        List<String> list = new ArrayList<>();
        if (!a && !b) {
            throw new BizException("时间参数错误，请重试");
        }
        if (a && !b) {
            String[] split = time.split(":");
            list.addAll(Arrays.asList(split));
        }
        if (!a && b) {
            String[] split = time.split("：");
            list.addAll(Arrays.asList(split));
        }
        if (a && b) {
            String[] split = time.split(":");
            for (String s : split) {
                String[] split1 = s.split("：");
                list.addAll(Arrays.asList(split1));
            }
        }
        StringBuilder times = new StringBuilder();
        for (String s : list) {
            times.append(s);
        }
        return Integer.valueOf(times.toString());
    }

    /**
     * 获取周日历
     *
     * @param date 当前时间
     * @param week 0：当前周，负数为减
     * @return 加/减几周后的日期
     */
    public static List<Date> dateList(Date date, int week) {
        Date dateWeek = addDateWeeks(date, week);
        DateTime dateTime = new DateTime(dateWeek.getTime());
        Date[] mondayAndSunday = getMondayAndSunday(dateTime);
        Date weekOne = mondayAndSunday[0];

        List<Date> weekDayList = new ArrayList<>();
        for (int i = 0; i <= 6; i++) {
            weekDayList.add(addDateDays(weekOne, i));
        }
        return weekDayList;
    }

    /**
     * 根据类型解析开始时间
     *
     * @param beginTime 开始时间
     * @param type      类型：1：日、2：周、3：月、4：年
     * @return
     */
    public static String getBeginTime(String beginTime, Integer type) {
        if (type == null) {
            throw new BizException("时间类型参数不能为空");
        }

        if (StringUtils.isEmpty(beginTime)) {
            beginTime = GetFormatTime(getTodayStart(), DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        }

        if (type == 1) {
            if (beginTime.length() < 10) {
                throw new BizException("开始时间参数错误；参数为：" + beginTime);
            }
            beginTime = beginTime.substring(0, 10) + " 00:00:00";
        } else if (type == 2) {
            if (beginTime.length() < 10) {
                throw new BizException("开始时间参数错误；参数为：" + beginTime);
            }
            beginTime = beginTime.substring(0, 10) + " 00:00:00";
        } else if (type == 3) {
            if (beginTime.length() < 7) {
                throw new BizException("开始时间参数错误；参数为：" + beginTime);
            }
            beginTime = beginTime.substring(0, 7) + "-01 00:00:00";
        } else if (type == 4) {
            if (beginTime.length() < 4) {
                throw new BizException("开始时间参数错误；参数为：" + beginTime);
            }
            beginTime = beginTime.substring(0, 4) + "-01-01 00:00:00";
        }
        return beginTime;
    }

    /**
     * 解析开始时间
     *
     * @param beginTime
     * @return
     */
    public static String getBeginTime(String beginTime) {
        if (StringUtils.isEmpty(beginTime)) {
            beginTime = GetFormatTime(getTodayStart(), DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        } else if (beginTime.length() < 4) {
            throw new BizException("时间格式错误");
        } else if (beginTime.length() == 4) {
            beginTime = beginTime.substring(0, 4) + "-01-01 00:00:00";
        } else if (beginTime.length() >= 7 && beginTime.length() < 10) {
            beginTime = beginTime.substring(0, 7) + "-01 00:00:00";
        } else if (beginTime.length() >= 10) {
            beginTime = beginTime.substring(0, 10) + " 00:00:00";
        }
        return beginTime;
    }

    /**
     * 根据类型解析结束时间
     *
     * @param endTime 结束时间
     * @param type    类型：1：日、2：周、3：月、4：年
     * @return
     */
    public static String getEndTime(String endTime, Integer type) {
        if (type == null) {
            throw new BizException("时间类型参数不能为空");
        }

        if (StringUtils.isEmpty(endTime)) {
            endTime = GetFormatTime(getTodayEnd(), DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        }

        if (type == 1) {
            if (endTime.length() < 10) {
                throw new BizException("结束时间参数错误；参数为：" + endTime);
            }
            endTime = endTime.substring(0, 10) + " 23:59:59";
        } else if (type == 2) {
            if (endTime.length() < 10) {
                throw new BizException("结束时间参数错误；参数为：" + endTime);
            }
            endTime = endTime.substring(0, 10) + " 23:59:59";
        } else if (type == 3) {
            if (endTime.length() < 7) {
                throw new BizException("结束时间参数错误；参数为：" + endTime);
            }
            endTime = GetFormatTime(getNowMonthLastDay(formatDateString(endTime.substring(0, 7), YEAR_MONTH)), YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        } else if (type == 4) {
            if (endTime.length() < 4) {
                throw new BizException("结束时间参数错误；参数为：" + endTime);
            }
            endTime = endTime.substring(0, 4) + "-12-31 23:59:59";
        }
        return endTime;
    }

    /**
     * 解析结束时间
     *
     * @param endTime
     * @return
     */
    public static String getEndTime(String endTime) {
        if (StringUtils.isEmpty(endTime)) {
            endTime = GetFormatTime(getTodayEnd(), DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        } else if (endTime.length() < 4) {
            throw new BizException("时间格式错误");
        } else if (endTime.length() == 4) {
            endTime = endTime.substring(0, 4) + "-12-31 23:59:59";
        } else if (endTime.length() >= 7 && endTime.length() < 10) {
            endTime = GetFormatTime(getNowMonthLastDay(formatDateString(endTime.substring(0, 7), YEAR_MONTH)), YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        } else if (endTime.length() >= 10) {
            endTime = endTime.substring(0, 10) + " 23:59:59";
        }
        return endTime;
    }

    /**
     * 计算两个时间之间相差  改方法只有计算目标值使用!!!!其他方法请勿使用
     *
     * @param startDate 开始时间
     * @param endDate   结束时间
     * @return {{year=0,month=1,  days=3}
     */
    public static Map<String, Long> getTerm(java.time.LocalDate startDate, java.time.LocalDate endDate) {
        HashMap<String, Long> map = new HashMap<>();
        try {
            int startYear = startDate.getYear();
            int startMonth = startDate.getMonthValue();
            int startDay = startDate.getDayOfMonth();
            int endYear = endDate.getYear();
            int endMonth = endDate.getMonthValue();
            int endDay = endDate.getDayOfMonth();

            java.time.LocalDate nowStartMonth = startDate.with(TemporalAdjusters.firstDayOfMonth());
            java.time.LocalDate nowEndMonth = endDate.with(TemporalAdjusters.lastDayOfMonth());

            //获取两个日期间隔年
            long y = ChronoUnit.YEARS.between(startDate, endDate);
            //获取两个日期间隔月
            long m = ChronoUnit.MONTHS.between(nowStartMonth, nowEndMonth);
            //获取两个日期间隔天
            long d = ChronoUnit.DAYS.between(startDate, endDate);
            //获取某个月的最后一天
            int lastDayOfEndDate = endDate.with(TemporalAdjusters.lastDayOfMonth()).getDayOfMonth();
            if (startYear == endYear) {
                if (startDay == endDay || lastDayOfEndDate == endDay) {
                    m = endMonth - startMonth;
                } else {
                    //获取传入时间对象的Day值
                    d = endDate.getDayOfMonth();
                }
            } else {
                if (startDay == endDay || lastDayOfEndDate == endDay) {
                    d = 0;
                } else {
                    d = endDate.getDayOfMonth();
                }
            }
            map.put("year", y);
            map.put("month", m);
            map.put("day", d);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

    public static int getOneYearDay(int year) {
        int days;//某年(year)的天数
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {//闰年的判断规则
            days = 366;
        } else {
            days = 365;
        }
        return days;
    }

    public static int intervalJudgment(String restBeginTime, String restEndTime, String beginTime, String endTime) {
        if (StringUtil.isEmpty(restBeginTime) || StringUtil.isEmpty(restEndTime)) {
            return 1;
        }
        if (isEffectiveDate(parseDate(beginTime, DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE), parseDate(restBeginTime, DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE), parseDate(restEndTime, DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE))) {
            return 2;
        }
        if (isEffectiveDate(parseDate(endTime, DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE), parseDate(restBeginTime, DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE), parseDate(restEndTime, DateUtil.YEAR_MONTH_DAY_HOUR_MINUTE))) {
            return 2;
        }
        return 1;
    }

    public static boolean isEffectiveDate(Date nowTime, Date startTime, Date endTime) {
        if (nowTime.getTime() == startTime.getTime()
                || nowTime.getTime() == endTime.getTime()) {
            return true;
        }

        Calendar date = Calendar.getInstance();
        date.setTime(nowTime);

        Calendar begin = Calendar.getInstance();
        begin.setTime(startTime);

        Calendar end = Calendar.getInstance();
        end.setTime(endTime);

        if (date.after(begin) && date.before(end)) {
            return true;
        } else {
            return false;
        }
    }

    public static int getHourByCalendar(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int hour = cal.get(Calendar.HOUR);//小时
        int minute = cal.get(Calendar.MINUTE);//分
        return hour;
    }

    /**
     * 获取两个日期之间的所有日期(字符串格式, 按天计算)
     *
     * @param startTime String 开始时间 yyyy-MM-dd
     * @param endTime   String 结束时间 yyyy-MM-dd
     * @return
     */
    public static List<String> getBetweenDays(String startTime, String endTime) {
        if (StringUtils.isEmpty(startTime) || StringUtils.isEmpty(endTime)) {
            return new ArrayList<>();
        }
        //1、定义转换格式
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");

        Date start = null;
        Date end = null;
        try {
            start = df.parse(startTime);
            end = df.parse(endTime);

        } catch (ParseException e) {
            e.printStackTrace();
        }
        if (StringUtil.isEmpty(start) || StringUtil.isEmpty(end)) {
            return new ArrayList<>();
        }
        if (start.getTime() > end.getTime()) {
            throw new BizException("开始时间不能大于结束时间");
        }

        List<String> result = new ArrayList<String>();
        Calendar tempStart = Calendar.getInstance();
        tempStart.setTime(start);

        tempStart.add(Calendar.DAY_OF_YEAR, 1);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar tempEnd = Calendar.getInstance();
        tempEnd.setTime(end);
        result.add(sdf.format(start));
        while (tempStart.before(tempEnd)) {
            result.add(sdf.format(tempStart.getTime()));
            tempStart.add(Calendar.DAY_OF_YEAR, 1);
        }
        if (start.getTime() != end.getTime()) {
            result.add(sdf.format(end));
        }
        return result;
    }

    public static ArrayList<String> getDays(int intervals) {
        ArrayList pastDaysList = new ArrayList<>();

        for (int i = 0; i < intervals; i++) {
            pastDaysList.add(getPastDate(i));
        }
        return pastDaysList;
    }

    public static String getWeek(String dateTime) {
        String week = "";

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        try {
            Date date = sdf.parse(dateTime);

            SimpleDateFormat dateFm = new SimpleDateFormat("EEEE", Locale.CHINESE);
            dateFm.setTimeZone(TimeZone.getTimeZone("Etc/GMT-8"));

            week = dateFm.format(date);

            week = week.replaceAll("星期", "周");

        } catch (ParseException e) {
            e.printStackTrace();
        }

        return week;

    }

    public static String getPastDate(int past) {
        Calendar calendar = Calendar.getInstance();

        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + past);

        Date today = calendar.getTime();

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");

        String result = format.format(today);

        return result;

    }

    public static String getCurrentDate(String dateStr, Integer second) {
        SimpleDateFormat df = new SimpleDateFormat(YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
        Date date = null;
        try {
            date = df.parse(dateStr);
            date.setTime(date.getTime() + second);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return df.format(date);
    }

    public static String addDateDays(String dateStr, int days) {

        String timeStr = dateStr.split(" ")[1];
        dateStr = dateStr.split(" ")[0];
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat df = new SimpleDateFormat(YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);

        Date date = null;
        try {
            date = sdf.parse(dateStr);
            date = addDateDays(date, days);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (date != null) {
            if (!StringUtil.isEmpty(timeStr)) {
                return df.format(date) + " " + timeStr;
            }
            return df.format(date);
        }
        return null;
    }