日期处理工具类

package org.example;



import org.apache.commons.lang3.StringUtils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;

/**
 * 日期处理工具类
 *
 */
public final class DateUtils extends org.apache.commons.lang3.time.DateUtils {
    private DateUtils() {
    }
    /** yyyy-MM **/
    public static final DateTimeFormatter FMT_MONTH = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_MONTH);
    /** yyyy-MM-dd **/
    public static final DateTimeFormatter FMT_DATE = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_DATE);
    /** yyyy-MM-dd HH:mm **/
    public static final DateTimeFormatter FMT_MINUTE = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_MINUTE);
    /** yyyy-MM-dd HH:mm:ss **/
    public static final DateTimeFormatter FMT_SECOND = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_SECOND);
    /** yyyy-MM-dd HH:mm:ss SSSS **/
    public static final DateTimeFormatter FMT_MILLISECOND = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_MILLISECOND);
    /** EEE MMM dd HH:mm:ss zzz yyyy **/
    public static final DateTimeFormatter FMT_SECOND_ENG = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_MILLISECOND);
    /** MM-dd **/
    public static final DateTimeFormatter FMT_MONTHDATE = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_MONTHDATE);

    /** yyyyMMdd **/
    public static final DateTimeFormatter FMT_DATE_N = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_DATE_N);

    /** yyyy/mm/dd **/
    public static final DateTimeFormatter FMT_SLASH = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.FMT_SLASH);

    /** yyyyMMddHHmm **/
    public static final DateTimeFormatter FMT_MINUTE_N = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_MINUTE_N);
    /** yyyyMMddHHmmss **/
    public static final DateTimeFormatter FMT_SECOND_N = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_SECOND_N);
    /** yyMMddHHmmss **/
    public static final DateTimeFormatter FMT_SHORT_SECOND_N = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_SHORT_SECOND_N);
    /** yyyyMMddHHmmssSSSS **/
    public static final DateTimeFormatter FMT_MILLISECOND_N = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_MILLISECOND_N);
    /** yyMMddHHmmssSSSS **/
    public static final DateTimeFormatter FMT_SHORT_MILLISECOND_N = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_SHORT_MILLISECOND_N);
    /** HHmmss **/
    public static final DateTimeFormatter FMT_HMS_N = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_HMS_N);

    /** yyyy/M/d **/
    public static final DateTimeFormatter FMT_DATE_SLASH = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_DATE_SLASH);

    /** H **/
    public static final DateTimeFormatter FMT_HOUR_N = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.HOUR_N);

    /** yyyy年MM月dd日 **/
    public static final DateTimeFormatter FMT_SIMPLE = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_DATE_SIMPLE);

    /** yyyy年M月dd日 **/
    public static final DateTimeFormatter FMT_SIMPLE1 = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_DATE_SIMPLE1);

    /** MMM.dd,uuuu **/
    public static final DateTimeFormatter FMT_ENGLISH = DateTimeFormatter.ofPattern(GlobalConstants.DateFormat.TO_DATE_ENGLISH, Locale.ENGLISH);

    /**
     * 此处集合顺序要以最长的开始，否则获取格式不准确
     */
    public static final String[] FORMATS = { GlobalConstants.DateFormat.TO_SECOND_ENG, GlobalConstants.DateFormat.TO_MILLISECOND,
            GlobalConstants.DateFormat.TO_MILLISECOND_N, GlobalConstants.DateFormat.TO_SECOND, GlobalConstants.DateFormat.TO_SECOND_N,
            GlobalConstants.DateFormat.TO_MINUTE, GlobalConstants.DateFormat.TO_HOUR_N, GlobalConstants.DateFormat.TO_MINUTE_N,
            GlobalConstants.DateFormat.TO_DATE, GlobalConstants.DateFormat.TO_DATE_N, GlobalConstants.DateFormat.TO_MONTH,
            GlobalConstants.DateFormat.TO_MONTH_N };

    /**
     * 获取两个日期相隔天数
     * @param startDate
     * @param endDate
     * @return
     */
    public static int getDayBetween(LocalDate startDate, LocalDate endDate) {
        Long day = 0L;
        if (null != startDate && null != endDate && !startDate.isAfter(endDate)) {
            day = endDate.toEpochDay() - startDate.toEpochDay();
        }
        return day.intValue();
    }

    /**
     * 获取两个日期相隔月数(不足一个月时为一个月)
     * @param startDate
     * @param endDate
     * @return
     */
    public static int getMonthBetween(LocalDate startDate, LocalDate endDate) {
        int month = 0;
        if (null != startDate && null != endDate && !startDate.isAfter(endDate)) {
            Period period = Period.between(startDate, endDate);
            month = period.getMonths();
            // 默认为1个月
            month = month == 0 ? 1 : month;
        }
        return month;
    }

    /**
     * Date转LocalDateTime
     *
     * @param date
     * @return java.time.LocalDateTime
     */
    public static LocalDateTime dateToLocalDateTime(Date date) {
        if (null == date) {
            return null;
        }
        Instant instant = date.toInstant();
        ZoneId zone = ZoneId.systemDefault();
        return LocalDateTime.ofInstant(instant, zone);
    }

    /**
     * LocalDateTime转Date
     *
     * @param localDateTime
     * @return java.util.Date
     */
    public static Date localDateTimeToDate(LocalDateTime localDateTime) {
        if (null == localDateTime) {
            return null;
        }
        ZoneId zone = ZoneId.systemDefault();
        Instant instant = localDateTime.atZone(zone).toInstant();
        return Date.from(instant);
    }

    /**
     * 获取日期的月份 .
     *
     * @param date
     * @return int
     */
    public static int getYear(Date date) {
        return getValueByField(date, Calendar.YEAR);
    }

    /**
     * 获取日期的月份 .
     *
     * @param date
     * @return int
     */
    public static int getMonth(Date date) {
        // 因月份从0开始，故加1
        return getValueByField(date, Calendar.MONTH) + 1;
    }

    /**
     * 根据Calendar中的日期字段获取日期的对应值 .
     *
     * @param date
    * @param field
     * @return int
     */
    public static int getValueByField(Date date, int field) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(field);
    }

    /**
     * 根据指定的格式 格式化日期
     *
     * @param date
     * @param pattern
     * @return
     */
    public static String formatDateToString(Date date, String pattern) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
        return dateFormat.format(date);
    }

    /**
     * 根据指定的格式 格式化日期
     * @param date
     * @param pattern
     * @return java.lang.String
     */
    public static String formatDate(LocalDateTime date, String pattern) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return date.format(formatter);
    }

    /**
     * 传入的日期转换成星期几
     * @param changeDate
     * @return int
     */
	public static int dateToWeekday(Date changeDate){
		int[] weekdays = { 0, 1, 2, 3, 4, 5, 6 };
		if(null == changeDate) {
			return -1;
		}
		Calendar cal = Calendar.getInstance();
		cal.setTime(changeDate);
		int numOfWeek = cal.get(Calendar.DAY_OF_WEEK) - 1;
		return weekdays[numOfWeek];
	}

	/**
     * 转换时间
     * @param year
     * @param month
     * @return
     */
	public static String formatYmDate(int year, int month) {
        String excludeDate = year + GlobalConstants.Symbol.MINUS; // 转换时间
        if (month < 10) {
            excludeDate += "0" + month;
        } else {
            excludeDate += month;
        }
        return excludeDate;
    }

    /**
     * 将一个字符串转换为日期
     *
     * @param dateStr
     * @return
     */
    public static Date parseStringToDate(String dateStr) {
        String formatter = getDateFormat(dateStr);
        if (null != formatter) {
            return parseDate(dateStr, formatter);
        } else {
            return null;
        }
    }

    /**
     * 获取字符串的日期格式
     *
     * @param str 字符串
     * @return 返回字符串的日期格式
     */
    public static String getDateFormat(String str) {
        for (String format : FORMATS) {
            if (isDate(str, format)) {
                return format;
            }
        }
        return null;
    }

    /**
     * 判断字符串是否为指定日期格式的字符串。
     *
     * @param datesStr 字符串
     * @param format 日期格式
     * @return 如果是指定日期格式的字符串返回true，否则返回false。
     */
    public static Boolean isDate(String datesStr, String format) {
        boolean isDate = false;
        try {
            Date date = parseDate(datesStr, format);
            if (date != null) {
                isDate = true;
            }
        } catch (Exception e) {
            isDate = false;
        }
        return isDate;
    }

    /**
     * 根据指定日期格式将给出的日期字符串dateStr转换成一个日期对象
     *
     * @param dateStr
     * @param pattern
     * @return Date
     */
    public static Date parseDate(String dateStr, String pattern) {
        if (StringUtils.isBlank(dateStr) || StringUtils.isBlank(pattern)) {
            return null;
        }
        DateFormat dateFormat = null;
        if (GlobalConstants.DateFormat.TO_SECOND_ENG.equals(pattern)) {
            dateFormat = new SimpleDateFormat(pattern, Locale.ENGLISH);
        } else {
            dateFormat = new SimpleDateFormat(pattern);
        }
        dateFormat.setLenient(false);
        Date result = null;
        try {
            result = dateFormat.parse(dateStr);
        } catch (ParseException e) {
        }
        return result;
    }

	/**
	 * 根据月份获取季度
	 * @param month
	 * @return
	 */
	public static int getSeasonByMonth(int month) {
	    int season = 0;
	    if (month <= 3) {
	        season = 1;
        } else if (month <= 6) {
            season = 2;
        } else if (month <= 9) {
            season = 3;
        } else {
            season = 4;
        }
	    return season;
	}

	/**
     * 获取统计月份条件(不含当前月份)
     *
     * @param queryCount
     * @return statisticsDateList
     */
	public static List<String> getStatisticsMonths(int queryCount) {
        final LocalDate now = LocalDate.now();
        List<String> statisticsDateList = new ArrayList<>();
        for (int i = 1; i <= queryCount; i++) {
            LocalDate statisticsDate = now.minusMonths(i);
            statisticsDateList.add(DateUtils.FMT_MONTH.format(statisticsDate));
        }
        return statisticsDateList;
    }

    /**
     * 获取统计季度条件(不含当前季度)
     *
     * @param queryCount
     * @return quarterStaticsList
     */
	public static List<String> getStatisticsSeasons(int queryCount) {
        List<String> quarterStaticsList = new ArrayList<>();
        String seaonDate = null;
        LocalDate queryDate = LocalDate.now();
        for (int i = 0; i < queryCount; i++) {
            // 四个季度的时间
            queryDate = queryDate.minusMonths(3);
            // X轴时间
            seaonDate = queryDate.getYear() + "Q" + DateUtils.getSeasonByMonth(queryDate.getMonthValue());
            quarterStaticsList.add(seaonDate);
        }
        return quarterStaticsList;
    }

    /**
     * 判断日期是否有效
     *
     * @param dataTime
     * @return
     */
    public static boolean isValid(LocalDateTime dataTime) {
        if (null == dataTime) {
            return false;
        }
        if (dataTime.getYear() > 9999) {
            return false;
        }
        if (dataTime.getMonthValue() <= 0 || dataTime.getMonthValue() > 12) {
            return false;
        }
        if (dataTime.getDayOfMonth() <= 0 || dataTime.getDayOfMonth() > 31) {
            return false;
        }
        return true;
    }

	/**
     * 转换时间yyyy-MM-dd
     *
     * @param year
     * @param month
     * @param day
     * @return
     */
	public static Date parseDate(int year, int month, int day) {
        String excludeDate = year + GlobalConstants.Symbol.MINUS; // 转换时间
        if (month < 10) {
            excludeDate += "0" + month;
        } else {
            excludeDate += month;
        }
        excludeDate += GlobalConstants.Symbol.MINUS;
        if (day < 10) {
            excludeDate += "0" + day;
        } else {
            excludeDate += day;
        }
        return parseDate(excludeDate, GlobalConstants.DateFormat.TO_DATE);
    }


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

    /**
     * 获取给定时间所在周的周一和周日 .<br>
     *
     * @param localDateTime 给定时间
     * @return java.util.List<java.time.LocalDateTime>
     */
    public static List<LocalDateTime> getWeek(LocalDateTime localDateTime){
        List<LocalDateTime> dateTimeList = new ArrayList<>();
        long week = localDateTime.getDayOfWeek().getValue();
        LocalDateTime startDate = localDateTime.plusDays(-week + 1);
        LocalDateTime endDate = localDateTime.plusDays(7 - week);
        // 第一天
        dateTimeList.add(0,startDate);
        // 最后一天
        dateTimeList.add(1,endDate);
        return dateTimeList;
    }
}