超级全的日期时间工具类DateUtils

package com.nuiiqk.common.util;
import java.lang.management.ManagementFactory;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 时间的操作的工具类
 *
 * @author NuiiQK
 * @date 2020/12/24 024
 */
public class DateUtils {

    public static final String STARTTIME = " 00:00:00";
    public static final String ENDTIME = " 23:59:59";
    public final static String FORMAT_STRING = "yyyy-MM-dd HH:mm:ss";
    public final static String[] REPLACE_STRING = new String[] {"GMT+0800", "GMT+08:00"};
    public final static String SPLIT_STRING = "(中国标准时间)";
    // 日志输出器
    public static Logger log = LoggerFactory.getLogger(DateUtils.class);

    public static String YYYY = "yyyy";

    public static String YYYY_MM = "yyyy-MM";

    public static String YYYY_MM_DD = "yyyy-MM-dd";

    public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

    public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

    private final static String in_formate_s = "yyyy-MM-dd";

    private final static String in2_formate_s = "yyyy-MM-dd HH:mm:ss";

    private final static String out_formate_s = "MM/dd/yyyy";

    private final static String out3_formate_s = "MM/dd/yyyy HH:mm:ss";

    private static String[] parsePatterns =
            {"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM", "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss",
                    "yyyy/MM/dd HH:mm", "yyyy/MM", "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};

    private DateUtils() {}

    /**
     * 获取今天开始的时间
     *
     * @return
     * @author NuiiQK
     *         2018年5月8日 上午9:40:53
     */
    public static String getToDayStartTime() {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        Date date = new Date(System.currentTimeMillis());
        return formate.format(date);
    }

    /**
     * 获取今天结束的时间
     *
     * @return
     * @author NuiiQK
     *         2018年6月12日
     */
    public static String getToDayEndTime() {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        Date date = new Date(System.currentTimeMillis());
        return formate.format(date);
    }

    /**
     * 获取昨天开始的时间
     *
     * @return
     * @author NuiiQK
     *         2018年6月11日
     */
    public static String getYestodayStartTime() {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        Date date = new Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L);
        return formate.format(date);
    }

    /**
     * 获取昨天结束的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月11日
     */
    public static String getYestodayEndTime() {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        Date date = new Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L);
        return formate.format(date);
    }

    /**
     * 获取某天开始的时间
     *
     * @return
     * @author NuiiQK
     *         2019年6月20日09:39:25
     */
    public static String getOneDayStartTime(String oneDay) {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        Date date = new Date(oneDay);
        return formate.format(date);
    }

    public static String getOneDayStartTime(Date oneDay) {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        return formate.format(oneDay);
    }

    /**
     * 获取某天结束的时间
     *
     * @return
     * @author NuiiQK
     *         2019年6月20日09:42:16
     */
    public static String getOneDayEndTime(String oneDay) {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        Date date = new Date(oneDay);
        return formate.format(date);
    }

    public static String getOneDayEndTime(Date oneDay) {
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        return formate.format(oneDay);
    }

    /**
     * 获取本周开始的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static Date getWeekStartTime() {
        // 获得本周一0点时间
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        return cal.getTime();
    }

    /**
     * 将 String 转换成 date
     *
     * @param dateTime
     * @return
     * @author NuiiQK
     * @date 2018年6月19日
     */
    public static Date strToDateTime(String dateTime) {
        Date date = null;
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            date = format.parse(dateTime);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 将 date 转换成 时间戳
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月26日
     */
    public static Long dateToStamp(String s) throws ParseException {

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = simpleDateFormat.parse(s);
        long ts = date.getTime();
        return ts;
    }

    /**
     * Date 转换成 String
     *
     * @param dateTime
     * @return
     * @author NuiiQK
     * @date 2018年6月19日
     */
    public static String dateTimeToStr(Date dateTime) {

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return format.format(dateTime);
    }

    /**
     * 获取本周开始的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getWeekStartTimeStr() {
        // 获得本周一0点时间
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        return formate.format(cal.getTime());
    }

    /**
     * 获取本周结束的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static Date getWeekEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getWeekStartTime());
        cal.add(Calendar.DAY_OF_WEEK, 7);
        return cal.getTime();
    }

    /**
     * 获取本周结束的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getWeekEndTimeStr() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getWeekStartTime());
        cal.add(Calendar.DAY_OF_WEEK, 7);
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        return formate.format(cal.getTime());
    }

    /**
     * 获取上周开始的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getLastWeekStartTimeStr() {
        int weeks = -1;
        int mondayPlus = getMondayPlus();
        GregorianCalendar currentDate = new GregorianCalendar();
        currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks);
        Date monday = currentDate.getTime();
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
        return formate.format(monday);
    }

    /**
     * 获取本月开始的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static Date getMonthStartTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(Calendar.DAY_OF_MONTH));
        return cal.getTime();
    }

    /**
     * 获取本月开始的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getMonthStartTimeStr() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(Calendar.DAY_OF_MONTH));
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        return formate.format(cal.getTime());
    }

    /**
     * 获取本月结束的时间
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static Date getMonthEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 24);
        return cal.getTime();
    }

    /**
     * 获取本月结束的时间的字符串
     *
     * @return
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static String getMonthEndTimeStr() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 24);
        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
        return formate.format(cal.getTime());
    }

    /**
     * 获取当月的 天数
     */
    public static int getCurrentMonthDay() {
        Calendar a = Calendar.getInstance();
        a.set(Calendar.DATE, 1);
        a.roll(Calendar.DATE, -1);
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }

    /**
     * 得到二个日期间的间隔天数
     */
    public static int getDayByTwoDay(String sj1, String sj2) {
        SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
        Long day = 0L;
        try {
            Date date = myFormatter.parse(sj1);
            Date mydate = myFormatter.parse(sj2);
            day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
        } catch (Exception e) {
            return 0;
        }
        return day.intValue();
    }

    /**
     * 得到两个日期相差的秒数
     *
     * @param lastDate
     * @param date
     * @return
     */
    public static int getSecondByTwoDay(Date lastDate, Date date) {
        Long second = 0L;
        try {
            second = (lastDate.getTime() - date.getTime()) / 1000;
        } catch (Exception e) {
            return 0;
        }
        return second.intValue();
    }

    /**
     * 判断某个日期属于本周的第几天 (星期一代表第一天)
     *
     * @param dateTime
     * @return
     * @throws ParseException
     * @author NuiiQK
     * @date 2018年6月13日
     */
    public static int getDaysByWeek(String dateTime) throws ParseException {
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = dateFormat.parse(dateTime);
        cal.setTime(date);
        int day = cal.get(Calendar.DAY_OF_WEEK);
        day = day - 1;
        if (day == 0) {
            day = 7;
        }
        return day;
    }

    /**
     * 判断某个日期属于本月的第几天
     *
     * @param dateTime
     * @return
     * @throws ParseException
     * @author NuiiQK
     * @date 2018年6月14日
     */
    public static int getDaysByMonth(String dateTime) throws ParseException {
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = dateFormat.parse(dateTime);
        cal.setTime(date);
        int day = cal.get(Calendar.DAY_OF_MONTH);
        return day;
    }

    /**
     * 根据年 月 获取对应的月份 天数
     */
    public static int getDaysByYearMonth(int year, int month) {

        Calendar a = Calendar.getInstance();
        a.set(Calendar.YEAR, year);
        a.set(Calendar.MONTH, month - 1);
        a.set(Calendar.DATE, 1);
        a.roll(Calendar.DATE, -1);
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }

    /**
     * 获取当前的年
     *
     * @return
     * @author NuiiQK
     *         2018年5月8日 上午9:36:12
     */
    public static Integer getYears() {
        Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
        return calendar.get(Calendar.YEAR);

    }

    /**
     * 获取当前的月
     *
     * @return
     * @author NuiiQK
     *         2018年5月8日 上午9:37:37
     */
    public static Integer getMonth() {
        Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
        return calendar.get(Calendar.MONTH) + 1;

    }

    /**
     * 获取当前天
     *
     * @return
     * @author NuiiQK
     *         2018年5月8日 上午10:31:37
     */
    public static Integer getDay() {
        Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
        return calendar.get(Calendar.DAY_OF_MONTH);
    }

    /**
     * wx支付的过期时间
     *
     * @param hour
     * @return
     */
    @SuppressWarnings("unused")
    public static String getTime(double hour) {
        Calendar calendar = new GregorianCalendar(TimeZone.getDefault());
        long time = (long)(System.currentTimeMillis() + hour * 60 * 60 * 1000L);
        Date date = new Date(time);
        SimpleDateFormat formate = new SimpleDateFormat("yyyyMMddHHmmss");
        String format = formate.format(date);
        return format;
    }

    // 获得当前日期与本周日相差的天数
    private static int getMondayPlus() {
        Calendar cd = Calendar.getInstance();
        // 获得今天是一周的第几天，星期日是第一天，星期二是第二天......
        int dayOfWeek = cd.get(Calendar.DAY_OF_WEEK) - 1; // 因为按中国礼拜一作为第一天所以这里减1
        if (dayOfWeek == 1) {
            return 0;
        } else {
            return 1 - dayOfWeek;
        }
    }

    /**
     * 获取几天之后的日期（wq）
     *
     * @param date yyyy-MM-dd HH:mm:ss
     * @param day 加减的天数
     * @return
     */
    public static Date getDate(String date, int day) {

        SimpleDateFormat formate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Calendar cal = Calendar.getInstance();
        try {
            Date beforeDate = formate.parse(date);
            cal.setTime(beforeDate);
            cal.add(Calendar.DAY_OF_MONTH, day);
            // cal.set(beforeDate.getYear(), beforeDate.getMonth(), beforeDate.getDay()+day,
            // beforeDate.getHours(),beforeDate.getSeconds(), beforeDate.getMinutes());
            Date newDate = cal.getTime();
            return newDate;
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 把date转换成字符串
     *
     * @param date
     * @param code 例如 yyyy-MM-dd 00:00:00
     * @return
     */
    public static String formateDate(Date date, String code) {
        SimpleDateFormat formate = new SimpleDateFormat(code);
        return formate.format(date);

    }

    /**
     * 获取过去N天内的日期数组
     *
     * @param intervals intervals天内
     * @param formatStr 格式化字符串 yyyy-MM-dd
     * @return 日期数组
     */
    public static ArrayList<String> getDaysByN(int intervals, String formatStr) {
        ArrayList<String> pastDaysList = new ArrayList<>();
        for (int i = intervals - 1; i >= 0; i--) {
            pastDaysList.add(getPastDate(i, formatStr));
        }
        return pastDaysList;
    }

    /**
     * 获取过去第几天的日期
     *
     * @param past
     * @return
     */
    public static String getPastDate(int past, String formatStr) {
        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(formatStr);
        String result = format.format(today);
        return result;
    }

    /**
     * 获取某个时间段内所有日期
     *
     * @param begin
     * @param end
     * @return
     */
    public static List<String> getDayBetweenDates(String begin, String end) {
        Date dBegin = strToDateTime(begin);
        Date dEnd = strToDateTime(end);
        List<String> lDate = new ArrayList<>();
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
        lDate.add(sd.format(dBegin));
        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(dBegin);
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calEnd.setTime(dEnd);
        // 测试此日期是否在指定日期之后
        while (dEnd.after(calBegin.getTime())) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            calBegin.add(Calendar.DAY_OF_MONTH, 1);
            lDate.add(sd.format(calBegin.getTime()));
        }
        return lDate;
    }

    /**
     * 获取服务器启动时间
     */
    public static Date getServerStartDate() {
        long time = ManagementFactory.getRuntimeMXBean().getStartTime();
        return new Date(time);
    }

    /**
     * 计算两个时间差
     */
    public static String getDatePoor(Date endDate, Date nowDate) {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时" + min + "分钟";
    }

    /**
     * "yyyy-MM-dd" to "MM/dd/yyyy";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return "";
        }
        return new SimpleDateFormat(out_formate_s).format(new SimpleDateFormat(in_formate_s).parse(inDate));
    }

    /**
     * "MM/dd/yyyy"; to "yyyy-MM-dd"
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange2(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return "";
        }

        return new SimpleDateFormat(in_formate_s).format(new SimpleDateFormat(out_formate_s).parse(inDate));
    }

    /**
     * "MM/dd/yyyy HH:mm:ss"; to "yyyy-MM-dd HH:mm:ss";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange3(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return "";
        }

        return new SimpleDateFormat(in2_formate_s).format(new SimpleDateFormat(out3_formate_s).parse(inDate));
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"; to "MM/dd/yyyy HH:mm:ss";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange4(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return "";
        }

        return new SimpleDateFormat(in2_formate_s).format(new SimpleDateFormat(out3_formate_s).parse(inDate));
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"; to "Data";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static Date dateChange1(String inDate) throws ParseException {
        return new SimpleDateFormat(in2_formate_s).parse(inDate);
    }

    /**
     * "Data"; to "yyyy-MM-dd HH:mm:ss";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange(Date inDate) throws ParseException {
        if (inDate == null) {
            return "";
        }
        return new SimpleDateFormat(in2_formate_s).format(inDate);
    }

    /**
     * "Data"; to "yyyy-MM-dd";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static String dateChange5(Date inDate) throws ParseException {
        if (inDate == null) {
            return "";
        }
        return new SimpleDateFormat(in_formate_s).format(inDate);
    }

    /**
     * "yyyy/MM/dd"; to "Data";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static Date dateChange6(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return null;
        }
        return new SimpleDateFormat(out_formate_s).parse(inDate);
    }

    /**
     * "yyyy-MM-dd"; to "Data";
     *
     * @param inDate
     * @return
     * @throws ParseException
     */
    public static Date dateChange7(String inDate) throws ParseException {
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return null;
        }
        return new SimpleDateFormat(in_formate_s).parse(inDate);
    }

    /*    *//**
     * "MM/dd/yyyy" to "yyyy-MM-dd"
     *
     * @param inDate
     * @return
     * @throws ParseException
     *//*
                       public static String dateChange4(String inDate) throws ParseException {
                        if(StringUtils.isBlank(inDate)) return "";

                        return in_formate.format(out_formate_s.parse(inDate));
                       }*/

    /**
     * 将字符串的时间按照format格式转换为date
     *
     * @param inDate
     * @param format
     * @return
     * @throws ParseException
     */
    public static Date stringToDate(String inDate, String format) throws ParseException {
        // TODO Auto-generated method stub
        if (org.apache.commons.lang3.StringUtils.isBlank(inDate)) {
            return null;
        }
        return new SimpleDateFormat(format).parse(inDate);
    }

    /**
     * 将date按照format格式转换为String
     *
     * @param inDate
     * @param format
     * @return
     * @throws ParseException
     */
    public static String dateToString(Date inDate, String format) throws ParseException {
        // TODO Auto-generated method stub
        if (inDate == null) {
            return "";
        }
        return new SimpleDateFormat(format).format(inDate);
    }

    /**
     * 将数据库查出来的时间多.0的string时间去掉.0
     *
     * @param time
     * @return
     */
    public static String normTime(String time) {
        if (StringUtils.isEmpty(time)) {
            return "";
        }
        int index = time.indexOf(".0");
        if (index >= 0) {
            time = time.substring(0, index);
        }
        return time;
    }

    /**
     * 判断当前日期是否在期间内
     *
     * @param deadLine 格式: 2018-04-01|2018-06-30
     * @return
     */
    public static boolean isDeadLine(String deadLine) {
        boolean result = false;

        String start = deadLine.substring(0, deadLine.indexOf("|"));
        String end = deadLine.substring(deadLine.indexOf("|") + 1);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date startDate = sdf.parse(start);
            Date endDate = sdf.parse(end);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(endDate);
            calendar.add(Calendar.DAY_OF_YEAR, 1);
            endDate = calendar.getTime();
            Date now = new Date();
            if (now.after(startDate) && now.before(endDate)) {
                result = true;
            }

        } catch (Exception e) {
            log.info("Exception ", e);
        }
        return result;
    }

    /**
     * 获取上海时区的当前日期时间
     *
     * @return yyyy-MM-dd HH:mm:ss
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getNowDateTime() {
        return getNowDateTimeFormatter("yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 获取上海时区的昨天的日期时间
     *
     * @return yyyy-MM-dd HH:mm:ss
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getYesterdayDateTime() {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        return LocalDateTime.now(ZoneId.of("Asia/Shanghai")).minusDays(1).format(formatter);
    }

    /**
     * 获取上海时区的昨天的日期
     *
     * @return yyyy-MM-dd
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getYesterdayDate() {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        return LocalDate.now(ZoneId.of("Asia/Shanghai")).minusDays(1).format(formatter);
    }

    /**
     * 获取上海时区的当前日期
     *
     * @return yyyy-MM-dd
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getNowDate() {
        return getNowDateTimeFormatter("yyyy-MM-dd");
    }

    /**
     * yyyy-MM-dd HH:mm:ss格式时间字符串转换为yyyy-MM-dd格式
     *
     * @return
     * @author NuiiQK
     * @date 2019-11-08
     */
    public static String dateTimeTODate(String timeStr) {
        return getDateTimeToFormatter(timeStr, "yyyy-MM-dd");
    }

    /**
     * 获取上海时区的当前年
     *
     * @return yyyy-MM-dd
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static int getNowYear() {
        return LocalDate.now(ZoneId.of("Asia/Shanghai")).getYear();
    }

    /**
     * 获取上海时区的当前日期的日
     *
     * @return yyyy-MM-dd
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static int getNowDayOfMonth() {
        return LocalDateTime.now(ZoneId.of("Asia/Shanghai")).getDayOfMonth();
    }

    /**
     * 获取上海时区的当前星期
     *
     * @return
     * @author NuiiQK
     * @date 2019-11-08
     */
    public static int getNowDayOfWeek() {
        return LocalDate.now(ZoneId.of("Asia/Shanghai")).getDayOfWeek().getValue();
    }

    /**
     * 获取上海时区的当前时间
     *
     * @return HH:mm:ss
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static String getNowTime() {
        return getNowDateTimeFormatter("HH:mm:ss");
    }

    /**
     * 获取上海时区的当前小时
     *
     * @return HH:mm:ss
     * @author NuiiQK
     * @date 2019-07-16
     */
    public static int getNowHour() {
        return LocalDateTime.now(ZoneId.of("Asia/Shanghai")).getHour();
    }

    /**
     * 获取当天的毫秒秒时间值
     *
     * @return
     * @author NuiiQK
     * @date 2019-09-09
     */
    public static String getMicroTimestamp() {
        return String.valueOf(LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli());
    }

    /**
     * 获取当天的秒时间值
     *
     * @return
     * @author NuiiQK
     * @date 2019-09-09
     */
    public static String getTimestamp() {
        return String.valueOf(LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8")));
    }

    /**
     * 指定格式化当前时间
     *
     * @param pattern
     * @return
     * @author NuiiQK
     * @date 2019-09-10
     */
    public static String getNowDateTimeFormatter(String pattern) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return LocalDateTime.now(ZoneId.of("Asia/Shanghai")).format(formatter);
    }

    /**
     * yyyy-MM-dd HH:mm:ss格式日期时间字符串转换指定格式时间字符串
     *
     * @param timeStr
     * @param pattern
     * @return
     * @author NuiiQK
     * @date 2019-10-25
     */
    public static String getDateTimeToFormatter(String timeStr, String pattern) {
        if (StringUtils.isEmpty(timeStr)) {
            return "";
        }
        LocalDateTime time = LocalDateTime.parse(timeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return time.format(formatter);
    }

    /**
     * yyyy-MM-dd格式日期字符串转换指定格式日期字符串
     *
     * @param timeStr
     * @param pattern
     * @return
     * @author NuiiQK
     * @date 2019-10-25
     */
    public static String getDateToFormatter(String timeStr, String pattern) {
        if (StringUtils.isEmpty(timeStr)) {
            return "";
        }
        LocalDate time = LocalDate.parse(timeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return time.format(formatter);
    }

    /**
     * HH:mm:ss格式时间字符串转换指定格式时间字符串
     *
     * @param timeStr
     * @param pattern
     * @return
     * @author NuiiQK
     * @date 2019-10-25
     */
    public static String getTimeToFormatter(String timeStr, String pattern) {
        if (StringUtils.isEmpty(timeStr)) {
            return "";
        }
        LocalTime time = LocalTime.parse(timeStr, DateTimeFormatter.ofPattern("HH:mm:ss"));
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return time.format(formatter);
    }

    /**
     * 以当前时间生成yyyyMMddHHmmssSSS格式的编号
     *
     * @return
     * @author NuiiQK
     * @date 2019-09-10
     */
    public static String getDateTimeCode() {
        return getNowDateTimeFormatter("yyyyMMddHHmmssSSS");
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串转换为LocalDateTime对象
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static LocalDateTime parseDateTime(String timeStr) {
        return LocalDateTime.parse(timeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * "yyyy-MM-dd"格式时间字符串转换为LocalDate对象
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static LocalDate parseDate(String timeStr) {
        return LocalDate.parse(timeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }

    /**
     * "HH:mm:ss"格式时间字符串转换为LocalTime对象
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static LocalTime parseTime(String timeStr) {
        return LocalTime.parse(timeStr, DateTimeFormatter.ofPattern("HH:mm:ss"));
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串是否在当前时间之后
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeAfterNow(String timeStr) {
        return parseDateTime(timeStr).isAfter(LocalDateTime.now());
    }

    /**
     * "yyyy-MM-dd"格式时间字符串是否在当前时间之后
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateAfterNow(String timeStr) {
        return parseDate(timeStr).isAfter(LocalDate.now());
    }

    /**
     * "HH:mm:ss"格式时间字符串是否在当前时间之后
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean timeAfterNow(String timeStr) {
        return parseTime(timeStr).isAfter(LocalTime.now());
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串是否在当前时间之前
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeBeforeNow(String timeStr) {
        return parseDateTime(timeStr).isBefore(LocalDateTime.now());
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串是否在当前时间之前
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateBeforeNow(String timeStr) {
        return parseDate(timeStr).isBefore(LocalDate.now());
    }

    /**
     * "HH:mm:ss"格式时间字符串是否在当前时间之前
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean timeBeforeNow(String timeStr) {
        return parseTime(timeStr).isBefore(LocalTime.now());
    }

    /**
     * 某日期时间是否在另一日期时间之后
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeAfterDateTime(String t1, String t2) {
        return parseDateTime(t1).isAfter(parseDateTime(t2));
    }

    /**
     * 某日期是否在另一日期之后
     * "yyyy-MM-dd"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateAfterDate(String t1, String t2) {
        return parseDate(t1).isAfter(parseDate(t2));
    }

    /**
     * 某时间是否在另一时间之后
     * "HH:mm:ss"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean timeAfterTime(String t1, String t2) {
        return parseTime(t1).isAfter(parseTime(t2));
    }

    /**
     * 某日期时间是否在另一日期时间之前
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeBeforeDateTime(String t1, String t2) {
        return parseDateTime(t1).isBefore(parseDateTime(t2));
    }

    /**
     * 某日期是否在另一日期之前
     * "yyyy-MM-dd"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateBeforeDate(String t1, String t2) {
        return parseDate(t1).isBefore(parseDate(t2));
    }

    /**
     * 某时间是否在另一时间之前
     * "HH:mm:ss"格式时间字符串
     *
     * @param t1
     * @param t2
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean timeBeforeTime(String t1, String t2) {
        return parseTime(t1).isBefore(parseTime(t2));
    }

    /**
     * "yyyy-MM-dd HH:mm:ss"格式时间字符串是否在当天之后包括当天
     *
     * @param timeStr
     * @return
     * @author NuiiQK
     * @date 2019-10-18
     */
    public static boolean dateTimeAfterNowDate(String timeStr) {
        return parseDateTime(timeStr).toLocalDate().isAfter(LocalDate.now().plusDays(-1));
    }

    /**
     * 计算两个时间的差"yyyy-MM-dd HH:mm:ss"格式字符串
     *
     * @param unit
     * @return
     * @author NuiiQK
     * @date 2019-11-12
     */
    public static long differ(String startStr, String endStr, TimeUnit unit) throws Exception {
        LocalDateTime start = parseDateTime(startStr);
        LocalDateTime end = parseDateTime(endStr);
        Duration duration = Duration.between(start, end);
        long res;
        if (TimeUnit.DAYS == unit) {
            // 相差的天数
            res = duration.toDays();
        } else if (TimeUnit.HOURS == unit) {
            // 相差的小时数
            res = duration.toHours();
        } else if (TimeUnit.MINUTES == unit) {
            // 相差的分钟数
            res = duration.toMinutes();
        } else if (TimeUnit.MILLISECONDS == unit) {
            // 相差毫秒数
            res = duration.toMillis();
        } else if (TimeUnit.NANOSECONDS == unit) {
            // 相差的纳秒数
            res = duration.toNanos();
        } else {
            throw new Exception("unsupport unit: " + unit);
        }
        return res;
    }
}