时间工具类 DateUtils

package com.yfcl.common.core.utils;

import java.lang.management.ManagementFactory;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.*;

import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.springframework.util.CollectionUtils;

/**
 * 时间工具类
 *
 * @author yfcl
 */
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";
    public static String YMDHMS = "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"};

    public static final String START_TIME = "startTime";
    public static final String END_TIME = "endTime";

    /**
     * 获取当前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 getChangeTime(Date date)
    {
        return dateTimeStr(date,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 dateTimeStr(Date date, final String format)
    {
        return parseDateToStr(format, 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 + "分钟";
    }

    /**
     * 增加 LocalDateTime ==> Date
     */
    public static Date toDate(LocalDateTime temporalAccessor)
    {
        ZonedDateTime zdt = temporalAccessor.atZone(ZoneId.systemDefault());
        return Date.from(zdt.toInstant());
    }

    /**
     * 增加 LocalDate ==> Date
     */
    public static Date toDate(LocalDate temporalAccessor)
    {
        LocalDateTime localDateTime = LocalDateTime.of(temporalAccessor, LocalTime.of(0, 0, 0));
        ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
        return Date.from(zdt.toInstant());
    }

    /**
     * 获取两个日期相差的月数
     */
    public static int getMonthDiff(Date d1, Date d2) {
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        c1.setTime(d1);
        c2.setTime(d2);
        int year1 = c1.get(Calendar.YEAR);
        int year2 = c2.get(Calendar.YEAR);
        int month1 = c1.get(Calendar.MONTH);
        int month2 = c2.get(Calendar.MONTH);
        int day1 = c1.get(Calendar.DAY_OF_MONTH);
        int day2 = c2.get(Calendar.DAY_OF_MONTH);
        // 获取年的差值?
        int yearInterval = year1 - year2;
        // 如果 d1的 月-日 小于 d2的 月-日 那么 yearInterval-- 这样就得到了相差的年数
        if (month1 < month2 || month1 == month2 && day1 < day2) {
            yearInterval--;
        }
        // 获取月数差值
        int monthInterval = (month1 + 12) - month2;
        if (day1 < day2) {
            monthInterval--;
        }
        monthInterval %= 12;
        int monthsDiff = Math.abs(yearInterval * 12 + monthInterval);
        return monthsDiff;
    }
    /**
     * 比较两个日期的大小 d1>d2=1 d1<d2=-1 d1=d2=0
     */
    public static int compareDate(Date d1, Date d2) {
        try {
            if (d1.getTime() > d2.getTime()) {
                return 1;
            } else if (d1.getTime() < d2.getTime()) {
                return -1;
            } else {
                return 0;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return 0;
    }

    /**
     * 获取当年的第一天
     * @param
     * @return
     */
    public static Date getCurrYearFirst(){
        Calendar currCal=Calendar.getInstance();
        int currentYear = currCal.get(Calendar.YEAR);
        return getYearFirst(currentYear);
    }

    /**
     * 获取当年的最后一天
     * @param
     * @return
     */
    public static Date getCurrYearLast(){
        Calendar currCal=Calendar.getInstance();
        int currentYear = currCal.get(Calendar.YEAR);
        return getYearLast(currentYear);
    }

    /**
     * 获取某年第一天日期
     * @param year 年份
     * @return Date
     */
    public static Date getYearFirst(int year){
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        Date currYearFirst = calendar.getTime();
        String nowTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(currYearFirst);
        return currYearFirst;
    }

    /**
     * 获取某年最后一天日期
     * @param year 年份
     * @return Date
     */
    public static Date getYearLast(int year){
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        calendar.roll(Calendar.DAY_OF_YEAR, -1);
        return calendar.getTime();
    }

    /**
     * 获取指定日期的当月第一天
     *
     * @return String
     */
    public static String getFirstDayOfMonth(Date date) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Calendar firstDay = Calendar.getInstance();
        firstDay.setTime(date);
        firstDay.set(Calendar.DAY_OF_MONTH, 1);
        firstDay.set(Calendar.HOUR_OF_DAY, 0);
        firstDay.set(Calendar.MINUTE, 0);
        return simpleDateFormat.format(firstDay.getTime());
    }

    /**
     * 获取指定日期的当月第一天
     *
     * @return String
     */
    public static Date getFirstDayOfMonthReturnDate(Date date) {
        Calendar firstDay = Calendar.getInstance();
        firstDay.setTime(date);
        firstDay.set(Calendar.DAY_OF_MONTH, 1);
        firstDay.set(Calendar.HOUR_OF_DAY, 0);
        firstDay.set(Calendar.MINUTE, 0);
        return firstDay.getTime();
    }

    public static int getYear(Date date){
        int year = Integer.parseInt(String.format("%tY",date));
        return year;
    }

    public static int getMonth(Date date){
        int month = Integer.parseInt(String.format("%tm",date));
        return month;
    }

    /**
     * 获取某年某周的时间跨度
     *
     * @param year 年份
     * @param week 周数
     * @return k-v
     */
    public static Map<String, String> getWeekRangeMap(int year, int week) {
        Map<String, String> dateMap = new HashMap<>(8);
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        // 设置星期一为一周开始的第一天
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        // 设置了第一周的最小天数
        calendar.setMinimalDaysInFirstWeek(7);
        // 获得当前的年
        int weekYear = calendar.get(Calendar.YEAR);
        // 获得指定年的第几周的开始日期(星期几)
        calendar.setWeekDate(weekYear, week, Calendar.MONDAY);
        Date time = calendar.getTime();
        String startTime = new SimpleDateFormat(DateUtils.YYYY_MM_DD).format(time);
        dateMap.put(START_TIME, startTime);
        // 获得指定年的第几周的结束日期(星期几)
        calendar.setWeekDate(weekYear, week, Calendar.SUNDAY);
        time = calendar.getTime();
        String endTime = new SimpleDateFormat(DateUtils.YYYY_MM_DD).format(time);
        dateMap.put(END_TIME, endTime);
        return dateMap;
    }

    /**
     * 获取某年有多少周
     *
     * @param year 年份
     * @return 当前年份的总周数
     */
    public static int getYearWeekCount(int year) {
        int week = 52;
        try {
            Map<String, String> timeMap = getWeekRangeMap(year, 53);
            if (!CollectionUtils.isEmpty(timeMap)) {
                String startTime = timeMap.get(START_TIME);
                if (startTime.substring(0, 4).equals(year + "")) {
                    // 判断年度是否相符，如果相符说明有53个周。
                    week = 53;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return week;
    }

    /**
     * 获取某年所有周的日期跨度
     *
     * @param year 年份
     * @return list 当前年份所有周的日期范围
     */
    public static List<Map<String, String>> getYearWeekMap(int year) {
        int weeks = getYearWeekCount(year);
        List<Map<String, String>> yearWeekMap = new ArrayList<>();
        //当年的第一周不是从1月1号开始的需插入一个非完整周
        Map<String, String> firstDateMap = getWeekRangeMap(year, 1);
        //获取第一周开始的第一天不是一号
        if (!firstDateMap.get(START_TIME).substring(8,10).equals("01")) {
            //插入一个非完成周期
            Map<String, String> firstDateRealMap = new HashMap<>();
            firstDateRealMap.put(START_TIME,year + "-01-01");
            firstDateRealMap.put(END_TIME,getYesterdayDate(dateTime(YYYY_MM_DD,firstDateMap.get(START_TIME))));
            yearWeekMap.add(firstDateRealMap);
        }
        for (int i = 1; i <= weeks; i++) {
            Map<String, String> dateMap = getWeekRangeMap(year, i);
            //最后一周endTime取当年的最后一天
            if (i == weeks) {
                dateMap.put(END_TIME,year + "-12-31");
            }
            yearWeekMap.add(dateMap);
        }
        return yearWeekMap;
    }

    /**
     * 获取指定日期的昨天
     *
     * @param date 日期
     * @return yyyy-MM-dd
     */
    public static String getYesterdayDate(Date date){
        SimpleDateFormat format =new SimpleDateFormat("yyyy-MM-dd");
        Calendar cale = Calendar.getInstance();
        cale.setTime(date);
        cale.add(Calendar.DATE,-1);
        String yesterday = format.format(cale.getTime());
        return yesterday;
    }
    /**
     * 2个日期相隔多少天,不包含最后一天
     *
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return days
     */
    public static int calculateDaysInterval(Date startDate,Date endDate){
        long startTime = startDate.getTime();
        long endTime = endDate.getTime();
        int days = (int) ((endTime - startTime) / (1000 * 60 * 60 * 24));
        return days;
    }

    /**
     * 2个日期相差多少分钟
     *
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return days
     */
    public static int calculateMinuteInterval(Date startDate,Date endDate){
        long startTime = startDate.getTime();
        long endTime = endDate.getTime();
        int minute = (int) ((endTime - startTime) / (1000 * 60));
        return minute;
    }
    /**
     * 2个日期相隔多少天,不包含最后一天
     *
     * @param date 开始日期
     * @param day 添加天数
     * @return Date
     */
    public static Date addDate(Date date,long day) {
        long time = date.getTime(); // 得到指定日期的毫秒数
        day = day*24*60*60*1000; // 要加上的天数转换成毫秒数
        time+=day; // 相加得到新的毫秒数
        return new Date(time); // 将毫秒数转换成日期
    }

    /**
     *  获取两个日期之间的所有日期 (年月日)
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public static List<String> getBetweenDate(String startTime, String endTime){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 声明保存日期集合
        List<String> list = new ArrayList<String>();
        try {
            // 转化成日期类型
            Date startDate = sdf.parse(startTime);
            Date endDate = sdf.parse(endTime);

            //用Calendar 进行日期比较判断
            Calendar calendar = Calendar.getInstance();
            while (startDate.getTime()<=endDate.getTime()){
                // 把日期添加到集合
                list.add(sdf.format(startDate));
                // 设置日期
                calendar.setTime(startDate);
                //把日期增加一天
                calendar.add(Calendar.DATE, 1);
                // 获取增加后的日期
                startDate=calendar.getTime();
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     *  获取两个日期之间的所有日期 (年月日)
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static List<String> getBetweenDate2(Date startDate, Date endDate){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 声明保存日期集合
        List<String> list = new ArrayList<String>();
        //用Calendar 进行日期比较判断
        Calendar calendar = Calendar.getInstance();
        while (startDate.getTime()<=endDate.getTime()){
            // 把日期添加到集合
            list.add(sdf.format(startDate));
            // 设置日期
            calendar.setTime(startDate);
            //把日期增加一天
            calendar.add(Calendar.DATE, 1);
            // 获取增加后的日期
            startDate=calendar.getTime();
        }
        return list;
    }

    /**
     *  给定日期增加一天
     * @param date
     * @return
     */
    public static Date dateAddOne(Date date) {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.add(calendar.DATE, 1); //把日期往后增加一天,整数  往后推,负数往前移动
        date = calendar.getTime(); //这个时间就是日期往后推一天的结果
        return date;
    }

    /**
     *  当前日期往前推num周
     * @param num
     * @return
     */
    public static List<Map<String, String>> getWeekPushForward(int num) {
        List<Map<String, String>> returnList = new ArrayList<>();
        Date nowDate = getNowDate();
        int year = getYear(nowDate);
        List<Map<String, String>> list = getYearWeekMap(year);
        boolean flag = false;
        for (int i = list.size()-1; i >=0; i--) {
            Map<String, String> map = list.get(i);
            if (flag && returnList.size() < num) {
                fillMap(returnList,map,year+"-"+(i+1));
            }
            if (nowDate.compareTo(dateTime(YYYY_MM_DD,map.get(END_TIME))) <=0 && nowDate.compareTo(dateTime(YYYY_MM_DD,map.get(START_TIME))) >=0) {
                fillMap(returnList,map,year+"-"+(i+1));
                flag = true;
            }
        }
        int count = 1;
        a:while (returnList.size() < num) {
            List<Map<String, String>> listPrev = getYearWeekMap(year-count);
            for (int i = listPrev.size()-1; i >=0; i--) {
                Map<String, String> map = listPrev.get(i);
                fillMap(returnList,map,(year-count)+"-"+(i+1));
                if (returnList.size() == num) {
                    break a;
                }
            }
            count++;
        }
        Collections.reverse(returnList);
        return returnList;
    }

    private static void fillMap(List<Map<String, String>> returnList,Map<String, String> map,String weekNum){
        Map<String, String> returnMap = new HashMap<>();
        returnMap.put(START_TIME,map.get(START_TIME));
        returnMap.put(END_TIME,map.get(END_TIME));
        returnMap.put("weekNum",weekNum);
        returnList.add(returnMap);
    }

    public static void main(String[] args) throws ParseException {
//        System.out.println(getSysMonthBeforeCnt(12));
//        String num = RandomStringUtils.random(3, false, true);
        //比较日期大小
//        Date d1 = new Date();
//        System.out.println(d1);
//        Date d2 = parseDate("2022-12-31");
//        System.out.println(d2);
//        System.out.println(compareDate(d1,d2));
        //计算两个日期相差月份
//        Date d1 = parseDate("2022-12-31");
//        System.out.println(d1);
//        Date d2 = parseDate("2022-12-31");
//        System.out.println(d2);
//        System.out.println(getMonthDiff(d1,d2));
        //获取当年的最后一天
//        System.out.println(getCurrYearLast());
        //获取指定日期的当月第一天
//        System.out.println(getFirstDayOfMonthReturnDate(parseDate("2022-12-31")));

//        System.out.println(getMonth(new Date()));
//        List<Map<String, String>> list = getYearWeekMap(2022);
//        for (int i = 0; i < list.size(); i++) {
//            System.out.println((i+1)+"--" + list.get(i));
//        }
//        List<Map<String, String>> list = getWeekPushForward(30);
//        for (int i = 0; i < list.size(); i++) {
//            System.out.println(list.get(i));
//        }


//        System.out.println("2023--" + getYearWeekMap(2023));
//        System.out.println("2024--" + getYearWeekMap(2024));
//        System.out.println("2025--" + getYearWeekMap(2025));
//
//        System.out.println("2022-01-03".substring(5,7));
//        System.out.println("2022-01-03".substring(8,10));

//        DateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd");
//        Date startDate = simpleFormat.parse("2022-05-10");
//        Date endDate = simpleFormat.parse("2022-05-14");
//        System.out.println(calculateDaysInterval(startDate,endDate));

//        DateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd");
//        Date startDate = simpleFormat.parse("2022-05-10");
//        System.out.println(addDate(startDate,0));
//        System.out.println(addDays(startDate,0));

//        System.out.println(getBetweenDate("2022-05-10","2022-05-10"));

//        DateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd");
//        Date startDate = simpleFormat.parse("2022-05-10");
//        System.out.println(addDate(startDate,0));
//        System.out.println(addDays(startDate,0));
//        System.out.println(getSysMonthBeforeCnt(12));
        System.out.println(dateToWeek(new Date()));
    }

    public static final String getBatchCode(String beginStr)
    {
       String codeStr = beginStr + dateTimeNow(YYYYMMDDHHMMSS) + RandomStringUtils.random(3, false, true);
        return codeStr;
    }

    /**
     * 通过当前日期获取当前日期所在周的开始和结束
     * @return
     */
    public static List<String> getWeeekDate(Date ymd){
        // 定义返回的list
        List<String> dateList = null;
        // 获取年的所有周的开始日期和结束日期
        List<Map<String, String>> dwList = getYearWeekMap(getYear(ymd));
        // 遍历所有的周
        for(int i = 0; i < dwList.size(); i++){
            // 当所传参数日期正好在周的范围内
            if(compareDate(ymd,parseDate(dwList.get(i).get(START_TIME))) >= 0 && compareDate(ymd,parseDate(dwList.get(i).get(END_TIME))) <= 0){
                dateList = getBetweenDate(dwList.get(i).get(START_TIME),dwList.get(i).get(END_TIME));
                break;
            }
        }
        return dateList;
    }

    /**
     * 通过当前日期获取当前日期所在周
     * @return
     */
    public static int getWeeek(Date ymd){
        // 定义返回的list
        int weekNum = 0;
        // 获取年的所有周的开始日期和结束日期
        List<Map<String, String>> dwList = getYearWeekMap(getYear(ymd));
        // 遍历所有的周
        for(int i = 0; i < dwList.size(); i++){
            weekNum = weekNum + 1;
            // 当所传参数日期正好在周的范围内
            if(compareDate(ymd,parseDate(dwList.get(i).get(START_TIME))) >= 0 && compareDate(ymd,parseDate(dwList.get(i).get(END_TIME))) <= 0){
                break;
            }
        }
        return weekNum;
    }

    /**
     * 通过当前日期的年月获取之前的前几个月(包含当月)
     * @return
     */
    public static List<String> getSysMonthBeforeCnt(int count){
        List<String> dateList = new ArrayList<String>();
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) + 2);
        String strMonth = "";
        String strYear = "";
        for(int i =0 ; i < count; i++){
            calendar.set(Calendar.MONTH,calendar.get(Calendar.MONTH) - 1);
            strYear = String.valueOf(calendar.get(Calendar.YEAR));
            if(String.valueOf(calendar.get(Calendar.MONTH)).length() == 1 ){
                if("0".equals(String.valueOf(calendar.get(Calendar.MONTH)))){
                    strYear = String.valueOf(Integer.valueOf(strYear) - 1);
                    strMonth = "12";
                }else{
                    strMonth = "0" + String.valueOf(calendar.get(Calendar.MONTH));
                }
            }else{
                strMonth = String.valueOf(calendar.get(Calendar.MONTH));
            }
            dateList.add(strYear+"-"+strMonth);
        }
        // 将存的list数据倒序
        Collections.reverse(dateList);
        return dateList;
    }

    // 当前月份向前推12个月
    public static List<String> getSysMonthBeforeMonth(){
        List<String> dateList = new ArrayList<String>();
        String[] last12Months = new String[12];
        Calendar cal = Calendar.getInstance();
        //如果当前日期大于二月份的天数28天或者29天会导致计算月份错误，会多出一个三月份，故设置一个靠前日期解决此问题
        cal.set(Calendar.DAY_OF_MONTH, 1);
        for (int i = 0; i < 12; i++) {
            if((cal.get(Calendar.MONTH) + 1) < 10){
                last12Months[11 - i] = cal.get(Calendar.YEAR) + "-0" + (cal.get(Calendar.MONTH) + 1);
            }else{
                last12Months[11 - i] = cal.get(Calendar.YEAR) + "-" + (cal.get(Calendar.MONTH) + 1);
            }

            cal.set(Calendar.MONTH, cal.get(Calendar.MONTH) - 1); //逐次往前推1个月
        }
        for (int i = 0; i < last12Months.length; i++) {
            dateList.add(last12Months[i]);
        }
        return dateList;
    }

    /**
     * 获取过去或者未来 任意天内的日期数组
     * @param intervals      intervals天内
     * @return              日期数组
     */
    public static ArrayList<String> getFdays(int intervals ) {
        ArrayList<String> pastDaysList = new ArrayList<>();
        ArrayList<String> fetureDaysList = new ArrayList<>();
        for (int i = 0; i <intervals; i++) {
            pastDaysList.add(getPastDate(i));
            fetureDaysList.add(getFetureDate(i));
        }
        return pastDaysList;
    }

    /**
     * 获取过去第几天的日期
     *
     * @param past
     * @return
     */
    public static String getPastDate(int past) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - past);
        Date today = calendar.getTime();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String result = format.format(today);
        return result;
    }

    /**
     * 获取未来 第 past 天的日期
     * @param past
     * @return
     */
    public static String getFetureDate(int past) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + past);
        Date today = calendar.getTime();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String result = format.format(today);
        return result;
    }


    /**
     *  给定日期计算前多少天或者后多少天
     * @param date
     * @return
     */
    public static Date dateCompute(Date date, int num) {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.add(calendar.DATE, num); //把日期往后增加一天,整数  往后推,负数往前移动
        date = calendar.getTime(); //这个时间就是日期往后推一天的结果
        return date;
    }

    /**
     *  通过某个日期获取是周几
     * @param date
     * @return
     */
    public static String dateCompute(Date date) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("EEEE");
        String currSun = dateFormat.format(date);
        return currSun;
    }

    /**
     *  通过某个日期获取是周几
     * @param date
     * @return
     */
    public static int dateToWeek(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        //因为数组下标从0开始，而返回的是数组的内容，是数组{1,2,3,4,5,6,7}中用1~7来表示，所以要减1
        int week = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (week == 0) {
            week = 7;
        }
        return week;
    }

    public static int getDaysFromYearAndMonth(int year,int month){
        // 获取日历对象
        Calendar c = Calendar.getInstance();
        // 设置日历对象为指定年月日，为指定月份的第一天
        c.set(year, month, 1);
        // 设置日历对象，指定月份往前推一天，也就是最后一天
        c.add(Calendar.DATE, -1);
        // 获取这一天输出即可
        return c.get(Calendar.DATE);
    }
}