时间格式util

package com.dlxx.util;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dlxx.entity.po.HolidayPo;
import com.dlxx.service.HolidayService;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.springframework.beans.factory.annotation.Autowired;

import java.sql.Timestamp;
import java.text.*;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DateUtil {
    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
    public static final String DEFAULT_DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String ALIGN_DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String CHINA_DATETIME_FORMAT = "yyyy年MM月dd日HH时mm分ss秒";
    public static final String DEFAULT_DATETIME_FORMAT1 = "yyyy-MM-dd HH:mm:ss";
    public static final String DEFAULT_DATETIME_FORMAT2 = "yyyy-MM-dd HH:mm";
    /**
     * yyyyMMddHHmmss
     */
    public static final String DB_DATETIME_FORMAT = "yyyyMMddHHmmss";
    /**
     * yyyyMMdd
     */
    public static final String DB_DATE_FORMAT = "yyyyMMdd";

    /**
     * 转化日期格式为yyyy年MM月dd日HH时mm分ss秒
     *
     * @param d
     * @return
     */
    public static String toStringChina(Date d) {
        return toString(d, CHINA_DATETIME_FORMAT);
    }

    /**
     * 转化日期格式为yyyy-MM-dd HH:mm:ss
     *
     * @param d
     * @return
     */
    public static String toStringDefault(Date d) {
        return toString(d, DEFAULT_DATETIME_FORMAT);
    }

    /**
     * 创建人 wang_xiaodong
     * 转化日期格式为yyyy-MM-dd  HH:mm
     *
     * @param d
     * @return
     */
    public static String toStringDefault2(Date d) {
        return toString(d, DEFAULT_DATETIME_FORMAT2);
    }

    /**
     * 创建人 wang_xiaodong
     * 转化日期格式为yyyy-MM-dd  HH:mm:ss
     *
     * @param d
     * @return
     */
    public static String toStringDefault1(Date d) {
        return toString(d, DEFAULT_DATETIME_FORMAT1);
    }

    /**
     * date formart : yyyyMMddHHmmss
     */
    public static String toStringFmis3DateTime(Date d) {
        return toString(d, DB_DATETIME_FORMAT);
    }

    /**
     * date formart : yyyyMMdd
     */
    public static String toStringFmis3Date(Date d) {
        return toString(d, DB_DATE_FORMAT);
    }

    /**
     * date formart : yyyyMMddHHmmss
     */
    public static Date toDateFmis3DateTime(String d) {
        return toDate(d, DB_DATETIME_FORMAT);
    }

    /**
     * date formart : yyyyMMdd
     */
    public static Date toDateFmis3Date(String d) {
        return toDate(d, DB_DATE_FORMAT);
    }

    /**
     * 将短时间格式字符串转换为时间 yyyy-MM-dd
     *
     * @param strDate
     * @return
     */
    public static Date strToDate(String strDate) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        ParsePosition pos = new ParsePosition(0);
        return formatter.parse(strDate, pos);
    }

    /**
     * 日期字符串转换, 页面显示格式转换为FMIS3数据库存储格式
     * 2006-11-14 => 20061114
     */
    public static String trans2fmis3(String src) {
        if (src == null) {
            return null;
        }
        if (src.indexOf('-') < 0) {
            return src;
        }
        Date d = toDate(src, DEFAULT_DATE_FORMAT);
        return toStringFmis3Date(d);
    }

    /**
     * 时间转换Timestamp, 页面显示格式为字符串
     * "2019-10-12 14:33:41.842" => 2019-10-12 10:34:48
     */
    public static String transTimestampToString(Timestamp timestamp) {

        if (null != timestamp) {
            Calendar instance = Calendar.getInstance();
            instance.setTimeInMillis(timestamp.getTime());
            return DateUtil.toString(instance.getTime(), "yyyy-MM-dd HH:mm:ss");
        } else {
            return null;
        }
    }


    /**
     * 判断字符串是否为空
     *
     * @param str str
     * @return boolean true：为空；false：不为空
     */
    public static boolean isNull(String str) {
        if (null != str && !"".equals(str) && !"".equals(str.trim()) && !"null".equals(str.trim())) {
            return false;
        }
        return true;
    }

    /**
     * 将字符串转成日期 "yyyy-MM-dd HH:mm:ss"
     *
     * @param str str
     * @return Date
     */
    public static Date stringToDateTime(String str) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (!isNull(str)) {
            try {
                return sdf.parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return null;
    }


    /**
     * 将字符串转成日期 "yyyy-MM-dd HH:mm"
     *
     * @param str str
     * @return Date
     */
    public static Date stringToDateTime2(String str) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        if (!isNull(str)) {
            try {
                return sdf.parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return null;
    }


    /**
     * 将字符串转成日期 "yyyy-MM-dd HH:mm"
     *
     * @param str str
     * @return Date
     */
    public static Date stringToDate(String str) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        if (!isNull(str)) {
            try {
                return sdf.parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return null;
    }


    /**
     * 日期字符串转换, FMIS3数据库存储格式转换为页面显示格式
     * 20061114 => 2006-11-14
     */
    public static String trans2view(String src) {
        if (src == null || "".equals(src)) {
            return "";
        }
//    return src.substring(0, 4) + src.substring(4, 6) + src.substring(6);
        Date d = toDateFmis3Date(src);
        return toString(d, DEFAULT_DATE_FORMAT);
    }

    private static final double[] LIMITS = {0, 1, 2};

    private static final String[] MINUTES_PART =
            {"", "1 minute ", "{0,number} minutes "};

    private static final String[] SECONDS_PART =
            {"0 seconds", "1 second", "{1,number} seconds"};

    private static final ChoiceFormat MINUTES_FORMAT =
            new ChoiceFormat(LIMITS, MINUTES_PART);

    private static final ChoiceFormat SECONDS_FORMAT =
            new ChoiceFormat(LIMITS, SECONDS_PART);

    private static final MessageFormat MINUTE_SECONDS =
            new MessageFormat("{0}{1}");

    static {
        MINUTE_SECONDS.setFormat(0, MINUTES_FORMAT);
        MINUTE_SECONDS.setFormat(1, SECONDS_FORMAT);
    }


    public static final long ONE_DAY = 24 * 60 * 60 * 1000;

    public static final SimpleDateFormat _defDateTimeFmt =
            new SimpleDateFormat(DEFAULT_DATETIME_FORMAT);

    public static final SimpleDateFormat _defDateFmt =
            new SimpleDateFormat(DEFAULT_DATE_FORMAT);
    public static final SimpleDateFormat _defDBDateTimeFmt =
            new SimpleDateFormat(DB_DATETIME_FORMAT);

    public static final SimpleDateFormat _defDBDateFmt =
            new SimpleDateFormat(DB_DATE_FORMAT);

    public static String toString(Date date, String format) {

        SimpleDateFormat formatter;

        if ((date == null) || (format == null) || (format.length() == 0)) {
            return null;
        }
        formatter = new SimpleDateFormat(format);
        return formatter.format(date);
    }

    public static Date toDate(String str, String format) {
        if ((str == null)
                || (str.length() == 0)
                || (format == null)
                || (format.length() == 0)) {
            return null;
        }

        SimpleDateFormat formatter = new SimpleDateFormat(format);
        formatter.setLenient(false);
        ParsePosition pos = new ParsePosition(0);
        return formatter.parse(str, pos);
    }

    public static boolean compare(Date date1, Date date2) {
        if (date1 == null && date2 == null) {
            return true;
        }
        if (date1 == null || date2 == null)
            return false;
        else
            return date1.getTime() == date2.getTime();
    }

    public static Date toDate(String str) {
        try {
            if (str.indexOf(':') > 0) {
                return toDate(str, DEFAULT_DATETIME_FORMAT);
            } else {
                return toDate(str, DEFAULT_DATE_FORMAT);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }


    public static String currentDateToString(String format) {
        Date date = new Date();
        return toString(date, format);
    }

    public static String curDateStr() {
        return _defDateFmt.format(new Date());
    }

    public static String curDateTimeStr() {
        return _defDateTimeFmt.format(new Date());
    }

    public static String formatElapsedTime(long millis) {
        long seconds = millis / 1000;
        long minutes = seconds / 60;
        //Object[] args = { new Long(minutes), new Long(seconds % 60)};
        Object[] args = {Long.valueOf(minutes), Long.valueOf(seconds % 60)};
        return MINUTE_SECONDS.format(args);
    }

    public static String curDBDateStr() {
        return _defDBDateFmt.format(new Date());
    }

    public static String curDBDateTimeStr() {
        return _defDBDateTimeFmt.format(new Date());
    }


    /**
     * LocalDateTime 转 String
     *
     * @param dateTime
     * @return
     */
    public static String DateTimeToString(LocalDateTime dateTime) {
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime time = LocalDateTime.now();
        String localTime = df.format(dateTime);
        return localTime;
    }

    /**
     * LocalDate 转 String
     *
     * @param date
     * @return
     */
    public static String DateToString(LocalDate date) {
        DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        String dateStr = date.format(fmt);
        return dateStr;
    }


    /***
     * 判断字符串是否是yyyy-MM-dd格式
     * @param mes 字符串
     * @return boolean 是否是日期格式
     */
    public static boolean isRqFormat(String mes) {
        String format = "([0-9]{4})-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])";
        Pattern pattern = Pattern.compile(format);
        Matcher matcher = pattern.matcher(mes);
        if (matcher.matches()) {
            pattern = Pattern.compile("^(\\d{4})-(\\d{2})-(\\d{2})$");
            matcher = pattern.matcher(mes);
            if (matcher.matches()) {
                int y = Integer.valueOf(matcher.group(1));
                int m = Integer.valueOf(matcher.group(2));
                int d = Integer.valueOf(matcher.group(3));
                if (d > 28) {
                    Calendar c = Calendar.getInstance();
                    c.set(y, m - 1, 1);//每个月的最大天数
                    int lastDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
                    return (lastDay >= d);
                }
            }
            return true;
        }
        return false;

    }

    /***
     * 判断字符串是否是yyyy-MM-dd HHmmss格式
     * @param mes 字符串
     * @return boolean 是否是日期格式
     */
    public static boolean isRqSjFormat(String mes) {
        String format = "([0-9]{4})(0[1-9]|1[012])(0[1-9]|[12][0-9]|3[01])"
                + "([01][0-9]|2[0-3])[0-5][0-9][0-5][0-9]";
        Pattern pattern = Pattern.compile(format);
        Matcher matcher = pattern.matcher(mes);
        if (matcher.matches()) {
            pattern = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2}).*");
            matcher = pattern.matcher(mes);
            if (matcher.matches()) {
                int y = Integer.valueOf(matcher.group(1));
                int m = Integer.valueOf(matcher.group(2));
                int d = Integer.valueOf(matcher.group(3));
                if (d > 28) {
                    Calendar c = Calendar.getInstance();
                    c.set(y, m - 1, 1);//每个月的最大天数
                    int lastDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
                    return (lastDay >= d);
                }
            }
            return true;
        }
        return false;

    }

    /**
     * 日期对象LocalDate转string
     *
     * @param date
     * @param pattern
     * @return
     */
    public static String coverDateToString(LocalDate date, String pattern) {
        try {
            if (StringUtils.isEmpty(pattern)) {
                throw new IllegalArgumentException("data pattern is empty");
            } else if (date != null) {
                return date.format(DateTimeFormatter.ofPattern(pattern));
            } else {
                throw new IllegalArgumentException("data is null");
            }
        } catch (Exception var3) {
            return "";
        }
    }

    /**
     * 获取某个日期的开始时间
     *
     * @param d
     * @return
     */
    public static Timestamp getDayStartTime(Date d) {
        Calendar calendar = Calendar.getInstance();
        if (null != d) {
            calendar.setTime(d);
        }
        calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0,
                0, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return new Timestamp(calendar.getTimeInMillis());
    }

    /**
     * 获取某个日期的结束时间
     *
     * @param d
     * @return
     */
    public static Timestamp getDayEndTime(Date d) {
        Calendar calendar = Calendar.getInstance();
        if (null != d) {
            calendar.setTime(d);
        }
        calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 23,
                59, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return new Timestamp(calendar.getTimeInMillis());
    }
    /**
     * 字符串 yyyy-mm-dd HH:mm:ss转yyyy-MM-dd
     *
     * @param date
     * @return
     */
    public static String coverStringDateToString(String date) {
        try {
            if (StringUtils.isEmpty(date)) {
                throw new IllegalArgumentException("data is empty");
            } else {
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                return sdf.format(simpleDateFormat.parse(date));
            }
        } catch (Exception var3) {
            return "";
        }
    }

    /**
     * 判断当前日期是否在[startDate, endDate]区间
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return
     * @author jqlin
     */
    public static boolean isEffectiveDate(Date startDate, Date endDate) {
        if (startDate == null || endDate == null) {
            return false;
        }
        long currentTime = new Date().getTime();
        return currentTime >= startDate.getTime() && currentTime <= endDate.getTime();
    }


    static HolidayService holidayService = SpringContextUtils.getBean(HolidayService.class);

    /**
     * 获取两个日期之间排除非工作日的天数
     * @param startDate yyyy-MM-dd
     * @param endDate yyyy-MM-dd
     * @return
     */
    public static Integer getDateLegalholidayNumber(Date startDate,Date endDate){
        QueryWrapper<HolidayPo> queryWrapper = new QueryWrapper<>();
        queryWrapper.ge("YMD_DATE", DateFormatUtils.format(startDate,"yyyy-MM-dd"));
        queryWrapper.le("YMD_DATE",DateFormatUtils.format(endDate,"yyyy-MM-dd"));
        queryWrapper.eq("IS_LEGALHOLIDAY","0");
        return holidayService.count(queryWrapper);
    }
}