日期偏移量

package 包名.路径;

import cn.hutool.core.date.*;
import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author 孙永潮
 * @date 2023/10/8
 */
@Slf4j
public class LocalDateUtil extends LocalDateTimeUtil {
    /**
     * 获取当前日期 ~ 偏移量之间的日期范围
     *
     * @param type 1:年 2：季 3:月 4:日 5:小时
     * @param num  偏移量
     * @return
     */
    public static List<String> createDateScope(Integer type, Integer num) {
        return createDateScope(new Date(), type, num, null);
    }

    /**
     * 获取起始日期 ~ 偏移量之间的日期范围
     *
     * @param now  起始日期
     * @param type 1:年 2：季 3:月 4:日 5:小时
     * @param num  偏移量
     * @return
     */
    public static List<String> createDateScope(Date now, Integer type, Integer num) {
        return createDateScope(now, type, num, null);
    }

    /**
     * 获取起始日期 ~ 偏移量之间的日期范围
     *
     * @param now    起始日期
     * @param type   1:年 2：季 3:月 4:日 5:小时
     * @param num    偏移量
     * @param format 自定义格式(季不支持)
     * @return
     */
    public static List<String> createDateScope(Date now, Integer type, Integer num, String format) {
        List<String> list = new LinkedList<>();
        switch (type) {
            case 1:
                for (int i = num - 1; i >= 0; i--) {
                    DateTime offset = DateUtil.offset(now, DateField.YEAR, -i);
                    String date = DateUtil.format(offset, StrUtil.isNotBlank(format) ? format : DatePattern.NORM_YEAR_PATTERN);
                    list.add(date);
                }
                return list;
            case 2:
                for (int i = num - 1; i >= 0; i--) {
                    DateTime offset = DateUtil.offsetMonth(now, -i * 3);
                    int quarter = DateUtil.quarter(offset);
                    String date = DateUtil.format(offset, DatePattern.NORM_YEAR_PATTERN);
                    list.add(date + "/" + quarter + "季度");
                }
                break;
            case 3:
                for (int i = num - 1; i >= 0; i--) {
                    DateTime offset = DateUtil.offsetMonth(now, -i);
                    String date = DateUtil.format(offset, StrUtil.isNotBlank(format) ? format : "yyyy/MM");
                    list.add(date);
                }
                break;
            case 4:
                for (int i = num - 1; i >= 0; i--) {
                    DateTime offset = DateUtil.offsetDay(now, -i);
                    String date = DateUtil.format(offset, StrUtil.isNotBlank(format) ? format : "MM/dd");
                    list.add(date);
                }
                break;
            case 5:
                for (int i = num - 1; i >= 0; i--) {
                    DateTime offset = DateUtil.offsetHour(now, -i);
                    String date = DateUtil.format(offset, StrUtil.isNotBlank(format) ? format : "HH");
                    list.add(date);
                }
                break;
        }
        return list;
    }

    /**
     * 两个年份之间的X轴
     * 如果 开始年份 >= 结束年份，则只返回开始年份
     *
     * @return
     */
    public static List<String> yearBetween(LocalDate startDate, LocalDate endDate) {
        Integer start = Integer.parseInt(LocalDateTimeUtil.format(startDate, DatePattern.NORM_YEAR_PATTERN));
        Integer end = Integer.parseInt(LocalDateTimeUtil.format(endDate, DatePattern.NORM_YEAR_PATTERN));
        List<String> list = new LinkedList<>();
        list.add(start.toString());
        if (start >= end) {
            return list;
        }
        while (start < end) {
            start += 1;
            list.add(start.toString());
        }
        return list;
    }

    /**
     * 判断字符串时间
     * dateTime 时间字符串
     * type 1 月 2 季度 3 年
     *
     * @return
     */
    public static String getByString(String dateTime, Integer type) throws ParseException {
        Date parses = new SimpleDateFormat(DatePattern.NORM_DATE_PATTERN).parse(dateTime);
        StringBuilder result = new StringBuilder();
        switch (type) {
            case 1:
                result.append(DateUtil.format(parses, DatePattern.NORM_MONTH_PATTERN));
                break;
            case 2:
                int quarter = DateUtil.quarter(parses);
                result.append(DateUtil.format(parses, DatePattern.NORM_YEAR_PATTERN)).append("第").append(quarter).append("季度");
                break;
            case 3:
                result.append(DateUtil.format(parses, DatePattern.NORM_YEAR_PATTERN));
                break;
        }
        return result.toString();
    }

    /**
     * 校验日期格式
     *
     * @param date
     * @param format
     */
    public static boolean isValidDate(String date, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        sdf.setLenient(false);
        try {
            sdf.parse(date);

        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 校验日期格式
     *
     * @param date
     * @return
     */
    public static boolean isValidDate(String date) {
        return isValidDate(date, DatePattern.NORM_DATE_PATTERN);
    }

    /**
     * 传过来的LocalDate类型的日期，距当前时间，相差多少年
     * 可计算年龄，工龄等
     * 返回Integer类型
     */
    public static Integer getYear(LocalDate localDate){
        //传过来的日期
        DateTimeFormatter df = DateTimeFormatter.ofPattern(DatePattern.NORM_YEAR_PATTERN);
        String dateStr = df.format(localDate);
        Long yearLong = Long.parseLong(dateStr);

        //当前日期
        LocalDate yearNow = LocalDate.now();
        String yearNowStr = df.format(yearNow);
        Long yearNowLong = Long.parseLong(yearNowStr);

        //当前 - 传过来的参数
        long age = yearNowLong - yearLong;
        return Math.toIntExact(age);
    }

    //写个main方法 试试效果
    public static void main(String[] args) {
        List<String> dateScope = LocalDateUtil.createDateScope(3, 6);

        for (String e : dateScope){
            log.info(e);
        }

        System.out.println("换行");

        //替换为横线
        List<String> collect = dateScope.stream()
                .map(e -> e.replace("/", "-"))
                .collect(Collectors.toList());

        for (String e : collect){
            log.info(e);
        }

    }
}