Java开发中常用日期工具(整合版)

开发中经常用到的日期工具类整合

package com.etouch.utils;

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

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;


/**
 * @author fei
 * @date 2020-06-01 11:48:29
 * @description 日期工具类
 */
public class DateUtil {

    private static Logger log = LoggerFactory.getLogger(DateUtil.class);

    /**
     * @author fei
     * @date 2020-06-01 11:38:18
     * @description 获取时间戳
     */
    public static String getInterfaceCurrentTimestamp() {
        String time_stamp = "";
        try {
            time_stamp = DateUtil.getStringFromDate(new Date(), "yyyyMMddHHmmss");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return time_stamp;
    }

    /**
     * @author fei
     * @date 2020-06-01 11:38:46
     * @description 获取当前时间
     */
    public static Timestamp getCurrentTimestamp() {
        Timestamp t = null;
        try {
            t = date2TimeStamp(getCurrentDate());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return t;
    }

    /**
     * @author fei
     * @date 2020-06-01 13:56:56
     * @description 获取当前时间
     */
    public static Date getCurrentDate() {
        Date date = new Date();
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            date = ((Date) sdf.parseObject(sdf.format(new Date())));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * @author fei
     * @date 2020-06-01 13:57:26
     * @description 获取当前时间 字符串形式 格式为 yyyy-MM-dd HH:mm:ss
     */
    public static String getCurrentStringDate() {
        return getStringFromDate(getCurrentDate());
    }

    /**
     * @author fei
     * @date 2020-06-01 13:24:19
     * @description 默认格式化为yyyy-MM-dd HH:mm:ss
     */
    public static String getStringFromDate(Date date) {
        return format(date, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * @author fei
     * @date 2020-06-01 13:27:26
     * @description 将日期字符串转化为格式化字符串
     */
    public static String getStringFromDate(String date) {
        if (date == null) {
            return "";
        }
        Date d = getDateFromString(date, "yyyy-MM-dd HH:mm:ss");
        return format(d, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * @author fei
     * @date 2020-06-01 13:25:35
     * @description 格式化为指定的样式
     */
    public static String getStringFromDate(Date date, String format) {
        return format(date, format);
    }

    /**
     * 格式化输出日期
     *
     * @param date   日期
     * @param format 格式
     * @return 返回字符型日期
     * @author fei
     * @date 2020-06-01 13:25:35
     */
    public static String format(Date date, String format) {
        String result = "";
        try {
            if (date != null) {
                SimpleDateFormat df = new SimpleDateFormat(format);
                result = df.format(date);
            }
        } catch (Exception e) {
        }
        return result;
    }

    /**
     * @author fei
     * @date 2020-06-01 13:30:01
     * @description 将String 转为date 默认String格式为yyyy-MM-dd HH:mm:ss
     */
    public static Date getDatetimeFromString(String dateStr) {
        return getDateFromString(dateStr, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * @author fei
     * @date 2020-06-01 13:31:11
     * @description 将String 转为date 默认String格式为HH:mm
     */
    public static Date getTimeFromString(String dateStr) {
        return getDateFromString(dateStr, "HH:mm");
    }

    /**
     * @author fei
     * @date 2020-06-01 13:31:05
     * @description 将String 转为date 默认String格式为yyyy-MM-dd
     */
    public static Date getDateFromString(String dateStr) {
        return getDateFromString(dateStr, "yyyy-MM-dd");
    }

    /**
     * @author fei
     * @date 2020-06-01 13:32:24
     * @description 将String 转为date 默认String格式为yyyy-MM-dd
     */
    public static Date getDateTimeFromString(String dateStr) {
        return getDateFromString(dateStr, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * @author fei
     * @date 2020-06-01 13:32:51
     * @description
     */
    public static Date strToDate(String dateTime, Date curDate) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        dateTime = sdf.format(curDate) + " " + dateTime;
        Date date = null;
        if (dateTime != null && !dateTime.trim().isEmpty()) {
            try {
                date = simpleDateFormat.parse(dateTime);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return date;
    }

    /**
     * @author fei
     * @date 2020-06-01 13:58:18
     * @description 自定义格式, 自定义日期字符
     */
    public static Date getDateFromString(String dateStr, String format) {
        if (StringUtils.isBlank(dateStr)) {
            return null;
        }
        Date date = new Date();
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            date = sdf.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;

    }

    /**
     * @author fei
     * @date 2020-06-01 13:34:52
     * @description 给指定日期加上 n个年月日时分秒
     */
    public static Date addDate(Date date, int year, int month, int day, int hour, int minute, int second) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(c.YEAR, year);
        c.add(c.MONTH, month);
        c.add(c.DAY_OF_MONTH, day);
        c.add(c.HOUR, hour);
        c.add(c.MINUTE, minute);
        c.add(c.SECOND, second);
        Date temp_date = c.getTime();
        return temp_date;
    }

    /**
     * @param date 指定日期
     * @return Timestamp
     * @author fei
     * @date 2020-06-01 13:36:36
     * @description date 转timestamp
     */
    public static Timestamp date2TimeStamp(Date date) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Timestamp ts = new Timestamp(((Date) sdf.parseObject(sdf.format(date))).getTime());
        return ts;
    }
    
    /**
     * @param date1 日期1
     * @param date2 日期2
     * @return int
     * @author fei
     * @date 2020-06-01 13:37:53
     * @description 得到两个时间之间的天数，字符串格式的,date2-date1
     */
    public static int getDaysBetween2Date(String date1, String date2) throws ParseException {
        int days = 0;
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        long to = df.parse(date2).getTime();
        long from = df.parse(date1).getTime();
        days = (int) ((to - from) / (1000 * 60 * 60 * 24));
        return days;
    }

    /**
     * @param n 小时
     * @return Date
     * @author fei
     * @date 2020-06-01 13:38:34
     * @description 获取指定时间的前n个小时时间
     */
    public static Date getBefore(Date date, Integer n) {
        Calendar calendar = Calendar.getInstance();
        /* HOUR_OF_DAY 指示一天中的小时 */
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, calendar.get(Calendar.HOUR_OF_DAY) - n);
        return calendar.getTime();
    }

    /**
     * 获取当前时间的后几个小时
     *
     * @param n
     * @return
     */
    public static Date getAfter(Date date, Integer n) {
        Calendar calendar = Calendar.getInstance();
        /* HOUR_OF_DAY 指示一天中的小时 */
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, calendar.get(Calendar.HOUR_OF_DAY) + n);
        //或者采用这种
//        calendar.add(Calendar.HOUR,n);
        return calendar.getTime();
    }

    /**
     * 得到两个时间之间的天数，日期格式的
     * date2-date1
     *
     * @param date1 日期1
     * @param date2 日期2
     * @return int 相差的日期
     * @throws ParseException
     */
    public static int getDaysBetween2Date(Date date1, Date date2) throws ParseException {
        String d1 = DateUtil.getStringFromDate(date1, "yyyy-MM-dd");
        String d2 = DateUtil.getStringFromDate(date2, "yyyy-MM-dd");
        return getDaysBetween2Date(d1, d2);
    }

    /**
     * 得到两个时间之间的小时，日期格式的 date2-date1
     *
     * @param date1 日期1
     * @param date2 日期2
     * @return double 小时数
     * @throws ParseException
     */
    public static double getHoursBetween2Date(Date date1, Date date2) {
        double hours = 0;
        hours = (double) (Double.parseDouble((date2.getTime() - date1.getTime()) + "") / (1000 * 60 * 60));
        return hours;
    }

    /**
     * @param date1 日期1
     * @param date2 日期2
     * @return int
     * @throws ParseException
     * @author fei
     * @date 2020-06-01 14:02:05
     * @description 得到两个时间之间的分，日期格式的 date2-date1
     */
    public static int getMinutesBetween2Date(Date date1, Date date2) throws ParseException {
        int minutes = 0;
        if (date2.getTime() < date1.getTime()) {
            return 0;
        }
        minutes = (int) ((date2.getTime() - date1.getTime()) / (1000 * 60));
        return minutes;
    }

    /**
     * @param date 指定日期
     * @return int 获取指定日期的年份
     * @author fei
     * @date 2020-06-01 11:41:16
     * @description 获取年份
     */
    public static int getYear(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.YEAR);
    }

    /**
     * @param date 指定日期
     * @return int 月份
     * @author fei
     * @date 2020-06-01 11:42:09
     * @description 获取月份
     */
    public static int getMonth(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.MONTH) + 1;//calendar获取到的月份少一个月, 所以这里加1
    }

    /**
     * @param date 传递的日期
     * @return int 指定日期的日份
     * @author fei
     * @date 2020-06-01 11:43:21
     * @description 获取指定日期的日份
     */
    public static int getDay(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.DAY_OF_MONTH);
    }

    /**
     * @author fei
     * @date 2020-06-01 11:44:30
     * @description 返回指定日期的对应小时
     */
    public static int getHour(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.HOUR_OF_DAY);
    }

    /**
     * 返回分钟
     *
     * @param date 指定的日期 日期
     * @return 返回分钟
     * @author fei
     */
    public static int getMinute(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.MINUTE);
    }

    /**
     * 返回秒钟
     *
     * @param date 指定的日期 日期
     * @return 返回秒钟
     * @author fei
     */
    public static int getSecond(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.SECOND);
    }

    /**
     * 返回毫秒
     *
     * @param date 指定的日期 日期
     * @return 返回毫秒
     * @author fei
     */
    public static long getMillis(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.getTimeInMillis();
    }


    /**
     * @param gc
     * @return java.util.Calendar
     * @Description: 获取月份的最后一天
     * @author fei
     * @date 2016-5-4
     */
    public static synchronized Calendar getLastDayOfMonth(Calendar gc) {
        /**
         * 详细设计：
         * 1.如果date在1月，则为31日
         * 2.如果date在2月，则为28日
         * 3.如果date在3月，则为31日
         * 4.如果date在4月，则为30日
         * 5.如果date在5月，则为31日
         * 6.如果date在6月，则为30日
         * 7.如果date在7月，则为31日
         * 8.如果date在8月，则为31日
         * 9.如果date在9月，则为30日
         * 10.如果date在10月，则为31日
         * 11.如果date在11月，则为30日
         * 12.如果date在12月，则为31日
         * 1.如果date在闰年的2月，则为29日
         */
        switch (gc.get(Calendar.MONTH)) {
            case 0:
                gc.set(Calendar.DAY_OF_MONTH, 31);
                break;
            case 1:
                gc.set(Calendar.DAY_OF_MONTH, 28);
                break;
            case 2:
                gc.set(Calendar.DAY_OF_MONTH, 31);
                break;
            case 3:
                gc.set(Calendar.DAY_OF_MONTH, 30);
                break;
            case 4:
                gc.set(Calendar.DAY_OF_MONTH, 31);
                break;
            case 5:
                gc.set(Calendar.DAY_OF_MONTH, 30);
                break;
            case 6:
                gc.set(Calendar.DAY_OF_MONTH, 31);
                break;
            case 7:
                gc.set(Calendar.DAY_OF_MONTH, 31);
                break;
            case 8:
                gc.set(Calendar.DAY_OF_MONTH, 30);
                break;
            case 9:
                gc.set(Calendar.DAY_OF_MONTH, 31);
                break;
            case 10:
                gc.set(Calendar.DAY_OF_MONTH, 30);
                break;
            case 11:
                gc.set(Calendar.DAY_OF_MONTH, 31);
                break;
        }
        //检查闰年
        if ((gc.get(Calendar.MONTH) == Calendar.FEBRUARY)
                && (isLeapYear(gc.get(Calendar.YEAR)))) {
            gc.set(Calendar.DAY_OF_MONTH, 29);
        }
        return gc;
    }

    /**
     * @param date 指定的日期 指定日期。
     * @return 指定日期的所处月份的第一天
     * @author fei
     * @date 2020-06-01 14:04:12
     * @description 取得指定日期的所处月份的第一天
     */
    public static synchronized Date getFirstDayOfMonth(Date date) {
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        gc.set(Calendar.DAY_OF_MONTH, 1);
        return gc.getTime();
    }
    
    /**
     * 将日期对象转换成为指定ORA日期、时间格式的字符串形式。如果日期对象为空，返回 一个空字符串对象，而不是一个空对象。
     *
     * @param theDate 将要转换为字符串的日期对象。
     * @param hasTime 如果返回的字符串带时间则为true
     * @return 转换的结果
     * @author fei
     */
    public static synchronized String toOraString(Date theDate, boolean hasTime) {
        /**
         * 详细设计：
         * 1.如果有时间，则设置格式为getOraDateTimeFormat()的返回值
         * 2.否则设置格式为getOraDateFormat()的返回值
         * 3.调用toString(Date theDate, DateFormat
         * theDateFormat)
         */
        DateFormat theFormat;
        if (hasTime) {
            theFormat = getOraDateTimeFormat();
        } else {
            theFormat = getOraDateFormat();
        }
        return toString(theDate, theFormat);
    }

    /**
     * 将日期对象转换成为指定日期、时间格式的字符串形式。如果日期对象为空，返回 一个空字符串对象，而不是一个空对象。
     *
     * @param theDate 将要转换为字符串的日期对象。
     * @param hasTime 如果返回的字符串带时间则为true
     * @return 转换的结果
     * @author fei
     */
    public static synchronized String toString(Date theDate, boolean hasTime) {
        /**
         * 详细设计：
         * 1.如果有时间，则设置格式为getDateTimeFormat的返回值
         * 2.否则设置格式为getDateFormat的返回值
         * 3.调用toString(Date theDate, DateFormat theDateFormat)
         */
        DateFormat theFormat;
        if (hasTime) {
            theFormat = getDateTimeFormat();
        } else {
            theFormat = getDateFormat();
        }
        return toString(theDate, theFormat);
    }

    /**
     * 标准日期格式
     */
    public static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("MM/dd/yyyy");
    /**
     * 标准时间格式
     */
    public static final SimpleDateFormat DATE_TIME_FORMAT = new SimpleDateFormat("MM/dd/yyyy HH:mm");
    /**
     * 带时分秒的标准时间格式
     */
    public static final SimpleDateFormat DATE_TIME_EXTENDED_FORMAT = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
    /**
     * ORA标准日期格式
     */
    private static final SimpleDateFormat ORA_DATE_FORMAT = new SimpleDateFormat("yyyyMMdd");
    /**
     * ORA标准时间格式
     */
    public static final SimpleDateFormat ORA_DATE_TIME_FORMAT = new SimpleDateFormat("yyyyMMddHHmm");
    /**
     * 带时分秒的ORA标准时间格式
     */
    public static final SimpleDateFormat ORA_DATE_TIME_EXTENDED_FORMAT = new SimpleDateFormat("yyyyMMddHHmmss");

    /**
     * 创建一个标准日期格式的克隆
     *
     * @return 标准日期格式的克隆
     */
    public static synchronized DateFormat getDateFormat() {
        /**
         * 详细设计： 1.返回DATE_FORMAT
         */
        SimpleDateFormat theDateFormat = (SimpleDateFormat)
                DATE_FORMAT.clone();
        theDateFormat.setLenient(false);
        return theDateFormat;
    }

    /**
     * 创建一个标准时间格式的克隆
     *
     * @return 标准时间格式的克隆
     */
    public static synchronized DateFormat getDateTimeFormat() {
        /**
         * 详细设计： 1.返回DATE_TIME_FORMAT
         */
        SimpleDateFormat theDateTimeFormat = (SimpleDateFormat) DATE_TIME_FORMAT
                .clone();
        theDateTimeFormat.setLenient(false);
        return theDateTimeFormat;
    }

    /**
     * 创建一个标准ORA日期格式的克隆
     *
     * @return 标准ORA日期格式的克隆
     */
    public static synchronized DateFormat getOraDateFormat() {
        /**
         * 详细设计： 1.返回ORA_DATE_FORMAT
         */
        SimpleDateFormat theDateFormat = (SimpleDateFormat) ORA_DATE_FORMAT
                .clone();
        theDateFormat.setLenient(false);
        return theDateFormat;
    }

    /**
     * 创建一个标准ORA时间格式的克隆
     *
     * @return 标准ORA时间格式的克隆
     */
    public static synchronized DateFormat getOraDateTimeFormat() {
        /**
         * 详细设计： 1.返回ORA_DATE_TIME_FORMAT
         */
        SimpleDateFormat theDateTimeFormat = (SimpleDateFormat)
                ORA_DATE_TIME_FORMAT.clone();
        theDateTimeFormat.setLenient(false);
        return theDateTimeFormat;
    }

    /**
     * 将一个日期对象转换成为指定日期、时间格式的字符串。 如果日期对象为空，返回一个空字符串，而不是一个空对象。
     *
     * @param theDate       要转换的日期对象
     * @param theDateFormat 返回的日期字符串的格式
     * @return 转换结果
     */
    public static synchronized String toString(Date theDate,
                                               DateFormat theDateFormat) {
        /**
         * 详细设计：
         * 1.theDate为空，则返回""
         * 2.否则使用theDateFormat格式化
         */
        if (theDate == null)
            return "";
        return theDateFormat.format(theDate);
    }

  	/**
  	 * @author fei
  	 * @date 2020-06-01 14:15:48 
  	 * @description 判断当前日期是否是闰年
  	*/
    public static synchronized boolean isLeapYear() {
        Calendar cal = Calendar.getInstance();
        int year = cal.get(Calendar.YEAR);
        return isLeapYear(year);
    }

    /**
     * 计算指定年份是否是闰年
     *
     * @param year
     * @return
     */
    public static synchronized boolean isLeapYear(int year) {
        /**
         * 详细设计： 1.被400整除是闰年，否则： 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年
         * 3.能被4整除同时能被100整除则不是闰年
         */
        if ((year % 400) == 0)
            return true;
        else if ((year % 4) == 0) {
            if ((year % 100) == 0)
                return false;
            else return true;
        } else return false;
    }

    /**
     * 判断指定日期的年份是否是闰年
     *
     * @param date 指定的日期 指定日期。
     * @return 是否闰年
     */
    public static synchronized boolean isLeapYear(Date date) {
        /**
         * 详细设计： 1.被400整除是闰年，否则： 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年
         * 3.能被4整除同时能被100整除则不是闰年
         */
        // int year = date.getYear();
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        int year = gc.get(Calendar.YEAR);
        return isLeapYear(year);
    }

    /**
     * 判断指定时间是否是闰年
     *
     * @param gc
     * @return
     */
    public static synchronized boolean isLeapYear(Calendar gc) {
        /**
         * 详细设计： 1.被400整除是闰年，否则： 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年
         * 3.能被4整除同时能被100整除则不是闰年
         */
        int year = gc.get(Calendar.YEAR);
        return isLeapYear(year);
    }

    /**
     * 取得指定日期的下一个月
     *
     * @param date 指定的日期 指定日期。
     * @return 指定日期的下一个月
     */
    public static synchronized Date getNextMonth(Date date) {
        /**
         * 详细设计：
         * 1.指定日期的月份加1
         */
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        gc.add(Calendar.MONTH, 1);
        return gc.getTime();
    }
    
    /**
     * @param date 指定日期
     * @author fei
     * @date 2020-06-01 14:10:43
     * @description 取得指定日期的下一天
     */
    public static synchronized Date getNextDay(Date date) {
        /**
         * 详细设计： 1.指定日期加1天
         */
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        gc.add(Calendar.DATE, 1);
        return gc.getTime();
    }
    
    /**
     * @author fei
     * @date 2020-06-01 14:10:22
     * @description 指定日期的下一个星期
     */
    public static synchronized Date getNextWeek(Date date) {
        /**
         * 详细设计：
         * 1.指定日期加7天
         */
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        gc.add(Calendar.DATE, 7);
        return gc.getTime();
    }
    

    /**
     * @author fei
     * @date 2020-06-01 14:09:28
     * @description 比较两个字符串时间大小，带时分秒的，date2大于date1返回true
     */
    public static synchronized boolean compare2Date(String date1, String date2) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = sdf.parse(date1);
        Date d2 = sdf.parse(date2);

        if (d2.getTime() - d1.getTime() > 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * @author fei
     * @date 2020-06-01 14:08:56
     * @description 比较两个时间大小，带时分秒的，date2大于date1返回true
     */
    public static synchronized boolean compare2Date(Date date1, Date date2) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = sdf.parse(sdf.format(date1));
        Date d2 = sdf.parse(sdf.format(date2));

        if (d2.getTime() - d1.getTime() > 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * @author fei
     * @date 2020-06-01 14:07:48
     * @description 比较两个时间字符串的大小，不带时分秒的，date2大于date1返回true
     */
    public static synchronized boolean compare2DateNoHMS(String date1, String date2) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = sdf.parse(date1);
        Date d2 = sdf.parse(date2);

        if (d2.getTime() - d1.getTime() > 0) {
            return true;
        } else {
            return false;
        }

    }

    /**
     * @author fei
     * @date 2020-06-01 14:07:06
     * @description 比较两个时间大小，不带时分秒的，date2大于date1返回true
     */
    public static synchronized boolean compare2DateNoHMS(Date date1, Date date2) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = sdf.parse(sdf.format(date1));
        Date d2 = sdf.parse(sdf.format(date2));
        if (d2.getTime() - d1.getTime() > 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 取得指定日期的加n天(n可为负数)
     *
     * @param date 指定日期。
     * @return 指定日期的加n天
     * @author fei
     */
    public static synchronized Date getOtherDay(Date date, int n) {
        GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();
        gc.setTime(date);
        gc.add(Calendar.DATE, n);
        return gc.getTime();
    }
    
    /**
     * @author fei
     * @date 2020-06-01 11:49:54
     * @description 获取指定时间是星期几
     */
    public static int getWeekOfDate(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w <= 0)
            w = 7;
        return w;
    }

    public static String getUpWeekOfDate(Date date) {
        int i = getWeekOfDate(date);
        switch (i) {
            case 1:
                return "一";
            case 2:
                return "二";
            case 3:
                return "三";
            case 4:
                return "四";
            case 5:
                return "五";
            case 6:
                return "六";
            case 7:
                return "七";
            default:
                return "error";
        }
    }

    /**
     * @param createDate 指定的日期
     * @return String 时分秒
     * @author fei
     * @date 2020-06-01 13:52:40
     * @description 获取指定日期的时分秒
     */
    public static String getTimeAllFromString(Date createDate) throws ParseException {
        SimpleDateFormat sd = new SimpleDateFormat("HH:mm:ss");
        return sd.format(createDate);
    }
}

获取指定日期几天后的时间

/**
     * @author fei
     * @date 2020-06-01 10:46:59
     * @description 获取几天后的时间
    */
    public static Date getDateAfter(Date date,Integer day) {
        Calendar now = Calendar.getInstance();
        now.setTime(date);
        now.set(Calendar.DATE, now.get(Calendar.DATE) + day);//+后 -前
        return now.getTime();
    }