时间相关的工具类

1.时间的格式校验,时间的转换,时间的计算

package com.tongsheng.common.utils;

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import java.sql.Time;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * <p>日期处理
 *
 * @author HuYong
 * @since 2019-06-17
 */
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {

    /**
     * 时间格式(yyyy-MM-dd)
     */
    public final static String DATE_PATTERN = "yyyy-MM-dd";
    /**
     * 时间格式(yyyy-MM)
     */
    public final static String MONTH_DATE_PATTERN = "yyyy-MM";
    /**
     * 时间格式(yyyy-MM-dd HH:mm:ss)
     */
    public final static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
    /**
     * 时间格式(yyyyMMdd)
     */
    public final static String DATE_SHORT_PATTERN = "yyyyMMdd";

    /**
     * 时间格式(yyyyMM)
     */
    public final static String DATE_YYYYMM_PATTERN = "yyyyMM";

    /**
     * 时间格式(yyyy)
     */
    public final static String DATE_YYYY_PATTERN = "yyyy";
    /**
     * 时间格式(yyyyMMddHHmmss)
     */
    public final static String DATE_LONG_PATTERN = "yyyyMMddHHmmss";
    /**
     * 时间格式(yyyyMMddHHmmssSSS)
     */
    public final static String DATE_BIG_LONG_PATTERN = "yyyyMMddHHmmssSSS";


    /**
     * 时间格式(yyyyMMddHHmmssSSS)
     */
    public final static String DATE_SHORT_PATTERNHMS = "HH:mm:ss";


    /**
     * 日期格式化
     *
     * @param String pattern
     * @return Date
     */
    public static Date getDateByPattern(String pattern, String str) {
        try {
            Date date = new SimpleDateFormat(pattern).parse(str);
            return date;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 日期格式化
     *
     * @param String pattern
     * @return Date
     */
    public static String getDateByPattern(Date time, String pattern) {
        try {
            return new SimpleDateFormat(pattern).format(time);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 日期格式化 日期格式为：yyyy-MM-dd
     *
     * @param date 日期
     * @return 返回yyyy-MM-dd格式日期
     */
    public static String formatDate(Date date) {
        return dateToString(date, DATE_PATTERN);
    }

    /**
     * 日期格式化 日期格式为：yyyy-MM
     *
     * @param date 日期
     * @return 返回yyyy-MM格式日期
     */
    public static String monthFormatDate(Date date) {
        return dateToString(date, MONTH_DATE_PATTERN);
    }

    public static String formatDateHMS(Date date) {
        return dateToString(date, DATE_SHORT_PATTERNHMS);
    }

    public static String formatDateYMD(Date date) {
        return dateToString(date, DATE_SHORT_PATTERN);
    }

    /**
     * 获取年月
     *
     * @param date
     * @return
     */
    public static String formatDateYear(Date date) {
        return dateToString(date, DATE_YYYY_PATTERN);
    }

    /**
     * 获取年月
     *
     * @param date
     * @return
     */
    public static String formatDateHM(Date date) {
        return dateToString(date, DATE_YYYYMM_PATTERN);
    }

    /**
     * 日期格式化 日期格式为：yyyy-MM-dd HH:mm:ss
     *
     * @param date 日期
     * @return 返回yyyy-MM-dd HH:mm:ss格式日期
     */
    public static String formatDateTime(Date date) {
        return dateToString(date, DATE_TIME_PATTERN);
    }

    /**
     * 日期格式化 日期格式为：yyyy-MM-dd HH:mm:ss
     *
     * @param date 日期
     * @return 返回yyyy-MM-dd HH:mm:ss格式日期
     */
    public static String formatDateTimeUp(Date date) {
        String d = null;
        try {
            d = dateToString(date, DATE_TIME_PATTERN);
        } catch (Exception ignored) {
        }
        return d;
    }

    /**
     * 字符串转换成日期 日期格式为：yyyy-MM-dd
     *
     * @param date 日期
     * @return 返回yyyy-MM-dd格式日期
     */
    public static Date formatDate(String date) {
        return stringToDate(date, DATE_PATTERN);
    }

    /**
     * 字符串转换成日期 日期格式为：yyyy-MM-dd HH:mm:ss
     *
     * @param date 日期
     * @return 返回yyyy-MM-dd HH:mm:ss格式日期
     */
    public static Date formatDateTime(String date) {
        return stringToDate(date, DATE_TIME_PATTERN);
    }

    /**
     * 日期格式化 日期格式为：yyyy-MM-dd
     *
     * @param date    日期
     * @param pattern 格式，如：DateUtils.DATE_TIME_PATTERN
     * @return 返回yyyy-MM-dd格式日期
     */
    public static String dateToString(Date date, String pattern) {
        if (date != null) {
            SimpleDateFormat df = new SimpleDateFormat(pattern);
            return df.format(date);
        }
        return null;
    }

    /**
     * 日期格式化 日期格式为：yyyy-MM-dd
     *
     * @param date    日期
     * @param pattern 格式，如：DateUtils.DATE_TIME_PATTERN
     * @return 返回yyyy-MM-dd格式日期
     */
    public static String stringToString(String date, String pattern) {
        if (StringUtils.isBlank(date)) {
            return null;
        }
        return dateToString(stringToDate(date, pattern), pattern);
    }

    /**
     * 字符串转换成日期
     *
     * @param strDate 日期字符串
     * @param pattern 日期的格式，如：DateUtils.DATE_TIME_PATTERN
     */
    public static Date stringToDate(String date, String pattern) {
        if (StringUtils.isBlank(date)) {
            return null;
        }
        DateTimeFormatter fmt = DateTimeFormat.forPattern(pattern);
        return fmt.parseLocalDateTime(date).toDate();
    }

    /**
     * 日期转换成日期
     *
     * @param strDate 日期字符串
     * @param pattern 日期的格式，如：DateUtils.DATE_TIME_PATTERN
     */
    public static Date dateToDate(Date date, String pattern) {
        if (date != null) {
            return stringToDate(dateToString(date, pattern), pattern);
        }
        return null;
    }

    /**
     * 将日期的时分秒变为毫秒值
     *
     * @param Date
     * @return long
     */
    public static Time dateToTime(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//小时
        int minute = calendar.get(Calendar.MINUTE);//分
        int second = calendar.get(Calendar.SECOND);//秒
        Time time = Time.valueOf(hour + ":" + minute + ":" + second);
        return time;
    }

    /**
     * 身份证计算出生年月yyyy-MM-dd
     *
     * @param idcard
     * @return Date
     */
    public static Date getBirthday(String idcard) {
        String birthday = "";
        if (idcard.length() == 15) {
            birthday = "19" + idcard.substring(6, 8) + "-" + idcard.substring(8, 10) + "-" + idcard.substring(10, 12);
        } else if (idcard.length() == 18) {
            birthday = idcard.substring(6, 10) + "-" + idcard.substring(10, 12) + "-" + idcard.substring(12, 14);
        }
        Date birthdayDate = stringToDate(birthday, DATE_PATTERN);
        return birthdayDate;
    }

    /**
     * 根据年月日计算年龄
     *
     * @param Date
     */
    public static int getAgeByBirth(Date date) {
        int age = 0;
        Calendar cal = Calendar.getInstance();
        if (cal.before(date)) { //出生日期晚于当前时间，无法计算
        } else {
            int yearNow = cal.get(Calendar.YEAR);  //当前年份
            int monthNow = cal.get(Calendar.MONTH);  //当前月份
            int dayOfMonthNow = cal.get(Calendar.DAY_OF_MONTH); //当前日期
            cal.setTime(date);
            int yearBirth = cal.get(Calendar.YEAR);
            int monthBirth = cal.get(Calendar.MONTH);
            int dayOfMonthBirth = cal.get(Calendar.DAY_OF_MONTH);
            age = yearNow - yearBirth;   //计算整岁数
            if (monthNow <= monthBirth) {
                if (monthNow == monthBirth) {
                    if (dayOfMonthNow < dayOfMonthBirth) {
                        age--;//当前日期在生日之前，年龄减一
                    }
                } else {
                    age--;//当前月份在生日之前，年龄减一
                }
            }
        }
        return age;
    }

    /**
     * 获取当天的开始时间
     *
     * @return Date
     */
    public static Date getDayBegin(Date date) {
        Calendar calendarFrom = Calendar.getInstance();
        calendarFrom.setTime(date); // 获得实体对象里面一个Date类型的属性，set进Calender对象中。
        calendarFrom.set(Calendar.HOUR_OF_DAY, 0);// 设置时为0点
        calendarFrom.set(Calendar.MINUTE, 0);// 设置分钟为0分
        calendarFrom.set(Calendar.SECOND, 0);// 设置秒为0秒
        calendarFrom.set(Calendar.MILLISECOND, 000);// 设置毫秒为000
        return calendarFrom.getTime();
    }

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

    /**
     * 计算两个日期之间相差的天数
     *
     * @param sdate 开始时间
     * @param edate 结束时间
     * @return 相差天数
     */
    public static int daysBetween(Date sdate, Date edate) {
        sdate = dateToDate(sdate, DATE_PATTERN);
        edate = dateToDate(edate, DATE_PATTERN);
        Calendar cal = Calendar.getInstance();
        cal.setTime(sdate);
        long time1 = cal.getTimeInMillis();
        cal.setTime(edate);
        long time2 = cal.getTimeInMillis();
        if (time2 > time1) {
            long between_days = (time2 - time1) / (1000 * 3600 * 24);
            return Integer.parseInt(String.valueOf(between_days));
        } else {
            return 0;
        }

    }

    /**
     * 计算两个日期之间相差的天数
     *
     * @param sdate 开始时间
     * @param edate 结束时间
     * @return 相差天数
     */
    public static int daysBetween(String sdate, String edate) {
        Date startDate = DateUtils.formatDate(sdate);
        Date endDate = DateUtils.formatDate(edate);
        startDate = dateToDate(startDate, DATE_PATTERN);
        endDate = dateToDate(endDate, DATE_PATTERN);
        Calendar cal = Calendar.getInstance();
        cal.setTime(startDate);
        long time1 = cal.getTimeInMillis();
        cal.setTime(endDate);
        long time2 = cal.getTimeInMillis();
        if (time2 > time1) {
            long between_days = (time2 - time1) / (1000 * 3600 * 24);
            return Integer.parseInt(String.valueOf(between_days));
        } else {
            return 0;
        }
    }

    /**
     * 计算两个日期之间相差的分钟数
     *
     * @param sdate 开始时间
     * @param edate 结束时间
     * @return 相差天数
     */
    public static int minuteBetween(String sdate, String edate) {
        Date startDate = DateUtils.formatDateTime(sdate);
        Date endDate = DateUtils.formatDateTime(edate);
        startDate = dateToDate(startDate, DATE_TIME_PATTERN);
        endDate = dateToDate(endDate, DATE_TIME_PATTERN);
        Calendar cal = Calendar.getInstance();
        cal.setTime(startDate);
        long time1 = cal.getTimeInMillis();
        cal.setTime(endDate);
        long time2 = cal.getTimeInMillis();
        if (time2 > time1) {
            long between_days = (time2 - time1) / (1000 * 60);
            return Integer.parseInt(String.valueOf(between_days));
        } else {
            return 0;
        }
    }

    /**
     * 获取某天前的日期
     *
     * @param int 4天前-4，4天后+4
     * @return String
     */
    public static String getDaysAgo(int day) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.add(Calendar.DATE, day);
        return formatDate(calendar.getTime());
    }

    /**
     * 获取某月的第一天
     *
     * @param Date
     * @return Date
     */
    public static Date getMonthsOneDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        return calendar.getTime();
    }

    /**
     * 获取某月的最后一天
     *
     * @param Date
     * @return Date
     */
    public static Date getMonthsEndDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, 1);
        calendar.add(Calendar.DAY_OF_MONTH, -1);
        return calendar.getTime();
    }

    /**
     * 获取某月的所有天数
     *
     * @param Date
     * @return Date
     */
    public static List<java.sql.Date> getAllDaysByMonth(Date date) {
        Date beginDate = getMonthsOneDay(date);
        Date endDate = getMonthsEndDay(date);
        List<java.sql.Date> dateList = new ArrayList<java.sql.Date>();
        dateList.add(new java.sql.Date(beginDate.getTime()));// 把开始时间加入集合
        if (beginDate.getTime() != endDate.getTime()) {
            Calendar cal = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            cal.setTime(beginDate);
            boolean bContinue = true;
            while (bContinue) {
                // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
                cal.add(Calendar.DAY_OF_MONTH, 1);
                // 测试此日期是否在指定日期之后
                if (endDate.after(cal.getTime())) {
                    dateList.add(new java.sql.Date(cal.getTime().getTime()));
                } else {
                    break;
                }
            }
            dateList.add(new java.sql.Date(endDate.getTime()));//把结束时间加入集合
        }
        return dateList;
    }

    /**
     * 获取某月的所有天数
     *
     * @param Date
     * @return Date
     */
    public static List<Date> getAllDaysFromStartToEnd(Date beginDate, Date endDate) {
        List<Date> dateList = new ArrayList<Date>();
        dateList.add(beginDate);// 把开始时间加入集合
        if (beginDate.getTime() != endDate.getTime()) {
            Calendar cal = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            cal.setTime(beginDate);
            boolean bContinue = true;
            while (bContinue) {
                // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
                cal.add(Calendar.DAY_OF_MONTH, 1);
                // 测试此日期是否在指定日期之后
                if (endDate.after(cal.getTime())) {
                    dateList.add(cal.getTime());
                } else {
                    break;
                }
            }
            dateList.add(endDate);//把结束时间加入集合
        }
        return dateList;
    }

    /**
     * 转换日期格式
     *
     * @param String yyyyMMdd
     * @return String yyyy-MM-dd
     */
    public static String formatDateString(String date) {
        if (StringUtils.isNotBlank(date)) {
            int cc = date.length();
            if (cc > 2) {
                return date.substring(0, 4) + "-" + date.substring(4, 6) + "-" + date.substring(6, 8);
            } else {
                return "长期";
            }
        } else {
            return "";
        }
    }

    /**
     * 获取某月多少天
     *
     * @param String yyyyMMdd
     * @return String yyyy-MM-dd
     */
    public static int getDaysByYearMonth(String year, String month) {
        Calendar a = Calendar.getInstance();
        a.setTime(formatDate(year + "-" + month + "-01"));
        a.set(Calendar.MONTH, Integer.parseInt(month) - 1);
        a.set(Calendar.DATE, 1);
        a.roll(Calendar.DATE, -1);
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }

    /**
     * 大象云日期格式转换
     *
     * @param String
     */
    public static Date getDaysByYearMonth(String str) {
        try {
            SimpleDateFormat sf1 = new SimpleDateFormat("EEE, dd MMM yyyy hh:mm:ss z", Locale.ENGLISH);
            Date date = sf1.parse(str);
            return date;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 给定两个日期，获取日期之间的时间集合
     *
     * @param startTime
     * @param endTime   结束时 开始时间间
     */
    public static List<String> getDateList(String startTime, String endTime) {
        List<String> days = new ArrayList<String>();
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date start = dateFormat.parse(startTime);
            Date end = dateFormat.parse(endTime);
            Calendar tempStart = Calendar.getInstance();
            tempStart.setTime(start);
            Calendar tempEnd = Calendar.getInstance();
            tempEnd.setTime(end);
            tempEnd.add(Calendar.DATE, +1);// 日期加1(包含结束)
            while (tempStart.before(tempEnd)) {
                days.add(dateFormat.format(tempStart.getTime()));
                tempStart.add(Calendar.DAY_OF_YEAR, 1);
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return days;
    }

    /**
     * 获取两个日期间年月集合
     *
     * @param minDate 最小时间  2015-01
     * @param maxDate 最大时间 2015-10
     * @return 日期集合 格式为 年-月
     * @throws Exception
     */
    public static List<String> getMonthBetween(String minDate, String maxDate) {
        ArrayList<String> result = new ArrayList<String>();
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");//格式化为年月

            Calendar min = Calendar.getInstance();
            Calendar max = Calendar.getInstance();

            min.setTime(sdf.parse(minDate));
            min.set(min.get(Calendar.YEAR), min.get(Calendar.MONTH), 1);

            max.setTime(sdf.parse(maxDate));
            max.set(max.get(Calendar.YEAR), max.get(Calendar.MONTH), 2);

            while (min.before(max)) {
                result.add(sdf.format(min.getTime()));
                min.add(Calendar.MONTH, 1);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 指定日期加上任意天数，获取最终天数
     *
     * @param date 指定日期
     * @param day  天数
     * @return
     */
    public static Date getDate(Date date, int day) {
        Date newDate = addDate(date, day); // 指定日期加上天
        return newDate;
    }

    public static Date addDate(Date date, long day) {
        long time = date.getTime(); // 得到指定日期的毫秒数
        day = day * 24 * 60 * 60 * 1000; // 要加上的天数转换成毫秒数
        time += day; // 相加得到新的毫秒数
        return new Date(time); // 将毫秒数转换成日期
    }

    /**
     * 判断当前时间 是否在两个时间的范围内
     */
    public static Boolean TimeCheckExample(Integer startDate, Integer endData) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeZone(TimeZone.getDefault());
        int currentHour = calendar.get(Calendar.HOUR_OF_DAY);  // 获取当前小时数
        if (currentHour >= startDate && currentHour < endData) {
            return true;
        } else {
            return false;
        }
    }


    /**
     * 随机时间数
     *
     * @param beginDate
     * @param endDate
     * @return
     */
    public static Date randomDate(Date beginDate, Date endDate) {
        if (beginDate.getTime() >= endDate.getTime()) {
            return new Date();
        }
        long date = random(beginDate.getTime(), endDate.getTime());
        return new Date(date);
    }

    public static long random(long begin, long end) {
        long rtn = begin + (long) (Math.random() * (end - begin));
        if (rtn == begin || rtn == end) {
            return random(begin, end);
        }
        return rtn;
    }


    /**
     * 判断时间是否在时间段内
     *
     * @param nowTime
     * @param beginTime
     * @param endTime
     * @return
     */
    public static boolean belongCalendar(String nowTime, String beginTime,
                                         String endTime) {
        Calendar date = Calendar.getInstance();
        date.setTime(formatDate(nowTime));

        Calendar begin = Calendar.getInstance();
        begin.setTime(formatDate(beginTime));

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

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

    /**
     * 判断一个日期是不是今天
     *
     * @param date
     * @return
     */
    public static boolean isNow(String date) {
        SimpleDateFormat sf = new SimpleDateFormat("yyyyMMdd");
        Date now = new Date();

        if (sf.format(formatDate(date)).equals(sf.format(now))) {
            return true;
        } else {
            return false;
        }
    }


    /**
     * 判断一个日期与当前时间的对比
     *
     * @param date
     * @return
     */
    public static boolean isEffective(String date) {
        if (StringUtils.isBlank(date)) {
            return false;
        }
        date = date.trim();
        if (date.contains("长期")) {
            return true;
        }
        Date now = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyyMMdd");

//        date = date.replace(".","");

        long longDate = Long.valueOf(date.replace(".", "").replace("-", ""));
        long longNow = Long.valueOf(sf.format(now));

        if (longDate >= longNow) {
            return false;
        }
        return true;
    }

    /**
     * 获取日期
     *
     * @return Date
     */
    public static Date getDate(String dateStr) {
        Date date = null;
        try {
            date = DateUtils.formatDateTime(dateStr);
        } catch (Exception e) {
            try {
                date = DateUtils.formatDate(dateStr);
            } catch (Exception ignored) {
            }
        }
        return date;
    }

    /**
     * 获取带点的日期（1999.01.01）
     *
     * @return Date
     */
    public static Date getPointDate(String dateStr) {
        Date date = null;
        if (StringUtils.isBlank(dateStr)) {
            return date;
        }
        try {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd");
            date = simpleDateFormat.parse(dateStr);
        } catch (Exception e) {
            e.printStackTrace();
            return date;
        }
        return date;
    }

    /**
     * 判断一个日期与当前时间的对比
     *
     * @param date
     * @return
     */
    public static String forDate(String date, String pattern) {
        String day = null;
        Date d = getDate(date);
        if (d != null) {
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
            day = simpleDateFormat.format(d);
        }
        return day;
    }

    /**
     * 比较两个日期
     *
     * @param date1
     * @param date2
     * @return -1 date1 < date2 | 0 date1 = date2  |  1 date1 ></> date2
     */
    public static int compareDate(Date date1, Date date2) {
        try {
            return Long.compare(date1.getTime(), date2.getTime() - 600000);
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return 0;
    }

    /**
     * 比较两个日期
     *
     * @param date1
     * @param date2
     * @return -1 date1 < date2 | 0 date1 = date2  |  1 date1 ></> date2
     */
    public static int compareDateCommon(Date date1, Date date2) {
        try {
            return Long.compare(date1.getTime(), date2.getTime());
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return 0;
    }

    /**
     * 获取某个月份天数
     *
     * @param match   yyyyMM
     * @param dateStr
     * @return
     */
    public static int getDaysOfMonth(String match, String dateStr) {
        Date date = getDateByPattern(match, dateStr);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
    }

    /**
     * 毫秒转为当前日期
     *
     * @param time 毫秒
     */
    public static String millisecondToDate(Long time) {
        Date d = new Date(time);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(d);
    }

    /**
     * 当前时间转时间戳
     *
     * @param
     */
    public static String getDateTimeStr() {
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_LONG_PATTERN);
        return sdf.format(d);
    }

    /**
     * 时间戳转当前时间
     *
     * @param
     */
    public static String timeStrToString(long time) {
        String rs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time);
        return rs;
    }

    /**
     * 通过时间字符串获取时间
     *
     * @param dateStr
     * @return
     */
    public static Date getDateByDateStr(String dateStr) {
        Date date = null;
        try {
            String reg = "";
            if (dateStr.indexOf(".") > 0) {
                reg = "yyyy.MM.dd";
            } else if (dateStr.indexOf("-") > 0) {
                reg = "yyyy-MM-dd";
            } else if (dateStr.indexOf(":") > 0) {
                reg = "yyyy:MM:dd";
            }
            SimpleDateFormat sdf = new SimpleDateFormat(reg);
            date = sdf.parse(dateStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 通过时间字符串获取时间
     *
     * @param dateStr
     * @return
     */
    public static Date getDateByConditions(String dateStr) {
        if (dateStr == null) {
            return null;
        }
        Date date = null;
        try {
            String reg = "";
            if (dateStr.indexOf(".") > 0) {
                reg = "yyyy.MM.dd";
            } else if (dateStr.indexOf("-") > 0) {
                reg = "yyyy-MM-dd";
            } else if (dateStr.indexOf(":") > 0) {
                reg = "yyyy:MM:dd";
            } else {
                reg = "yyyyMMdd";
            }
            SimpleDateFormat sdf = new SimpleDateFormat(reg);
            date = sdf.parse(dateStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * @param date 是为则默认今天日期、可自行设置“2013-06-03”格式的日期
     * @return 返回1是星期日、2是星期一、3是星期二、4是星期三、5是星期四、6是星期五、7是星期六
     */
    public static int getDayOfWeek(String date) {
        Calendar cal = Calendar.getInstance();
        if (date.equals("")) {
            cal.setTime(new Date(System.currentTimeMillis()));
        } else {
            cal.setTime(new Date(formatDate(date).getTime()));
        }
        return cal.get(Calendar.DAY_OF_WEEK);
    }

    //返回某天是星期几
    public static String getDayOfWeekChinese(String date) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "星期日");
        map.put(2, "星期一");
        map.put(3, "星期二");
        map.put(4, "星期三");
        map.put(5, "星期四");
        map.put(6, "星期五");
        map.put(7, "星期六");
        return map.get(getDayOfWeek(date));
    }


    public static boolean isValidDate(String str) {
        boolean convertSuccess = true;
        // 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        try {
            // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
            format.setLenient(false);
            format.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
            // 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
            convertSuccess = false;
        }
        return convertSuccess;
    }

    /**
     * 将 yyyyMMddHHmmss 转成 yyyy-MM-dd HH:mm:ss
     *
     * @param date
     * @return
     */
    public static String stringToString(String date) {
        DateFormat df1 = new SimpleDateFormat("yyyyMMddHHmmss");
        DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date time1 = df1.parse(date);
            return df2.format(time1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * UTC转成北京时间
     *
     * @param UTCStr
     * @return
     */
    public static Date UTCToCST(String UTCStr) {
        try {
            Date date = new Date();
            date.setTime(Long.parseLong(UTCStr));
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.set(Calendar.HOUR, calendar.get(Calendar.HOUR));
            return calendar.getTime();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取某月的第一天和最后一天
     *
     * @return
     */
    public static Map<String, String> getMonthOneAndLastDay(String month) {
        if (StringUtils.isBlank(month)) {
            return null;
        }
        Map<String, String> day = new HashMap<>();
        // 获取当月第一天和最后一天
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String firstday, lastday;
        // 获取前月的第一天
        Calendar cale = null;
        cale = Calendar.getInstance();
        cale.setTime(Objects.requireNonNull(stringToDate(month, "yyyy-MM")));
        cale.add(Calendar.MONTH, 0);
        cale.set(Calendar.DAY_OF_MONTH, 1);
        firstday = format.format(cale.getTime());
        // 获取前月的最后一天
        cale.add(Calendar.MONTH, 1);
        cale.set(Calendar.DAY_OF_MONTH, 0);
        lastday = format.format(cale.getTime());
        day.put("first", firstday);
        day.put("last", lastday);
        return day;
    }

    /**
     * 获取某月的第一天和最后一天
     *
     * @return
     */
    public static Map<String, String> getMonthOneAndLastDay(Date date) {
        Map<String, String> day = new HashMap<>();
        // 获取当月第一天和最后一天
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String firstday, lastday;
        // 获取前月的第一天
        Calendar cale = null;
        cale = Calendar.getInstance();
        cale.setTime(date);
        cale.add(Calendar.MONTH, 0);
        cale.set(Calendar.DAY_OF_MONTH, 1);
        firstday = format.format(cale.getTime());
        // 获取前月的最后一天
        cale.add(Calendar.MONTH, 1);
        cale.set(Calendar.DAY_OF_MONTH, 0);
        lastday = format.format(cale.getTime());
        day.put("first", firstday);
        day.put("last", lastday);
        return day;
    }

    /**
     * 取当前日期(天)的当前周的第一天和最后一天日期
     *
     * @param month
     * @return
     */
    public static Map<String, String> getWeekDay(Date date) {
        Map<String, String> dayMap = new HashMap<>();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - dayOfWeek + 1);
        dayMap.put("first", dateToString(calendar.getTime(), "yyyy-MM-dd"));
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 6);
        dayMap.put("last", dateToString(calendar.getTime(), "yyyy-MM-dd"));
        return dayMap;
    }

    /**
     * 取当前日期(天)的当前周的第一天和最后一天日期
     *
     * @param month
     * @return
     */
    public static Map<String, String> getWeekDay(String day) {
        Map<String, String> dayMap = new HashMap<>();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(stringToDate(day, "yyyy-MM-dd"));
        int dayOfWeek = calendar.get(calendar.DAY_OF_WEEK);
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - dayOfWeek + 1);
        dayMap.put("first", dateToString(calendar.getTime(), "yyyy-MM-dd"));
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 6);
        dayMap.put("last", dateToString(calendar.getTime(), "yyyy-MM-dd"));
        return dayMap;
    }

    /**
     * 获取某月的最后一天
     *
     * @throws
     * @Title:getLastDayOfMonth
     * @Description:
     * @param:@param year
     * @param:@param month
     * @param:@return
     * @return:String
     */
    public static String getLastDayOfMonth(String time) {
        int year = Integer.parseInt(time.substring(0, time.indexOf("-")));
        int month = Integer.parseInt(time.substring(time.indexOf("-") + 1));
        Calendar cal = Calendar.getInstance();
        //设置年份
        cal.set(Calendar.YEAR, year);
        //设置月份
        cal.set(Calendar.MONTH, month - 1);
        //获取某月最大天数
        int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        //设置日历中月份的最大天数
        cal.set(Calendar.DAY_OF_MONTH, lastDay);
        //格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(cal.getTime());
    }

    /**
     * 获取一个区间内的所有天数，返回 字符串数组
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return Date
     */
    public static List<String> dateList(String startTime, String endTime) {
        Date beginDate = formatDate(startTime);
        Date endDate = formatDate(endTime);
        List<String> dateList = new ArrayList<String>();
        dateList.add(startTime);// 把开始时间加入集合
        if (beginDate.getTime() != endDate.getTime()) {
            Calendar cal = Calendar.getInstance();
            // 使用给定的 Date 设置此 Calendar 的时间
            cal.setTime(beginDate);
            while (true) {
                // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
                cal.add(Calendar.DAY_OF_MONTH, 1);
                // 测试此日期是否在指定日期之后
                if (endDate.after(cal.getTime())) {
                    dateList.add(formatDate(cal.getTime()));
                } else {
                    break;
                }
            }
            dateList.add(endTime);//把结束时间加入集合
        }
        return dateList;
    }

    /**
     * 获取昨天的日期
     *
     * @return
     */
    public static Date getYesterday() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE, -1);
        return cal.getTime();
    }


    /**
     * 通过时间字符串获取时间
     *
     * @param dateStr
     * @return
     */
    public static Date getTimeByConditions(String dateStr) {
        if (dateStr == null) {
            return null;
        }
        Date date = null;
        try {
            String reg = "";
            if (dateStr.indexOf(".") > 0) {
                if (getStrCount(dateStr, ":") == 2) {
                    reg = "yyyy.MM.dd HH:mm:ss";
                } else if (getStrCount(dateStr, ":") == 1) {
                    reg = "yyyy.MM.dd HH:mm";
                } else {
                    reg = "yyyy.MM.dd";
                }
            } else if (dateStr.indexOf("-") > 0) {
                if (getStrCount(dateStr, ":") == 2) {
                    reg = "yyyy-MM-dd HH:mm:ss";
                } else if (getStrCount(dateStr, ":") == 1) {
                    reg = "yyyy-MM-dd HH:mm";
                } else {
                    reg = "yyyy-MM-dd";
                }
            } else {
                if (getStrCount(dateStr, ":") == 2) {
                    reg = "yyyyMMdd HH:mm:ss";
                } else if (getStrCount(dateStr, ":") == 1) {
                    reg = "yyyyMMdd HH:mm";
                } else {
                    reg = "yyyyMMdd";
                }
            }
            SimpleDateFormat sdf = new SimpleDateFormat(reg);
            date = sdf.parse(dateStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 获取字符串出现次数
     *
     * @param str
     * @param searchStr
     * @return
     */
    public static int getStrCount(String str, String searchStr) {
        int index = 0;//define the index
        int count = 0;//define the count
        while ((index = str.indexOf(searchStr, index)) != -1) {
            if (searchStr.equals(str.substring(index, index + searchStr.length()))) {
                System.out.println("index is :" + index);//print index
                index = index + searchStr.length();
                count++;
            }
        }
        return count;
    }

    /**
     * 通过时间字符串获取时间
     *
     * @param dateStr
     * @return
     */
    public static Date getDateByCondition(String dateStr) {
        if (StringUtils.isBlank(dateStr)) {
            return null;
        }
        Date date = null;
        try {
            String reg = "";
            if (dateStr.indexOf(".") > 0) {
                reg = "yyyy.MM.dd";
            } else if (dateStr.indexOf("-") > 0) {
                reg = "yyyy-MM-dd";
            } else if (dateStr.indexOf(":") > 0) {
                reg = "yyyy:MM:dd";
            } else if (dateStr.indexOf("/") > 0) {
                reg = "yyyy/MM/dd";
            }
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(reg);
            date = simpleDateFormat.parse(dateStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 将传进来的时间转为当前日+传进来的时间的时分秒
     *
     * @param date
     * @return
     */
    public static String dateToNowDate(Date date) {
        String dateTime = formatDateTime(date);
        String nowTime = formatDateTime(new Date());
        return nowTime.split(" ")[0] + dateTime.split(" ")[1];
    }

    /**
     * 获取本周第一天的日期  yyyy-MM-dd
     *
     * @return String
     */
    public static String getWeekStartDate() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        Date date = cal.getTime();
        SimpleDateFormat dformat = new SimpleDateFormat("yyyy-MM-dd");
        String format = dformat.format(date);
        return format;
    }

    /**
     * 获取当前时间的日期
     *
     * @return
     */
    public static String getDate() {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date1 = new Date();
        String currentTime = dateFormat.format(date1);
        return currentTime;
    }

    public static String getHour() {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:00:00");
        Date date1 = new Date();
        String currentTime = dateFormat.format(date1);
        return currentTime;
    }

    public static String getNextHour() {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:00:00");
        Calendar calendar = new GregorianCalendar();
        calendar.set(Calendar.HOUR_OF_DAY, calendar.get(Calendar.HOUR_OF_DAY) + 1);
        String currentTime = dateFormat.format(calendar.getTime());
        return currentTime;
    }

    /**
     * 获取明天日期
     */
    public static String getTomorrow() {
        SimpleDateFormat smdate = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(new Date());
        calendar.add(calendar.DATE, 1);
        String date = smdate.format(calendar.getTime());
        return date;
    }
 /*   public static void main(String[] args) {
        System.out.println(getWeekDay("2020-08-12"));
    }*/

    /**
     * 查询几个小时前的时间
     *
     * @param date
     * @return
     */
    public static Date dateBeforDate(Date date, int i) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, calendar.get(Calendar.HOUR_OF_DAY) - i);
        return calendar.getTime();
    }


    /**
     * 时间转换成时间戳,参数和返回值都是字符串
     *
     * @param s
     * @return res
     * @throws ParseException
     */
    public static String dateToStamp(String s) throws ParseException {
        String res;
        //设置时间模版
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = simpleDateFormat.parse(s);
        long ts = date.getTime();
        res = String.valueOf(ts);
        return res;
    }

    /**
     * 取两个时间相差的天数不足向下取整
     *
     * @param start 开始时间
     * @param end   结束时间
     * @return 相差天数 为-1表示开始时间大于结束时间 -2开始时间或结束时间为空
     */
    public static int getTwoDaysBetweenDays(String start, String end) {
        if (StringUtils.isBlank(start) || StringUtils.isBlank(end)) {
            return -2;
        }
        Date startDate = formatDateTime(start);
        Date endDate = formatDateTime(end);
        if (null == startDate || null == endDate) {
            return -2;
        }
        if (startDate.getTime() > endDate.getTime()) {
            return -1;
        }
        long startTime = startDate.getTime();
        long endTime = endDate.getTime();
        long betweenDays = (endTime - startTime) / (1000 * 3600 * 24);
        return (int) betweenDays;
    }

    /**
     * 取两个时间相差的天数不足向下取整
     *
     * @param start 开始时间
     * @param end   结束时间
     * @return 相差天数 为-1表示开始时间大于结束时间 -2开始时间或结束时间为空
     */
    public static int getTwoDaysBetweenS(String start, String end) {
        if (StringUtils.isBlank(start) || StringUtils.isBlank(end)) {
            return -2;
        }
        Date startDate = formatDateTime(start);
        Date endDate = formatDateTime(end);
        if (null == startDate || null == endDate) {
            return -2;
        }
        if (startDate.getTime() > endDate.getTime()) {
            return -1;
        }
        long startTime = startDate.getTime();
        long endTime = endDate.getTime();
        long betweenDays = (endTime - startTime) / (1000);
        return (int) betweenDays;
    }

    /**
     * 指定返回当天的前几天
     *
     * @param date
     * @param day
     * @return
     */
    public static Date returnPre(Date date, int day) {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.add(Calendar.DATE, day * -1);
        return calendar.getTime();
    }

    /**
     * 指定返回当天的前几天
     *
     * @param time
     * @param day
     * @return
     */
    public static Date returnPre(String time, int day) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = new GregorianCalendar();
        try {
            calendar.setTime(simpleDateFormat.parse(time));
            calendar.add(Calendar.DATE, day * -1);
            return calendar.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 获取两个时间相差的小时
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static double getHourDiff(Date startDate, Date endDate) {
        long diff = endDate.getTime() - startDate.getTime();
        if (diff < 0) {
            return 0;
        }
        return (Math.round(diff * 1.0 / 1000 / 60 / 60 * 100)) * 1.0 / 100;
    }

    public static void main(String[] args) {
        System.out.println(getHourDiff(DateUtils.formatDateTime("2022-09-27 09:36:36"), new Date()));
        System.out.println(getDaysAgo(-90));

        System.out.println(getMonthOneAndLastDay(new Date()));
        System.out.println(DateUtils.formatDate(DateUtils.returnPre(new Date(), 7)));
        System.out.println(DateUtils.formatDateTime("2023-07-25 15:33:45.6876108+08:00".substring(0, 19).replace("T", " ")));
    }

    /**
     * 得到UTC时间，类型为字符串，格式为"yyyy-MM-dd HH:mm"
     * <p>
     * 如果获取失败，返回null
     *
     * @return
     */
    public static String getUTCTimeStr() {
        StringBuffer UTCTimeBuffer = new StringBuffer();
        // 1、取得本地时间：
        Calendar cal = Calendar.getInstance();
        // 2、取得时间偏移量：
        int zoneOffset = cal.get(java.util.Calendar.ZONE_OFFSET);
        // 3、取得夏令时差：
        int dstOffset = cal.get(java.util.Calendar.DST_OFFSET);
        // 4、从本地时间里扣除这些差量，即可以取得UTC时间：
        cal.add(java.util.Calendar.MILLISECOND, -(zoneOffset + dstOffset));
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH) + 1;
        int day = cal.get(Calendar.DAY_OF_MONTH);
        int hour = cal.get(Calendar.HOUR_OF_DAY);
        int minute = cal.get(Calendar.MINUTE);
        int seconds = cal.get(Calendar.SECOND);
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        UTCTimeBuffer.append(year).append("-").append(month).append("-").append(day);
        UTCTimeBuffer.append(" ").append(hour).append(":").append(minute).append(":").append(seconds);
        try {
            format.parse(UTCTimeBuffer.toString());
            return UTCTimeBuffer.toString();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;

    }

    /**
     * 将UTC时间转换为东八区时间
     *
     * @param UTCTime
     * @return
     */

    public static String getLocalTimeFromUTC(String UTCTime) {
        java.util.Date UTCDate = null;
        String localTimeStr = null;
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            UTCDate = format.parse(UTCTime);
            format.setTimeZone(TimeZone.getTimeZone("GMT-8"));
            localTimeStr = format.format(UTCDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return localTimeStr;

    }

    public static String getUtcTime(String datePattern) {
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        StringBuffer UTCTimeBuffer = new StringBuffer();
        // 1、取得本地时间：
        // 获取UTC时间
        // 获取UTC时间
        Date date = new Date();
        // 获取UTC时间的毫秒数
        long time = date.getTime();
        // 转换为UTC时间
        Date utcDate = new Date(time - TimeZone.getDefault().getRawOffset());
        return DateUtil.format(utcDate, datePattern + ".000");
    }

}