wisdomisite-java/src/main/java/com/zhgd/xmgl/util/DateUtils.java

package com.zhgd.xmgl.util;


import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.*;


/**
 * @program: wisdomSite
 * @description: 日期格式
 * @author: Mr.Peng
 * @create: 2020-12-15 17:05
 **/
public class DateUtils {

    /**
     * 时间格式化
     *
     * @param oldDate
     * @return
     */
    public static String dealDateFormat(String oldDate) {
        Date date1 = null;
        SimpleDateFormat df2 = null;
        try {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
            Date date = df.parse(oldDate);
            Calendar beijingcal = Calendar.getInstance();
            beijingcal.setTime(date);
            //SimpleDateFormat df1 = new SimpleDateFormat ("EEE MMM dd HH:mm:ss Z yyyy", Locale.UK);
            //date1 = df1.parse(date.toString());
            beijingcal.set(Calendar.HOUR, beijingcal.get(Calendar.HOUR) + 8);
            date1 = beijingcal.getTime();
            df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return df2.format(date1);
    }

    public static String parseDateFormat(String oldDate) {
        Date date = null;
        SimpleDateFormat df2 = null;
        try {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
            date = df.parse(oldDate);
            df2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        } catch (ParseException e) {

            e.printStackTrace();
        }
        return df2.format(date);
    }

    /**
     * 查询本周所有天数
     *
     * @return
     */
    public static List<String> getNowWeekAllDayList() {
        Calendar cal = Calendar.getInstance();
        // 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
        // 获得当前日期是一个星期的第几天
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // log.info("要计算日期为:" + sdf.format(cal.getTime())); // 输出要计算日期
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        return findDates(cal.getTime(), new Date());
    }


    /**
     * 查询现在时间几天前到现在之间的所有日期
     *
     * @param days
     * @return
     */
    public static List<String> getOtherDayAllDayList(int days) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE, -days);
        return findDates(cal.getTime(), new Date());
    }

    /**
     * 查询本月所有天数
     *
     * @return
     */
    public static List<String> getNowMonthAllDayList() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_MONTH, 1);
        return findDates(cal.getTime(), new Date());
    }

    /**
     * 获取两个时间段所有天数
     *
     * @param beginTime
     * @param endTime
     * @return
     */
    public static List<String> getDiffTimeDayList(String beginTime, String endTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return findDates(sdf.parse(beginTime), sdf.parse(endTime));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static List<String> findDates(Date dBegin, Date dEnd) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        List lDate = new ArrayList();
        lDate.add(sdf.format(dBegin));
        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(dBegin);
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calEnd.setTime(dEnd);
        // 测试此日期是否在指定日期之后
        while (dEnd.after(calBegin.getTime())) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            calBegin.add(Calendar.DAY_OF_MONTH, 1);
            if (calBegin.getTimeInMillis() <= dEnd.getTime()) {
                lDate.add(sdf.format(calBegin.getTime()));
            }
        }
        return lDate;
    }

    /**
     * 获取指定年份所有天数
     *
     * @param yearMonth
     * @return
     */
    public static List<String> getYearAllMonthList(String yearMonth) {
        String year = yearMonth.substring(0, 4);
        List<String> list = new ArrayList<>();
        for (int i = 1; i <= 12; i++) {
            if (i < 10) {
                list.add(year + "0" + i);
            } else {
                list.add(year + i);
            }
        }
        return list;
    }

    /**
     * @param yearMonth 月份格式yyyy-MM
     * @return
     */
    public static List<String> getMonthDayList(String yearMonth) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        //判断是否是当月
        if (yearMonth.equals(sdf.format(new Date()))) {
            return getNowMonthAllDayList();
        } else {
            return getDayListOfMonth(yearMonth);
        }
    }

    public static List<String> getDayListOfMonth(String yearMonth) {
        int year = Integer.parseInt(yearMonth.split("-")[0]);  //年
        int month = Integer.parseInt(yearMonth.split("-")[1]); //月
        Calendar endCal = Calendar.getInstance();
        // 设置年份
        endCal.set(Calendar.YEAR, year);
        // 设置月份
        endCal.set(Calendar.MONTH, month - 1);
        // 获取某月最大天数
        int lastDay = endCal.getActualMaximum(Calendar.DATE);
        // 设置日历中月份的最大天数
        endCal.set(Calendar.DAY_OF_MONTH, lastDay);

        Calendar startCal = Calendar.getInstance();
        // 设置年份
        startCal.set(Calendar.YEAR, year);
        // 设置月份
        startCal.set(Calendar.MONTH, month - 1);
        //获取某月最小天数
        int firstDay = startCal.getActualMinimum(Calendar.DAY_OF_MONTH);
        //设置日历中月份的最小天数
        startCal.set(Calendar.DAY_OF_MONTH, firstDay);
        return findDates(startCal.getTime(), endCal.getTime());
    }

    /**
     * 获取当前周第一天日期
     *
     * @return
     */
    public static String getNowWeekStartTime() {
        Calendar cal = Calendar.getInstance();
        // 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
        // 获得当前日期是一个星期的第几天
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
        if (1 == dayWeek) {
            cal.add(Calendar.DAY_OF_MONTH, -1);
        }
        // log.info("要计算日期为:" + sdf.format(cal.getTime())); // 输出要计算日期
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int day = cal.get(Calendar.DAY_OF_WEEK);
        // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(cal.getTime());
    }

    public static List<String> getDiffTimeYearList(String beginTime, String endTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return findYear(sdf.parse(beginTime), sdf.parse(endTime));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static List<String> findYear(Date dBegin, Date dEnd) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
        List lDate = new ArrayList();
        lDate.add(sdf.format(dBegin));
        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(dBegin);
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calEnd.setTime(dEnd);
        // 测试此日期是否在指定日期之后
        while (dEnd.after(calBegin.getTime())) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            calBegin.add(Calendar.YEAR, 1);
            if (calBegin.getTimeInMillis() <= dEnd.getTime()) {
                lDate.add(sdf.format(calBegin.getTime()));
            }
        }
        return lDate;
    }

    public static List<String> getDiffTimeMonthList(String beginTime, String endTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return findMonth(sdf.parse(beginTime), sdf.parse(endTime));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static List<String> findMonth(Date dBegin, Date dEnd) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        List lDate = new ArrayList();
        lDate.add(sdf.format(dBegin));
        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(dBegin);
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calEnd.setTime(dEnd);
        // 测试此日期是否在指定日期之后
        while (dEnd.after(calBegin.getTime())) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            calBegin.add(Calendar.MONTH, 1);
            if (calBegin.getTimeInMillis() <= dEnd.getTime()) {
                lDate.add(sdf.format(calBegin.getTime()));
            }
        }
        return lDate;

    }

    public static List<String> getDiffTimeWeekList(String beginTime, String endTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate startDate = LocalDate.parse(beginTime, formatter);
        LocalDate endDate = LocalDate.parse(endTime, formatter);
        List<String> lDate = new ArrayList();
        while (endDate.isAfter(startDate)) {
            String start = startDate.format(formatter);
            if (startDate.getDayOfWeek() == DayOfWeek.SUNDAY) {
                lDate.add(start + "/" + start);
            } else {
                LocalDate sunday = startDate.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
                if (sunday.isAfter(endDate)) {
                    lDate.add(start + "/" + endDate.format(formatter));
                } else {
                    lDate.add(start + "/" + sunday.format(formatter));
                }
            }
            startDate = startDate.with(TemporalAdjusters.next(DayOfWeek.SUNDAY)).plusDays(1);

        }
        return lDate;
    }

    /**
     * 获取当前时间和当天时间几天前之间的所有天数
     *
     * @param dayNum 当天时间以前具体几天
     * @return
     */
    public static List<String> getNowFewDaysAgoList(int dayNum) {
        try {
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.DATE, -dayNum);
            Date date = calendar.getTime();
            return findDates(date, new Date());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * @param type 1 今日24 小时，2本周所有天，3本月所有天
     * @return
     */
    public static List<String> getDayList(Integer type) {
        if (type == 1) {
            List<String> list = new ArrayList<>();
            for (int i = 0; i <= 23; i++) {
                list.add(i + "");
            }
            return list;
        } else if (type == 2) {
            return getDaysBetweenLastWeek();
        } else if (type == 3) {
            return getNowMonthAllDayList();
        }
        return null;
    }

    /**
     * 比较两个日期大小
     *
     * @param time1
     * @param time2
     * @return
     * @throws ParseException
     */
    public static boolean compareTime(String time1, String time2) {
        try {
            //如果想比较日期则写成"yyyy-MM-dd"就可以了
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            //将字符串形式的时间转化为Date类型的时间
            Date a = sdf.parse(time1);
            Date b = sdf.parse(time2);
            //Date类的一个方法，如果a早于b返回true，否则返回false
            //a时间下雨b时间返回true,否正返回false
            if (a.before(b)) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 查询当前时间指定天数之前的日期
     *
     * @param @param  days
     * @param @return 参数
     * @return String    返回类型
     * @throws
     * @Title: getBeginDayTime
     */
    public static String getBeginDayTime(int days) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE, -days);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(cal.getTime());
    }

    /**
     * 获取一天内的小时列表
     *
     * @return
     */
    public static List<String> getAllHourInDay() {
        return Arrays.asList("00:00", "01:00", "02:00", "03:00", "04:00", "05:00", "06:00", "07:00", "08:00", "09:00", "10:00", "11:00", "12:00", "13:00", "14:00", "15:00", "16:00", "17:00", "18:00", "19:00", "20:00", "21:00", "22:00", "23:00");
    }

    /**
     * 转成GMT时间
     *
     * @param date
     */
    public static String getGMTTime(Date date) {
        DateFormat dateFormat = new SimpleDateFormat("E, dd MMM yyyy HH:mm:ss z", Locale.ENGLISH);
        dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
        return dateFormat.format(date);
    }


    /**
     * 查询本月所有天数Fix，如：2023-06-01到2023-06-30
     *
     * @return
     */
    public static List<String> getCurrentMonthAllDayList() {
        ArrayList<String> rtList = new ArrayList<>();
        Date now = new Date();
        DateTime beginDate = DateUtil.beginOfMonth(now);
        DateTime endDate = DateUtil.endOfMonth(now);
        long offset = DateUtil.betweenDay(beginDate, endDate, true);
        for (int i = 0; i < offset + 1; i++) {
            rtList.add(DateUtil.formatDate(DateUtil.offsetDay(beginDate, i)));
        }
        return rtList;
    }

    /**
     * 查询一个月前内所有天数，如：2023-06-10到2023-07-10
     *
     * @return
     */
    public static List<String> getDaysBetweenLastMonth() {
        ArrayList<String> rtList = new ArrayList<>();
        DateTime beginDate = DateUtil.lastMonth();
        DateTime endDate = DateTime.now();
        long offset = DateUtil.betweenDay(beginDate, endDate, true);
        for (int i = 0; i < offset + 1; i++) {
            rtList.add(DateUtil.formatDate(DateUtil.offsetDay(beginDate, i)));
        }
        return rtList;
    }

    /**
     * 查询一个周前内所有天数，如：2023-06-10到2023-06-17
     *
     * @return
     */
    public static List<String> getDaysBetweenLastWeek() {
        ArrayList<String> rtList = new ArrayList<>();
        DateTime beginDate = DateUtil.lastWeek();
        DateTime endDate = DateTime.now();
        long offset = DateUtil.betweenDay(beginDate, endDate, true);
        for (int i = 0; i < offset + 1; i++) {
            rtList.add(DateUtil.formatDate(DateUtil.offsetDay(beginDate, i)));
        }
        return rtList;
    }

    /**
     * 查询15天前的所有天数，如：2023-06-10到2023-06-15
     *
     * @return
     */
    public static List<String> getDaysBetweenLastHalfMonth() {
        ArrayList<String> rtList = new ArrayList<>();
        DateTime dateTime = DateUtil.parseDate(DateUtil.today());
        for (int i = 0; i < 15; i++) {
            rtList.add(DateUtil.formatDate(DateUtil.offsetDay(dateTime, i * (-1))));
        }
        Collections.reverse(rtList);
        return rtList;
    }

    /**
     * 查询N天前的所有天数，如：2023-06-10到2023-06-15
     *
     * @return
     */
    public static List<String> getDaysBefore(int days) {
        ArrayList<String> rtList = new ArrayList<>();
        DateTime dateTime = DateUtil.parseDate(DateUtil.today());
        for (int i = 0; i < days; i++) {
            rtList.add(DateUtil.formatDate(DateUtil.offsetDay(dateTime, i * (-1))));
        }
        Collections.reverse(rtList);
        return rtList;
    }

    /**
     * 查询指定天数内所有天数列表, 返回：如：[07-30, 07-31]
     *
     * @param queryStartTime 2023-07-31
     * @param queryEndTime   2023-07-31
     * @return
     */
    public static List<String> getBetweenDays(String queryStartTime, String queryEndTime, String format) {
        ArrayList<String> rtList = new ArrayList<>();
        DateTime beginDate = DateUtil.parseDate(queryStartTime);
        DateTime endDate = DateUtil.parseDate(queryEndTime);
        long offset = DateUtil.betweenDay(beginDate, endDate, true);
        for (int i = 0; i < offset + 1; i++) {
            rtList.add(DateUtil.format(DateUtil.offsetDay(beginDate, i), format));
        }
        return rtList;
    }

    /**
     * 查询一个周前内所有天数，如：06-10到06-17
     *
     * @return
     */
    public static List<String> getDaysBetweenLastWeekWithoutYear() {
        ArrayList<String> rtList = new ArrayList<>();
        DateTime beginDate = DateUtil.lastWeek();
        DateTime endDate = DateTime.now();
        long offset = DateUtil.betweenDay(beginDate, endDate, true);
        for (int i = 0; i < offset + 1; i++) {
            rtList.add(DateUtil.format(DateUtil.offsetDay(beginDate, i), "MM-dd"));
        }
        return rtList;
    }

    /**
     * 查询一天前内所有小时
     *
     * @return
     */
    public static List<String> getHoursListLastDay() {
        ArrayList<String> rtList = new ArrayList<>();
        DateTime beginDate = DateUtil.yesterday();
        DateTime endDate = DateTime.now();
        long offset = DateUtil.between(beginDate, endDate, DateUnit.HOUR);
        for (int i = 1; i < offset + 1; i++) {
            rtList.add(DateUtil.format(DateUtil.offsetHour(beginDate, i), "HH:00"));
        }
        return rtList;
    }

    /**
     * 偏移日期str，传入2023-11-02返回2023-11-02，传入2023-11-02 00:00:00返回2023-11-02 00:00:00
     *
     * @param dayStr
     * @param offset
     * @return
     */
    public static String offsetDayStr(String dayStr, int offset) {
        if (dayStr.length() == 10) {
            return DateUtil.formatDate(DateUtil.offsetDay(DateUtil.parse(dayStr), offset));
        } else {
            return DateUtil.format(DateUtil.offsetDay(DateUtil.parse(dayStr), offset), "yyyy-MM-dd HH:mm:ss");
        }
    }

    /**
     * 获取所有日期列表
     *
     * @param type    类型：
     *                10.近12小时,20.近24小时,30.近半天,40.近一天,50.近两天,60.近一周,70.近两周,80.近一个月,90.近半年,93.近一年
     *                100.今天,200.昨天,300.本周,400.本月,500.本年（每月）,600.去年
     * @param pattern 格式 如：yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static List<String> getDateStrList(int type, String pattern) {
        if (type == 1) {

        } else if (type == 90) {
            ArrayList<String> rtList = new ArrayList<>();
            DateTime endDate = DateTime.now();
            DateTime beginDate = DateUtil.offsetMonth(endDate, -6);
            long offset = DateUtil.betweenMonth(beginDate, endDate, true);
            for (int i = 1; i < offset + 1; i++) {
                rtList.add(DateUtil.format(DateUtil.offsetMonth(beginDate, i), pattern));
            }
            return rtList;
        } else if (type == 93) {
            ArrayList<String> rtList = new ArrayList<>();
            DateTime endDate = DateTime.now();
            DateTime beginDate = DateUtil.offsetMonth(endDate, -12);
            long offset = DateUtil.betweenMonth(beginDate, endDate, true);
            for (int i = 1; i < offset + 1; i++) {
                rtList.add(DateUtil.format(DateUtil.offsetMonth(beginDate, i), pattern));
            }
            return rtList;
        } else if (type == 500) {
            ArrayList<String> rtList = new ArrayList<>();
            DateTime beginDate = DateUtil.beginOfYear(DateTime.now());
            DateTime endDate = DateUtil.endOfYear(DateTime.now());
            long offset = DateUtil.betweenMonth(beginDate, endDate, true);
            for (int i = 0; i < offset + 1; i++) {
                rtList.add(DateUtil.format(DateUtil.offsetMonth(beginDate, i), pattern));
            }
            return rtList;
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println(getDateStrList(500, "月份M"));
    }
}