日期操作工具类

import com.google.common.collect.Lists;
import org.apache.commons.lang3.StringUtils;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class DateUtils {

    /**
     * Default locale is CHINA
     */
    public static final Locale DEFAULT_LOCALE = Locale.CHINA;

    public static final String FORMAT_DATE_DEFAULT = "yyyy-MM-dd";

    public static final String FORMAT_DATE_YYYYMMDD = "yyyyMMdd";

    public static final String FORMAT_DATE_YYYY_MM_DD = "yyyy-MM-dd";

    public static final String FORMAT_DATE_PATTERN_1 = "yyyy/MM/dd";

    public static final String FORMAT_DATE_PATTERN_2 = "yyyy/M/dd";

    public static final String FORMAT_DATE_PATTERN_3 = "yyyy/MM/d";

    public static final String FORMAT_DATE_PATTERN_4 = "yyyy/M/d";

    public static final String FORMAT_DATE_YYYY_MM_DD_HHMMSS = "yyyyMMddHHmmss";

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

    public static final String FORMAT_DATE_YYYY_MM_DD_HH_MM_SS_1 = "yyyy/MM/dd HH:mm:ss";

    public static final String FORMAT_DATE_YYYY_MM_DD_HH_MM_SS_FFF = "yyyy-MM-dd HH:mm:ss FFF";

    public static final String FORMAT_DATE_MM_DD_HH_MM_SS = "MM-dd HH:mm:ss";

    public static final String FORMAT_DATE_MM_DD_HH_MM = "MM-dd HH:mm";

    public static final String FORMAT_DATE_YYYY_MM_DD_HHMM = "yyyy-MM-dd HHmm";

    public static final String FORMAT_DATE_YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";

    public static final String FORMAT_DATE_HH_MM = "HH:mm";

    public static final String FORMAT_DATE_HH_MM_SS = "HH:mm:ss";

    public static final String FORMAT_DATE_HHMM = "HHmm";

    public static final String FORMAT_DATE_HHMMSS = "HHmmss";

    public static final String FORMAT_DATE_YYMMDD = "yyMMdd";

    public static final String FORMAT_WORK_TIME = "yyyy-MM-dd HHmmss";

    public static final String FORMAT_DATE_YYYY_MM_DDHHMMSS = "yyyy-MM-ddHHmmss";

    public static final String FORMAT_DATE_YYYYMMDD_BLANK_HHMMSS = "yyyyMMdd HH:mm:ss";

    public static final String FORMAT_DATE_YYMMDDHH = "yyMMddHH";
    public static final String FORMAT_DATE_YYYYMMDDHH = "yyyyMMddHH";

    public static final String FORMAT_DATE_YYYY_MM_DD_HH = "yyyy-MM-dd HH:00:00";

    public static final String FORMAT_DATE_YYYYMMDD_DOTS = "yyyy.MM.dd";

    public static final String FORMAT_DATE_YYYY_MM_DDTHH_MM_SS_FFFZ = "yyyy-MM-dd\'T\'HH:mm:ss.SSS+0800";

    public static final String DATE_END = " 23:59:59";

    /**
     * 获取月份
     */
    public static final String FORMAT_DATE_MM = "MM";

    /**
     * 获取年份
     */
    public static final String FORMAT_DATE_YYYY = "yyyy";

    public static final String FORMAT_DATE_YYYY_MM = "yyyy-MM";

    public static final String DATEYYYYMMREG = "(\\d{4})(\\d{2})(\\d{2})(\\d{2})(\\d{2})(\\d{2})";

    /**
     * Compares two Dates from their string value.
     *
     * @param stringValue1 Date 1 as string value.
     * @param stringValue2 Date 2 as string value.
     * @return the value <code>0</code> if the argument stringValue1 is equal to
     * stringValue2; a value less than <code>0</code> if this stringValue1
     * is before the stringValue2 as Date; and a value greater than
     * <code>0</code> if this stringValue1 is after the stringValue2.
     * @since 1.2
     */
    public static final int compareDate(String stringValue1, String stringValue2) throws ParseException {
        Date date1 = tryParse(stringValue1);
        if (date1 == null)
            throw new ParseException("Can not parse " + stringValue1 + " to Date.", 0);
        Date date2 = tryParse(stringValue2);
        if (date2 == null)
            throw new ParseException("Can not parse " + stringValue1 + " to Date.", 0);
        return date1.compareTo(date2);
    }

    /*
     * 给定时间于当期时间的比较，差值为分钟
     */
    public static final long compareDateToMin(String stringValue1) throws ParseException {

        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        java.util.Date now = Calendar.getInstance().getTime();
        java.util.Date date = df.parse(stringValue1);
        long l = now.getTime() - date.getTime();

        return l / (60 * 1000);

    }

    /**
     * Returns current system date as formatted string value with default format
     * pattern.
     *
     * @return current system date.
     * @see #FORMAT_DATE_DEFAULT
     */
    public static final String getCurrentDateAsString() {
        return getCurrentDateAsString(FORMAT_DATE_DEFAULT);
    }

    /**
     * Returns current system date as formatted string value with given format
     * pattern.
     *
     * @param formatPattern format pattern.
     * @return current system date.
     */
    public static final String getCurrentDateAsString(String formatPattern) {
        Date date = getCurrentDate();
        return format(date, formatPattern);
    }

    /**
     * Returns current system date.
     *
     * @return current system date.
     */
    public static final Date getCurrentDate() {
        return Calendar.getInstance().getTime();
    }

    public static final Date getCurrentDateZero() {
        Date now = getCurrentDate();
        try {
            SimpleDateFormat format = new SimpleDateFormat(FORMAT_DATE_YYYY_MM_DD);
            return format.parse(format.format(now));
        } catch (ParseException e) {
            return now;
        }
    }

    /**
     * @return
     */
    public static final Timestamp getCurrentTimestamp() {
        return new Timestamp(Calendar.getInstance().getTimeInMillis());
    }

    /**
     * Format Date value as string value with default format pattern.
     *
     * @param date Date value.
     * @return formatted date as string value.
     * @see #FORMAT_DATE_DEFAULT
     */
    public static final String format(Date date) {
        if (date == null) {
            return "";
        }
        return format(date, FORMAT_DATE_DEFAULT);
    }

    /**
     * Format Date value as string value with default format pattern.
     *
     * @param date Date value.
     * @return formatted date as string value.
     * @see #FORMAT_DATE_DEFAULT
     */
    public static final String formatDateTime(Date date) {
        if (date == null) {
            return "";
        }
        return format(date, FORMAT_DATE_YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * Format Date value as string value with default format pattern.
     *
     * @param date Date value.
     * @return formatted date as string value.
     * @see #FORMAT_DATE_DEFAULT
     */
    public static final String formatTimestamp(Date date) {
        if (date == null) {
            return "";
        }
        return format(date, "yyyy-MM-dd HH:mm:ss.SSS");
    }

    /**
     * Format Date value as string value with default format pattern.
     *
     * @param date Date value.
     * @return formatted date as string value.
     * @see #FORMAT_DATE_DEFAULT
     */
    public static final Date parseTimestamp(String date) {
        if (date == null) {
            return null;
        }
        return parse(date, "yyyy-MM-dd HH:mm:ss.SSS");
    }

    /**
     * Format Date value as string value with given format pattern.
     *
     * @param date          Date value.
     * @param formatPattern format pattern.
     * @return formatted date as string value.
     * @see #FORMAT_DATE_DEFAULT
     * @see #FORMAT_DATE_YYYY_MM_DD
     * @see #FORMAT_DATE_YYYY_MM_DD_HH_MM
     * @see #FORMAT_DATE_YYYY_MM_DD_HH_MM_SS
     * @see #FORMAT_DATE_YYYY_MM_DD_HHMMSS
     */
    public static final String format(Date date, String formatPattern) {
        if (date == null) {
            return "";
        }
        return new SimpleDateFormat(formatPattern).format(date);
    }

    /**
     * @param date
     * @return
     */
    public static final String formatTimestamp(Timestamp date) {
        return format(date, FORMAT_DATE_YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * Parse string value to Date with default format pattern.
     *
     * @param stringValue date value as string.
     * @return Date represents stringValue.
     * @see #FORMAT_DATE_DEFAULT
     */
    public static final Date parse(String stringValue) {
        return parse(stringValue, FORMAT_DATE_DEFAULT);
    }

    /**
     * Parse string value to Date with given format pattern.
     *
     * @param stringValue   date value as string.
     * @param formatPattern format pattern.
     * @return Date represents stringValue, null while parse exception occurred.
     * @see #FORMAT_DATE_DEFAULT
     */
    public static final Date parse(String stringValue, String formatPattern) {
        SimpleDateFormat format = new SimpleDateFormat(formatPattern);
        try {
            return format.parse(stringValue);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @param stringValue
     * @param format
     * @return
     */
    public static final boolean isDate(String stringValue, String formatPattern) {
        try {
            if (StringUtils.isEmpty(stringValue) || StringUtils.isEmpty(formatPattern)) {
                return false;
            }

            SimpleDateFormat format = new SimpleDateFormat(formatPattern);
            return null != format.parse(stringValue);
        } catch (ParseException e) {
            return false;
        }
    }

    public static final boolean isDateStrictWay(String stringValue, String formatPattern) {
        try {
            if (StringUtils.isEmpty(stringValue) || StringUtils.isEmpty(formatPattern)) {
                return false;
            }
            SimpleDateFormat format = new SimpleDateFormat(formatPattern);
            format.setLenient(false);
            return null != format.parse(stringValue);
        } catch (ParseException e) {
            return false;
        }
    }

    public static final Date parseDate(String stringValue, String formatPattern) {
        if (StringUtils.isEmpty(stringValue)) {
            return null;
        }
        return parse(stringValue, formatPattern);
    }

    /**
     * Try to parse string value to date.
     *
     * @param stringValue string value.
     * @return Date represents stringValue, null while parse exception occurred.
     */
    public static final Date tryParse(String stringValue) {
        Date date = parse(stringValue, FORMAT_DATE_YYYY_MM_DD);
        if (date != null) {
            return date;
        }
        date = parse(stringValue, FORMAT_DATE_YYYYMMDD);
        if (date != null) {
            return date;
        }
        date = parse(stringValue, FORMAT_DATE_YYYY_MM_DD_HHMMSS);
        if (date != null) {
            return date;
        }
        date = parse(stringValue, FORMAT_DATE_YYYY_MM_DD_HH_MM_SS);
        if (date != null) {
            return date;
        }
        date = parse(stringValue, FORMAT_DATE_YYYY_MM_DD_HHMM);
        if (date != null) {
            return date;
        }
        date = parse(stringValue, FORMAT_DATE_PATTERN_1);
        if (date != null) {
            return date;
        }
        date = parse(stringValue, FORMAT_DATE_PATTERN_2);
        if (date != null) {
            return date;
        }
        date = parse(stringValue, FORMAT_DATE_PATTERN_3);
        if (date != null) {
            return date;
        }
        date = parse(stringValue, FORMAT_DATE_PATTERN_4);
        if (date != null) {
            return date;
        }
        return date;
    }

    /**
     * get day of week
     *
     * @param SUN_FST_DAY_OF_WEEK
     * @return
     */
    public static int getDayOfWeek(int SUN_FST_DAY_OF_WEEK) {
        if (SUN_FST_DAY_OF_WEEK > 7 || SUN_FST_DAY_OF_WEEK < 1)
            return 0;
        if (SUN_FST_DAY_OF_WEEK == 1)
            return 7;
        return SUN_FST_DAY_OF_WEEK - 1;
    }

    public static Timestamp parseTimestamp(String stringValue, String formatPattern) {
        if (StringUtils.isEmpty(stringValue)) {
            return null;
        }
        return new Timestamp(parse(stringValue, formatPattern).getTime());
    }

    public static Timestamp parseTimestamp(Date d, String formatPattern) {
        if (d == null) {
            return null;
        }
        return parseTimestamp(format(d, formatPattern), formatPattern);
    }

    public static Timestamp parseTimestamp(Date d) {
        return new Timestamp(d.getTime());
    }

    // -----------------------------------------------------------------------

    /**
     * Adds a number of milliseconds to a date returning a new object. The original
     * date object is unchanged.
     *
     * @param date   the date, not null
     * @param amount the amount to add, may be negative
     * @return the new date object with the amount added
     * @throws IllegalArgumentException if the date is null
     */
    public static Date addMilliseconds(Date date, int amount) {
        return add(date, Calendar.MILLISECOND, amount);
    }

    /**
     * Adds a number of milliseconds to a date returning a new object. The original
     * date object is unchanged.
     *
     * @param date   the date, not null
     * @param amount the amount to add, may be negative
     * @return the new date object with the amount added
     * @throws IllegalArgumentException if the date is null
     */
    public static Date addMilliseconds(Date date, long amount) {
        if (date == null) {
            throw new IllegalArgumentException("The date must not be null");
        }
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(date.getTime() + amount);
        return c.getTime();
    }

    // -----------------------------------------------------------------------

    /**
     * Adds a number of minutes to a date returning a new object. The original date
     * object is unchanged.
     *
     * @param date   the date, not null
     * @param amount the amount to add, may be negative
     * @return the new date object with the amount added
     * @throws IllegalArgumentException if the date is null
     */
    public static Date addMinutes(Date date, int amount) {
        return add(date, Calendar.MINUTE, amount);
    }

    // -----------------------------------------------------------------------

    /**
     * Adds to a date returning a new object. The original date object is unchanged.
     *
     * @param date          the date, not null
     * @param calendarField the calendar field to add to
     * @param amount        the amount to add, may be negative
     * @return the new date object with the amount added
     * @throws IllegalArgumentException if the date is null
     */
    public static Date add(Date date, int calendarField, int amount) {
        if (date == null) {
            throw new IllegalArgumentException("The date must not be null");
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(calendarField, amount);
        return c.getTime();
    }

    /**
     * <p>
     * Checks if two date objects are on the same day ignoring time.
     * </p>
     *
     * <p>
     * 28 Mar 2002 13:45 and 28 Mar 2002 06:01 would return true. 28 Mar 2002 13:45
     * and 12 Mar 2002 13:45 would return false.
     * </p>
     *
     * @param date1 the first date, not altered, not null
     * @param date2 the second date, not altered, not null
     * @return true if they represent the same day
     * @throws IllegalArgumentException if either date is <code>null</code>
     * @since 2.1
     */
    public static boolean isSameDay(Date date1, Date date2) {
        if (date1 == null || date2 == null) {
            throw new IllegalArgumentException("The date must not be null");
        }
        Calendar cal1 = Calendar.getInstance();
        cal1.setTime(date1);
        Calendar cal2 = Calendar.getInstance();
        cal2.setTime(date2);
        return isSameDay(cal1, cal2);
    }

    /**
     * <p>
     * Checks if two calendar objects are on the same day ignoring time.
     * </p>
     *
     * <p>
     * 28 Mar 2002 13:45 and 28 Mar 2002 06:01 would return true. 28 Mar 2002 13:45
     * and 12 Mar 2002 13:45 would return false.
     * </p>
     *
     * @param cal1 the first calendar, not altered, not null
     * @param cal2 the second calendar, not altered, not null
     * @return true if they represent the same day
     * @throws IllegalArgumentException if either calendar is <code>null</code>
     * @since 2.1
     */
    public static boolean isSameDay(Calendar cal1, Calendar cal2) {
        if (cal1 == null || cal2 == null) {
            throw new IllegalArgumentException("The date must not be null");
        }
        return (cal1.get(Calendar.ERA) == cal2.get(Calendar.ERA) && cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR)
                && cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR));
    }

    /**
     * @param date
     * @return Date
     * @Title: getFirstDayOfWeek
     * @Description: 取得指定日期所在周的第一天
     * @author yangzhi
     */
    public static Date getFirstDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
        return c.getTime();
    }

    /**
     * @param currentDate
     * @param week
     * @return Date
     * @Title: addWeekDayOfWeek
     * @Description: 在指定的日期上+指定的周
     * @author yangzhi
     */
    public static Date addWeekDayOfWeek(Date currentDate, int week) {
        Calendar c = new GregorianCalendar();
        c.setTime(currentDate);
        c.add(Calendar.WEEK_OF_YEAR, week);
        return c.getTime();
    }

    /**
     * @param startDate
     * @param endDate
     * @return
     * @Description 获取两个时间间隔，单位ms
     */
    public static long getDateInterval(String startDate, String endDate) {
        Date startTime = parse(startDate, DateUtils.FORMAT_DATE_YYYY_MM_DD_HH_MM_SS);
        Date endTime = parse(endDate, DateUtils.FORMAT_DATE_YYYY_MM_DD_HH_MM_SS);
        return endTime.getTime() - startTime.getTime();
    }

    /**
     * 判断两个时间在一个间隔内
     *
     * @param startTime
     * @param endTime
     * @param interval
     * @return
     */
    public static boolean isTwoDateInInterval(Date startTime, Date endTime, int interval) {
        if (null == startTime || null == endTime) {
            return false;
        }

        Calendar cal = Calendar.getInstance();
        cal.setTime(startTime);
        cal.add(Calendar.DAY_OF_YEAR, interval);
        return cal.getTime().after(endTime);
    }

    /**
     * 获取两个时间段内的所有时间集合
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static List<Date> getDatesBetweenTwoDate(String startDate, String endDate) {
        Date startTime = parse(startDate, DateUtils.FORMAT_DATE_DEFAULT);
        Date endTime = parse(endDate, DateUtils.FORMAT_DATE_DEFAULT);
        List<Date> resultlist = new ArrayList<>();
        resultlist.add(startTime); // 把开始时间加入集合
        Calendar cal = Calendar.getInstance();
        cal.setTime(startTime);
        while (true) {
            cal.add(Calendar.DAY_OF_MONTH, 1);
            if (endTime.after(cal.getTime())) {
                resultlist.add(cal.getTime());
            } else {
                break;
            }
        }
        resultlist.add(endTime);
        return resultlist;
    }

    /**
     * 将指定格式时间转换为另一种格式
     *
     * @param sourceDate
     * @param sourceFormat
     * @param targetFormat
     * @return
     */
    public static String formatDate(String sourceDate, String sourceFormat, String targetFormat) {
        try {
            return DateUtils.format(DateUtils.parse(sourceDate, sourceFormat), targetFormat);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 获取指定日期星期天
     *
     * @param sourceDate
     * @param format
     * @return
     */
    public static String formatToSundayDate(String sourceDate, String format) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(parse(sourceDate, format));
        cal.set(Calendar.DAY_OF_WEEK, 1);
        return format(cal.getTime(), format);
    }

    /**
     * 获取指定日期星期天和前N个星期天
     *
     * @param updateTime
     * @param format
     * @param size
     * @return
     */
    public static List<String> listSundayDate(long updateTime, String format, int size) {
        List<String> sundayDates = Lists.newArrayList();
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(updateTime);
        cal.set(Calendar.DAY_OF_WEEK, 1);
        sundayDates.add(format(cal.getTime(), format));
        while (size-- > 0) {
            cal.add(Calendar.DATE, -7);
            sundayDates.add(format(cal.getTime(), format));
        }
        return sundayDates;
    }

    /**
     * 秒转换为 x时x分x秒 显示
     *
     * @param milliSeconds
     * @return
     */
    public static String formatMilliSeconds(int milliSeconds) {
        int seconds = milliSeconds / 1000;
        int second = seconds % 60;
        int minute = (seconds / 60) % 60;
        int hour = (seconds / (60 * 60)) % 60;

        StringBuilder formatTime = new StringBuilder();
        if (hour > 0) {
            formatTime.append(hour).append(" 时 ");
            formatTime.append(minute).append(" 分 ");
        } else if (minute > 0) {
            formatTime.append(minute).append(" 分 ");
        }
        formatTime.append(second).append(" 秒");
        return formatTime.toString();
    }

    /**
     * 时间是否已经过去
     *
     * @param stringValue
     * @param formatPattern
     * @return
     */
    public static boolean isOvertime(String stringValue, String formatPattern) {
        if (StringUtils.isBlank(stringValue)) {
            return false;
        }

        try {
            return DateUtils.parse(stringValue, formatPattern).before(DateUtils.getCurrentDate());
        } catch (Exception e) {
            return false;
        }
    }

    public static Timestamp parseYYYYMMDD(String stringValue, String formatPattern) {
        stringValue = stringValue.replaceAll(DATEYYYYMMREG, "$1-$2-$3 $4:$5:$6");
        if (StringUtils.isEmpty(stringValue)) {
            return null;
        }
        return new Timestamp(parse(stringValue, formatPattern).getTime());
    }


    /**
     * @param beginDateStr 制定开始日期
     * @param format       转换格式
     * @description: 制定日期到当前的所有间隔日期
     * @author: ChenYao(https : / / blog.csdn.net / chenyao1994)
     * @return: java.util.List<java.lang.String>
     * @CeateDate: 2020/6/16 16:22
     */
    public static List<String> findIntervalDates(String beginDateStr, String format) {
        List<String> intervalDateList = new ArrayList<>();
        //intervalDateList.add(beginDateStr);
        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(DateUtils.parse(beginDateStr, format));
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        Date endDate = new Date();
        calEnd.setTime(endDate);
        // 测试此日期是否在指定日期之后
        while (endDate.after(calBegin.getTime())) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            calBegin.add(Calendar.HOUR_OF_DAY, 1);
            intervalDateList.add(DateUtils.format(calBegin.getTime(), format));
        }
        if (!intervalDateList.isEmpty()) {
            intervalDateList.remove(intervalDateList.size() - 1);
        }
        return intervalDateList;
    }
}