java操作日期的相关工具类，拿去即用

日期工具类
1.获取当前Date型日期
2. 获取当前日期, 默认格式为yyyy-MM-dd
3. 日期路径 即年/月/日 如2018/08/08
4. 日期路径 即年/月/日 如20180808
5. 日期型字符串转化为日期 格式
6. 获取服务器启动时间
7. 计算两个时间差
8. 两个日期相差年或者月 1 ：年 ， 2 ：月
9. 日期相加（日期+年）
10.日期相加（日期+月）
11.特定天数
12.时间段是否重叠
13.秒转成时分秒
14.LocalDate转Date
15. 获取某区间段内的所有日期
16. 获取该月的第一天
17. 获取该月的最后一天
18.获取时间段内的月份
19.获取两个时间相差秒数
20.字符串 转 日期
21.判断时间是否在时间段内
22.生成指定年的每一天
23.判断是否是今年
24.获取本周第一天和最后一天
25.获取今天时间开始和结束
26.获取本月时间开始和结束
27.获取指定日期 几天前的时间
28.获取指定日期的0点和24点
29.获取30天以前的时间
30.根据年月获取对应的月份天数

package com.ngs.common.utils;

import java.lang.management.ManagementFactory;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang3.time.DateFormatUtils;

/**
 * 时间工具类
 * @author Wik6
 */
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
    public static String YYYY = "yyyy";

    public static String YYYY_MM = "yyyy-MM";

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

    public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

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

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

    /**
     * 获取当前Date型日期
     *
     * @return Date() 当前日期
     */
    public static Date getNowDate() {
        return new Date();
    }

    /**
     * 获取当前日期, 默认格式为yyyy-MM-dd
     *
     * @return String
     */
    public static String getDate() {
        return dateTimeNow(YYYY_MM_DD);
    }

    public static final String getTime() {
        return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
    }

    public static final String dateTimeNow() {
        return dateTimeNow(YYYYMMDDHHMMSS);
    }

    public static final String dateTimeNow(final String format) {
        return parseDateToStr(format, new Date());
    }

    public static final String dateTime(final Date date) {
        return parseDateToStr(YYYY_MM_DD, date);
    }

    public static final String parseDateToStr(final String format, final Date date) {
        return new SimpleDateFormat(format).format(date);
    }

    public static final Date dateTime(final String format, final String ts) {
        try {
            return new SimpleDateFormat(format).parse(ts);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 日期路径 即年/月/日 如2018/08/08
     */
    public static final String datePath() {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyy/MM/dd");
    }

    /**
     * 日期路径 即年/月/日 如20180808
     */
    public static final String dateTime() {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyyMMdd");
    }

    /**
     * 日期型字符串转化为日期 格式
     */
    public static Date parseDate(Object str) {
        if (str == null) {
            return null;
        }
        try {
            return parseDate(str.toString(), parsePatterns);
        } catch (ParseException e) {
            return null;
        }
    }

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

    /**
     * 计算两个时间差
     */
    public static String getDatePoor(Date endDate, Date nowDate) {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时" + min + "分钟";
    }
    
 //两个日期相差年或者月 1 ：年 ， 2 ：月
    public static int getMonthNum(String date1, String date2, int type) throws java.text.ParseException {
        int result = 0;
        SimpleDateFormat sdf = new SimpleDateFormat(type == 1 ? "yyyy" : "yyyy-MM");

        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();

        c1.setTime(sdf.parse(date1));
        c2.setTime(sdf.parse(date2));

        if (type == 1) {
            result = c2.get(Calendar.YEAR) - c1.get(Calendar.YEAR);
            System.out.println("日期：" + date1 + "|" + date2 + "|,相差" + Math.abs(result) + "年");
            return result;
        } else {
            result = c2.get(Calendar.MONTH) - c1.get(Calendar.MONTH);
            int month = (c2.get(Calendar.YEAR) - c1.get(Calendar.YEAR)) * 12;
            log.info("|到期时间：" + date2 + "减去现在日期：" + date1 + "|,剩余" + (month + result) + "个月");
            return  month + result;
        }
    }
 //日期相加（日期+年）
    public String addDate(String date, int year) throws ParseException {
        //格式化日期的对象(转化成习惯的时间格式)
        SimpleDateFormat sdFormat = new SimpleDateFormat("yyyy-MM-dd");
        //静态方法getInstance()使用默认时区和语言环境获得一个日历。
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(sdFormat.parse(date));
        calendar.add(Calendar.YEAR, year);
        String format = sdFormat.format(calendar.getTime());

        return format;
    }
    //日期相加（日期+月）
    public String addDate(String date, int mouth) throws ParseException {
        //格式化日期的对象(转化成习惯的时间格式)
        SimpleDateFormat sdFormat = new SimpleDateFormat("yyyy-MM-dd");
        //静态方法getInstance()使用默认时区和语言环境获得一个日历。
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(sdFormat.parse(date));
        calendar.add(Calendar.MOUTH, mouth);
        String format = sdFormat.format(calendar.getTime());
        return format;
    }





    /**
     * 特定天数
     *
     * @throws Exception
     */
    public static long getDays(String str, String endt) throws Exception {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date strD = simpleDateFormat.parse(str);
        Date endtD = simpleDateFormat.parse(endt);
        long day = endtD.getTime() - strD.getTime();
        long l = day / (24 * 3600 * 1000);
        return l;
    }


    //时间段是否重叠
    public static boolean isOverlap(List<Date> startList, List<Date> endList) throws ParseException {
        //造3个时间段数据
        List<Timestamp> periodStart = new ArrayList<Timestamp>();
        List<Timestamp> periodend = new ArrayList<Timestamp>();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //开始时间放到一个数组
        startList.stream().forEach(x -> {
            periodStart.add(new Timestamp(x.getTime()));
        });
        //结束时间放到一个数组
        endList.stream().forEach(x -> {
            periodend.add(new Timestamp(x.getTime()));
        });
        /**
         * 两两循环比较
         * 这里的3代表有三组数据，先写死
         */
        for (int i = 0; i < periodStart.size() - 1; i++) {
            Timestamp start0 = periodStart.get(i);
            Timestamp end0 = periodend.get(i);
            for (int j = i + 1; j < periodStart.size(); j++) {
                Timestamp start = periodStart.get(j);
                Timestamp end = periodend.get(j);
                if (start0.compareTo(end) >= 0 || end0.compareTo(start) <= 0) {
                    /**
                     * 说明不重复。
                     * 思路：该时间段的开始时间如何大于另个一个时间段的结束时间，那么这个两个时间段不会有重叠；
                     * 如果该时间段的结束时间小于另一个时间段的时间，那么这个两个时间段也不会有重叠。
                     */
                    continue;
                } else {
                    //说明该时间段重复
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * 秒转成时分秒
     *
     * @param second 秒数
     * @return 时分秒
     */
    public static String getFormatTime(Long second) {
        if (second != null) {
            String num0 = NumFormat(0);
            if (second < 60) {//秒
                return num0 + ":" + num0 + ":" + NumFormat(second);
            }
            if (second < 3600) {//分
                return num0 + ":" + NumFormat(second / 60) + ":" + NumFormat(second % 60);
            }
            if (second < 3600 * 24) {//时
                return NumFormat(second / 60 / 60) + ":" + NumFormat(second / 60 % 60) + ":" + NumFormat(second % 60);
            }
            if (second >= 3600 * 24) {//天
                return NumFormat(second / 60 / 60 / 24) + "天" + NumFormat(second / 60 / 60 % 24) + ":" + NumFormat(second / 60 % 60) + ":" + NumFormat(second % 60);
            }
        }
        return "--";
    }


    /**
     * LocalDate转Date
     *
     * @param localDate localDate
     * @return Date
     */
    public static Date LocalDate2Date(LocalDate localDate) {
        ZonedDateTime zonedDateTime = localDate.atStartOfDay(ZoneId.systemDefault());
        return Date.from(zonedDateTime.toInstant());
    }

    /**
     * 获取某区间段内的所有日期
     *
     * @param startTime 2020-09-9
     * @param endTime   2020-09-11
     * @return 2020-09-9 2020-09-10 2020-09-11
     */
    public static List<String> findDates(Date startTime, Date endTime) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        List<String> result = new ArrayList<>();
        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(startTime);
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calEnd.setTime(endTime);
        // 此日期是否在指定日期之后
        while (endTime.after(calBegin.getTime())) {
            result.add(sdf.format(calBegin.getTime()));
            calBegin.add(Calendar.DAY_OF_MONTH, 1);
        }
        result.add(sdf.format(calEnd.getTime()));
        return result;
    }

    /**
     * 获取该月的第一天
     *
     * @param year  年
     * @param month 月
     * @return
     */
    public static Date getFirstDay(int year, int month) {
        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR, year);
        // 设置月份，因为月份从0开始，所以用month - 1
        c.set(Calendar.MONTH, month - 1);
        c.set(Calendar.DAY_OF_MONTH, 1);
        Date time = c.getTime();
        SimpleDateFormat slf = new SimpleDateFormat("yyyy-MM-dd");
        String format = slf.format(time);
        try {
            return slf.parse(format);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取该月的最后一天
     */
    public static Date getLastDay ( int year, int month){
        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR, year);
        // 设置月份，因为月份从0开始，所以用month - 1
        c.set(Calendar.MONTH, month - 1);
        // 获取当前时间下，该月的最大日期的数字
        int lastDay = c.getActualMaximum(Calendar.DAY_OF_MONTH);
        // 将获取的最大日期数设置为Calendar实例的日期数
        c.set(Calendar.DAY_OF_MONTH, lastDay);
        Date time = c.getTime();
        SimpleDateFormat slf = new SimpleDateFormat("yyyy-MM-dd");
        String format = slf.format(time);
        try {
            return slf.parse(format);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取时间段内的月份
     */
    public static List<String> getMonthBetween(String minDate, String maxDate){
        ArrayList<String> result = new ArrayList<>();
        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 (ParseException e) {
            e.printStackTrace();
        }

        return result;
    }
    

    /*
    * 获取两个时间相差秒数
    *
    * */
    public  static long getTimeDelta(Date startDate,Date endDate) {
        long a = endDate.getTime();
        long b = startDate.getTime();
        long c =((a - b) / 1000);
        return c;
    }

    // 字符串 转 日期
    public static Date strToDate(String str) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = sdf.parse(str);
        } catch (ParseException e) {
        }
        return date;
    }


    /**
     * 判断时间是否在时间段内
     *
     * @param nowTime
     * @param beginTime
     * @param endTime
     * @return
     */
    public static boolean belongCalendar(Date nowTime, Date beginTime, Date endTime) {
        Calendar date = Calendar.getInstance();
        date.setTime(nowTime);
        Calendar begin = Calendar.getInstance();
        begin.setTime(beginTime);
        Calendar end = Calendar.getInstance();
        end.setTime(endTime);
        if (date.after(begin) && date.before(end)) {
            return true;
        } else if (nowTime.compareTo(beginTime) == 0 ) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 生成指定年的每一天
     * @param year
     * @return
     */
    public static List<String> getDaysByYear(int year){
        Calendar c=Calendar.getInstance();
        List<String> dates=new ArrayList<String>();
        for(int i=0;i<12;i++){
            c.set(year,i,1);
            int lastDay=c.getActualMaximum(Calendar.DATE);
            for(int j=1;j<=lastDay;j++){
                String month="";
                String day="";
                if(i<9) month="-0"+(i+1);
                else month="-"+(i+1);
                if(j<10) day="-0"+j;
                else day="-"+j;
                String date=year+month+day;
                dates.add(date);
            }
        }
        return dates;
    }
    //判断是否是今年
    public static boolean isNowYear(int year){
        Calendar date = Calendar.getInstance();
        String years = String.valueOf(date.get(Calendar.YEAR));
        return years.equals(year + "");
    }
    
        public static String beforeDate(int day) {
        Calendar now = Calendar.getInstance();
        now.add(Calendar.DAY_OF_MONTH, -day);
        String endDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(now.getTime());
        return endDate;
    }
    private static String NumFormat(long sec) {
        if (String.valueOf(sec).length() < 2) {
            return "0" + sec;
        } else {
            return String.valueOf(sec);
        }
    }
    //获取今年后两位
    private static String yearLast() {
        String yearLast = new SimpleDateFormat("yy", Locale.CHINESE).format(Calendar.getInstance().getTime());
        return yearLast;
    }
        public static String mixTimeStr(String endTime) {
        Calendar rCalendar = Calendar.getInstance();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = null;
        try {
            date = simpleDateFormat.parse(endTime);
        } catch (Exception e) {
            e.printStackTrace();
        }
        rCalendar.setTime(date);//里面的date换成自己的时间字段
        rCalendar.add(Calendar.HOUR, 23);
        rCalendar.add(Calendar.MINUTE, 59);
        rCalendar.add(Calendar.SECOND, 59);
        return simpleDateFormat.format(rCalendar.getTime());
    }
 /**
     * 获取本周的第一天
     * @return String
     * **/
    public static String getWeekStart(){
        Calendar cal=Calendar.getInstance();
        cal.add(Calendar.WEEK_OF_MONTH, 0);
        cal.set(Calendar.DAY_OF_WEEK, 2);
        Date time=cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time)+" 00:00:00";
    }
    /**
     * 获取本周的最后一天
     * @return String
     * **/
    public static String getWeekEnd(){
        Calendar cal=Calendar.getInstance();
        cal.set(Calendar.DAY_OF_WEEK, cal.getActualMaximum(Calendar.DAY_OF_WEEK));
        cal.add(Calendar.DAY_OF_WEEK, 1);
        Date time=cal.getTime();
        return new SimpleDateFormat("yyyy-MM-dd").format(time)+" 23:59:59";
    }
 //获取今天 00.00
    public static Date getStartTime() {
        Calendar todayStart = Calendar.getInstance();
        todayStart.set(Calendar.HOUR, 0);
        todayStart.set(Calendar.MINUTE, 0);
        todayStart.set(Calendar.SECOND, 0);
        todayStart.set(Calendar.MILLISECOND, 0);
        return todayStart.getTime();
    }

    //获取今天 23.59
    public static Date getEndTime() {
        Calendar todayEnd = Calendar.getInstance();
        todayEnd.set(Calendar.HOUR, 23);
        todayEnd.set(Calendar.MINUTE, 59);
        todayEnd.set(Calendar.SECOND, 59);
        todayEnd.set(Calendar.MILLISECOND, 999);
        return todayEnd.getTime();
    }

    // 获得本月第一天0点时间
    public static Date getTimesMonthmorning() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(Calendar.DAY_OF_MONTH));
        return cal.getTime();
    }

    // 获得本月最后一天24点时间
    public static Date getTimesMonthnight() {
        Calendar cal = Calendar.getInstance();
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONDAY), cal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 24);
        return cal.getTime();
    }
//获取指定日期  几天前的时间
    public Date getDateAfter(Date d, int day) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Calendar now = Calendar.getInstance();
        now.setTime(d);
        now.set(Calendar.DATE, now.get(Calendar.DATE) - day);//+后 -前
        return now.getTime();
    }
     // 返回时间格式如：2020-02-17 00:00:00
    public static String getStartOfDay(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());
    }
    // 返回时间格式如：2020-02-19 23:59:59
    public static String getEndOfDay(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());
    }
    // 获取30天以前的时间
    public static String getThirtyDaysAgo(Date time) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        calendar.add(calendar.DATE, -30);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(calendar.getTime());
    }

/**

* 根据年 月 获取对应的月份 天数

*/

public static int getDaysByYearMonth(int year, int month) {
Calendar a = Calendar.getInstance();

a.set(Calendar.YEAR, year);

a.set(Calendar.MONTH, month - 1);

a.set(Calendar.DATE, 1);

a.roll(Calendar.DATE, -1);

int maxDate = a.get(Calendar.DATE);

return maxDate;

}

    



}