季度操作工具类

 有关于季度的工具类

import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAdjusters;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;

public class DateTimeUtils {
    private final static Logger logger = LoggerFactory.getLogger(DateTimeUtils.class);

    private final static String PATTERN_STR = "yyyy[-MM[-dd[ [HH[:mm[:ss[.SSS]]]]]]]";
    public final static String YYYY_MM = "yyyy-MM";
    public final static String YYYYMM = "yyyyMM";
    public final static String YYYY_MM_DD = "yyyy-MM-dd";
    public final static String HH_MM = "HH:mm";
    public final static String MM_DD_HH_MM = "MM月dd日HH:mm";
    public final static String YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
    public final static String YYYY_MM_DD_HH_MM_SLASH = "yyyy/MM/dd HH:mm";
    public final static String YYYY_MM_DD_HH_MM_SS_SLASH = "yyyy/MM/dd HH:mm:ss";
    public final static String YYYY_MM_DD_SLASH = "yyyy/MM/dd";

    public final static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
    public final static String YYYYMMDD = "yyyyMMdd";
    public final static String HHMMSS = "HHmmss";

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

    public final static String YYYY_MM_DD_HH_MM_CHS = "yyyy年MM月dd日 HH:mm";

    public final static String YYYY_DD_MM_CHS = "yyyy年MM月dd日";

    private final static String[] WEEK_STR = {"一", "二", "三", "四", "五", "六", "日"};
    public final static String[] QUARTER_STR = {"第一季度", "第二季度", "第三季度", "第四季度"};
    public static final Integer MAX_MONTH = 12;

    public final static String MM_DD = "MM月dd日";
    public final static String MM_DD_DOT = "MM.dd";

    private final static DateTimeFormatter DATE_FORMATTER =
            new DateTimeFormatterBuilder().appendPattern(PATTERN_STR)
                    .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1)
                    .parseDefaulting(ChronoField.DAY_OF_MONTH, 1)
                    .parseDefaulting(ChronoField.HOUR_OF_DAY, 0)
                    .parseDefaulting(ChronoField.MINUTE_OF_HOUR, 0)
                    .parseDefaulting(ChronoField.SECOND_OF_MINUTE, 0)
                    .toFormatter();


    public static LocalDateTime localDateTime(String time, String patten) {
        DateTimeFormatter formatter = new DateTimeFormatterBuilder().appendPattern(patten)
                .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1)
                .parseDefaulting(ChronoField.DAY_OF_MONTH, 1)
                .parseDefaulting(ChronoField.HOUR_OF_DAY, 0)
                .parseDefaulting(ChronoField.MINUTE_OF_HOUR, 0)
                .parseDefaulting(ChronoField.SECOND_OF_MINUTE, 0)
                .toFormatter();
        return LocalDateTime.parse(time, formatter);
    }

    public static LocalDateTime localDateTime(String time) {
        try {
            return LocalDateTime.parse(time, DATE_FORMATTER);
        } catch (Exception e) {
            throw new IllegalArgumentException("can not convert " + time
                    + "to LocalDateTime, the pattern is " + PATTERN_STR);
        }
    }

    public static LocalDateTime localDateTime(long time) {
        return LocalDateTime.ofInstant(Instant.ofEpochMilli(time),
                TimeZone.getDefault().toZoneId());
    }

    public static long toMilliseconds(LocalDateTime dateTime) {

        if (dateTime == null) {
            return 0;
        }
        return dateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
    }


    /**
     * 标准时间转成UTC0时间
     * @param localDateTime
     * @return
     */
    public static String localDateTimeToUtc(LocalDateTime localDateTime) {
        // 将LocalDateTime转换为ZonedDateTime，这里使用系统默认时区转为UTC
        ZonedDateTime zonedDateTime =
            localDateTime.atZone(ZoneId.systemDefault()).withZoneSameInstant(ZoneId.of("UTC"));
        // 定义UTC0格式的时间格式器
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM_SS);
        // 格式化为字符串
        String utcTimeString = zonedDateTime.format(formatter);
        return utcTimeString;
    }

    /**
     * UTC0时间转成标准时间
     *
     * @param localDateTime
     * @return
     */
    public static LocalDateTime utcToLocalDateTime(LocalDateTime localDateTime) {
        OffsetDateTime utcTime = OffsetDateTime.of(localDateTime,ZoneOffset.ofHours(0));
        // 转换为北京时间，偏移量为+08:00
        OffsetDateTime beijingTime = utcTime.withOffsetSameInstant(ZoneOffset.ofHours(8));
        return beijingTime.toLocalDateTime();
    }

    /**
     * 时间转为秒数
     *
     * @param
     * @return
     */
    public static Long toEpochSecond(LocalDateTime dateTime) {
        if (dateTime == null) {
            return null;
        }
        return dateTime.toEpochSecond(ZoneOffset.of("+8"));
    }

    public static String localDateTime(LocalDateTime dateTime, String patten) {
        return dateTime.format(DateTimeFormatter.ofPattern(patten));
    }

    public static String week(LocalDateTime dateTime) {
        int week = dateTime.getDayOfWeek().getValue();
        return WEEK_STR[week - 1];
    }


    /**
     * 季度转换 数字1234转第一第二第三第四季度
     *
     * @param quarter
     * @return
     */
    public static String quarter(Integer quarter) {
        return QUARTER_STR[quarter - 1];
    }


    /**
     * 将时间间隔转换成xx小时xx分钟xx秒
     *
     * @param duration
     * @return
     */
    public static String durationFormat(long duration) {

        String time;

        // 总秒数
        duration /= 1000;

        // 秒
        long left = (duration % 60);
        time = left > 0 ? left + "秒" : "";

        // 分
        duration /= 60;
        left = (duration % 60);
        time = (left > 0 ? left + "分钟" : "") + time;

        // 时
        duration /= 60;
        time = (duration > 0 ? duration + "小时" : "") + time;

        return time;
    }

    /**
     * 获取 前num个季度的开始日期
     *
     * @param nowDate 当前时间
     * @param num     前第num个季度 0为当前季度
     * @return 前num个季度的开始日期 如2019-12-01T00:00
     * @author Lemon
     * @date 2019/12/20 16:43
     */
    public static LocalDateTime getBeforeQuarterStartDate(LocalDateTime nowDate, int num) {
        int nowDateMonthValue = nowDate.getMonthValue();
        //获取前num*3个月日期
        LocalDateTime resultDate = nowDate.plusMonths(-3 * num);
        int quarter = getCurrentQuarter(resultDate.getMonthValue());
        switch (quarter) {
            case 1:
                return LocalDateTime.of(resultDate.getYear(), 1, 1, 0, 0, 0);
            case 2:
                return LocalDateTime.of(resultDate.getYear(), 4, 1, 0, 0, 0);
            case 3:
                return LocalDateTime.of(resultDate.getYear(), 7, 1, 0, 0, 0);
            case 4:
                return LocalDateTime.of(resultDate.getYear(), 10, 1, 0, 0, 0);
            default:
                return null;
        }
    }

    /**
     * 获取月度结束时间，或者开始时间
     *
     * @param start
     * @return
     */
    public static LocalDateTime getMonthStartOrEndTime(Integer year,Integer month,boolean start) {
        LocalDate startOfMonth = LocalDate.of(year, month, 1);
        if (start) {
            return LocalDateTime.of(startOfMonth, LocalTime.MIN);
        }
        // 获取2024年1月的月末结束时间
        LocalDate endOfMonth = startOfMonth.with(TemporalAdjusters.lastDayOfMonth());
        return LocalDateTime.of(endOfMonth, LocalTime.MAX);
    }

    /**
     * 获得当前季度
     *
     * @return 当前季度
     */
    public static int getCurrentQuarter() {
        return getCurrentQuarter(LocalDateTime.now().getMonthValue());
    }

    /**
     * 当前日期是否季度开始第一天
     *
     * @param nowDate 当前时间
     * @return 是否季度开始时间
     * @author cwq
     * @date 2020/12/1 17:40
     */
    public static boolean isCurrentQuarterStartDate(LocalDateTime nowDate) {
        LocalDateTime day = getBeforeQuarterStartDate(nowDate, 0);
        if (day == null) {
            return false;
        }
        return day.getDayOfMonth() == nowDate.getDayOfMonth() && day.getMonthValue() == nowDate.getMonthValue();
    }

    /**
     * 获得当前季度
     *
     * @param monthValue 月份
     * @return
     */
    public static int getCurrentQuarter(int monthValue) {
        return ((monthValue - 1) / 3) + 1;
    }

    /**
     * 获取上季度开始时间或者结束时间
     *
     * @param start
     * @return
     */
    public static LocalDateTime getLastQuarterStartOrEndTime(boolean start) {
        LocalDateTime now = LocalDateTime.now();
        int monthValue = now.getMonthValue();
        LocalDateTime startQuarter;
        LocalDateTime endQuarter;
        if (monthValue <= 3) {
            startQuarter = LocalDateTime.of(now.getYear() - 1, 10, 1, 0, 0, 0);
            endQuarter = LocalDateTime.of(now.getYear() - 1, 12, 31, 23, 59, 59);
        } else {
            startQuarter = LocalDateTime.of(now.getYear(), 1 + 3 * ((monthValue - 1) / 3 - 1), 1, 0, 0, 0);
            endQuarter = LocalDateTime.of(now.getYear(), 3 * ((monthValue - 1) / 3), 1, 23, 59, 59);
            endQuarter = endQuarter.with(TemporalAdjusters.lastDayOfMonth());
        }
        if (start) {
            return startQuarter;
        } else {
            return endQuarter;
        }
    }

    /**
     * LocalDateTime转换为Date
     *
     * @param localDateTime
     */
    public static Date localDateTime2Date(LocalDateTime localDateTime) {
        ZoneId zoneId = ZoneId.systemDefault();
        ZonedDateTime zdt = localDateTime.atZone(zoneId);//Combines this date-time with a time-zone to create a  ZonedDateTime.
        Date date = Date.from(zdt.toInstant());
        return date;
    }

    /**
     * 将yyyyMMdd转换成yyyy-MM-dd
     *
     * @param saleTime
     * @return
     */
    public static String formatString(String saleTime) {
        if (Strings.isNullOrEmpty(saleTime) || saleTime.length() != 8) {
            throw new RuntimeException("数据格式错误");
        }
        StringBuilder stringBuffer = new StringBuilder(saleTime);
        stringBuffer.insert(4, "-");
        stringBuffer.insert(7, "-");
        return stringBuffer.toString();
    }

    /**
     * 把日期转换为字符串
     *
     * @param date 日期
     */
    public static String dateToString(Date date, String format) {
        String result = "";
        SimpleDateFormat format1 = new SimpleDateFormat(format);
        try {
            result = format1.format(date);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return result;
    }

    /**
     * 把日期转换为字符串
     *
     * @param localDateTime 日期
     */
    public static String localDateTimeToString(LocalDateTime localDateTime, String format) {
        String result = "";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
        try {
            result = localDateTime.format(formatter);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return result;
    }

    /**
     * 根据季度和年份  查询季度开始时间或结束时间
     *
     * @param year
     * @param quarter
     * @param isStart   false 是季度末 true是季度开始
     * @return
     */
    public static LocalDateTime getQuarterStartOrEnd(Integer year, Integer quarter, boolean isStart) {
        switch (quarter) {
            case 1:
                if (isStart) {
                    return LocalDateTime.of(year, 1, 1, 0, 0, 0);
                }
                return LocalDateTime.of(year, 3, 31, 23, 59, 59);
            case 2:
                if (isStart) {
                    return LocalDateTime.of(year, 4, 1, 0, 0, 0);
                }
                return LocalDateTime.of(year, 6, 30, 23, 59, 59);
            case 3:
                if (isStart) {
                    return LocalDateTime.of(year, 7, 1, 0, 0, 0);
                }
                return LocalDateTime.of(year, 9, 30, 23, 59, 59);
            case 4:
                if (isStart) {
                    return LocalDateTime.of(year, 10, 1, 0, 0, 0);
                }
                return LocalDateTime.of(year, 12, 31, 23, 59, 59);
            default:
                return LocalDateTime.now();
        }
    }

    /**
     * 查询下一个季度
     *
     * @param year        传入年份
     * @param quarter     传入季度
     * @param nextQuarter 是否是下个季度, true表示获取下个季度,false标识上个季度
     * @return left为年 right 为季度
     */
    public static Pair<Integer, Integer> getNextQuarter(Integer year, Integer quarter, boolean nextQuarter) {
        try {
            Integer resultQuarter = null;
            // 获取下个季度
            if (nextQuarter) {
                resultQuarter = quarter + 1;
                if (resultQuarter < 5) {
                    return Pair.of(year, resultQuarter);
                }
                return Pair.of(year + 1, 1);
            }
            // 获取上个季度
            resultQuarter = quarter - 1;
            if (resultQuarter < 1) {
                return Pair.of(year - 1, 4);
            }
            return Pair.of(year, resultQuarter);
        } catch (Exception e) {
            logger.error("获取上个季度失败year:{}quarter:{}nextQuarter:{}", year, quarter, nextQuarter, e);
            return null;
        }
    }

    /**
     * 查询季度前或者下几个季度
     *
     * @param year    传入年份
     * @param quarter 传入季度
     * @param gaps    0返回当前季度 1表示下一个季度 -1表示上一个季度 以此类推
     * @return left为年 right 为季度
     */
    public static Pair<Integer, Integer> getNextQuarter(Integer year, Integer quarter, int gaps) {
        try {
            Pair<Integer, Integer> nextQuarter = Pair.of(year, quarter);
            if (gaps == 0) {
                return nextQuarter;
            }
            int i = gaps > 0 ? gaps : -gaps;
            for (int j = 0; j < i; j++) {
                nextQuarter = getNextQuarter(nextQuarter.getLeft(), nextQuarter.getRight(), gaps > 0);
            }
            return nextQuarter;
        } catch (Exception e) {
            logger.error("获取下一季度失败year:{}quarter:{}nextQuarter:{},gap{}", year, quarter, gaps, e);
            return null;
        }
    }


    /**
     * 查询上个月或下个月对应的年月
     *
     * @param year      传入年份
     * @param month     传入月份
     * @param nextMonth 是否是下个月, true表示获取下个月,false标识上个月
     * @return left为年 right 为月份
     */
    public static Pair<Integer, Integer> getNextOrLastMonth(Integer year, Integer month, boolean nextMonth) {
        Integer resultMonth = null;
        // 获取下个月
        if (nextMonth) {
            resultMonth = month + 1;
            if (resultMonth < 13) {
                return Pair.of(year, resultMonth);
            }
            return Pair.of(year + 1, 1);
        }
        // 获取上个月
        resultMonth = month - 1;
        if (resultMonth < 1) {
            return Pair.of(year - 1, 12);
        }
        return Pair.of(year, resultMonth);
    }


    /**
     * 比较两个年月先后,
     *
     * @param checkYear     需要比较的年份
     * @param originalYear  被比较的年份
     * @param checkMonth
     * @param originalMonth
     * @return 返回是否在后者之前的月份
     */
    public static boolean compareYearAndMonth(Integer checkYear, Integer originalYear, Integer checkMonth, Integer originalMonth) {
        try {
            LocalDateTime checkTime = LocalDateTime.of(checkYear, checkMonth, 1, 0, 0);
            LocalDateTime originalTime = LocalDateTime.of(originalYear, originalMonth, 1, 0, 0);
            return checkTime.isBefore(originalTime) || checkTime.equals(originalTime);
        } catch (Exception e) {
            logger.error("比较月份前后失败.", e);
            return false;
        }
    }

    /**
     * 获取季度所在的月份集合
     *
     * @param quarter
     * @return
     */
    public static List<Integer> getQuarterMonths(Integer quarter) {
        if (quarter == 1) {
            return Lists.newArrayList(1, 2, 3);
        }
        if (quarter == 2) {
            return Lists.newArrayList(4, 5, 6);
        }
        if (quarter == 3) {
            return Lists.newArrayList(7, 8, 9);
        }
        if (quarter == 4) {
            return Lists.newArrayList(10, 11, 12);
        }
        return Lists.newArrayList();
    }

    /**
     * 月份转季度
     *
     * @param month 月
     * @return int
     */
    public static Integer monthToQuarter(int month) {
        if (month >= 1 && month <= MAX_MONTH) {
            return (month - 1) / 3 + 1;
        } else {
            throw new IllegalArgumentException("Invalid month");
        }
    }

    /**
     * 获取一天最早的时间
     *
     * @return
     */
    public static LocalDateTime getDayMinTime(LocalDateTime localDateTime) {
        return LocalDateTime.of(localDateTime.toLocalDate(), LocalTime.MIN);
    }

    /**
     * 获取一天最晚的时间
     *
     * @return
     */
    public static LocalDateTime getDayMaxTime(LocalDateTime localDateTime) {
        return LocalDateTime.of(localDateTime.toLocalDate(), LocalTime.MAX);
    }

    /**
     * 增加月份
     *
     * @param time
     * @param monthOffset
     * @return
     */
    public static LocalDateTime addMonth(LocalDateTime time, Integer monthOffset) {
        if (time != null && monthOffset != null) {
            return time.plusMonths(monthOffset);
        }
        return time;
    }

    public static Date safeToDate(Object date, String fmt, Date dv) {
        Date result = dv;
        if (date != null) {
            try {
                result = (new SimpleDateFormat(fmt)).parse(date.toString().trim());
            } catch (Exception var5) {
            }
        }

        return result;
    }


    /**
     * 根据年月构造月开始时间或结束时间
     * @param year
     * @param month
     * @param maxFlag
     * @return
     */
    public static LocalDateTime constructYearMonthTime(Integer year, Integer month, boolean maxFlag) {
        LocalDateTime time;
        if (maxFlag) {
            LocalDate localDate = LocalDate.of(year, month, 1).withDayOfMonth(Month.of(month).length(false));
            time = LocalDateTime.of(localDate, LocalTime.MAX);
        } else {
            LocalDate localDate = LocalDate.of(year, month, 1);
            time = LocalDateTime.of(localDate, LocalTime.MIN);
        }
        return time;
    }
}

举例：获取年份下某季度的开始时间和结束时间

    public static void main(String[] args) {
        Integer year = 2024;
        Integer quarter = 4;

        LocalDateTime localDateTime = LocalDateTime.now();
        //获取季度开始时间
        LocalDateTime quarterStart = DateTimeUtils.getQuarterStartOrEnd(year,quarter , true);
        //获取季度结束时间
        LocalDateTime qurterEnd = DateTimeUtils.getQuarterStartOrEnd(year,quarter, false);

        System.out.println("输入年份: "+ year + " 输入季度: " + quarter);
        System.out.println("季度开始时间：" + quarterStart);
        System.out.println("季度结束时间: " + qurterEnd);
//        //当前时间与季度结束时间相比较，当前时间小于季度结束时间取当前时间
//        int i = localDateTime.compareTo(qurterEnd);
//        if(i < 0){
//            System.out.println("localDateTime is before qurterEnd");
//        }else if (i > 0) {
//            System.out.println("localDateTime is after qurterEnd");
//        }else {
//            System.out.println("localDateTime is equals qurterEnd");
//        }
    }

 输出结果：

输入年份: 2024 输入季度: 4
季度开始时间：2024-10-01T00:00
季度结束时间:   2024-12-31T23:59:59