日期工具类

import cn.hutool.core.lang.Validator;
import cn.hutool.core.date.DateUtil;
import org.apache.commons.lang3.StringUtils;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static cn.hutool.core.lang.Validator.BIRTHDAY;

/**
 * 日期工具类
 *
 * @author : wy
 * @version : v1.0
 */
public final class LocalDateTimeUtils {

    /**
     * 日期格式yyyy-MM-dd
     */
    public static String DATE_PATTERN = "yyyy-MM-dd";

    /**
     * 日期时间格式yyyy-MM-dd HH:mm:ss
     */
    public static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 日期格式yyyy-MM-dd
     */
    public static String DATE_PATTERN_2 = "yyyy年M月d日";

    /**
     * 年月日时分秒正则(包含多种格式)
     */
    public final static Pattern DATE_TIME_PATTERN_2 = Pattern.compile("^(\\d{4})([/\\-\\.年]?)(\\d{1,2})([/\\-\\.月]?)(\\d{1,2})日?[\\s]?(\\d{1,2})([:时]?)(\\d{1,2})([:分]?)(\\d{1,2})([:秒]?)$");

    /**
     * 构造函数
     */
    private LocalDateTimeUtils() {
        super();
    }

    /**
     * Date转LocalDateTime
     *
     * @param date Date对象
     * @return
     */
    public static LocalDateTime dateToLocalDateTime(Date date) {
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
    }

    /**
     * LocalDateTime转换为Date
     *
     * @param dateTime LocalDateTime对象
     * @return
     */
    public static Date localDateTimeToDate(LocalDateTime dateTime) {
        return Date.from(dateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 格式化时间-默认yyyy-MM-dd HH:mm:ss格式
     *
     * @param dateTime LocalDateTime对象
     * @return
     */
    public static String formatDateTime(LocalDateTime dateTime) {
        return formatDateTime(dateTime, DATE_TIME_PATTERN);
    }

    /**
     * 格式化日期(yyyy-MM-dd)
     *
     * @param dateTime LocalDateTime对象
     * @return
     */
    public static String formatDate(LocalDateTime dateTime) {
        if (dateTime == null) {
            return null;
        }
        return formatDateTime(dateTime, DATE_PATTERN);
    }

    /**
     * @param localDate
     * @return java.lang.String
     * @title: formatDate
     * @description: 格式化日期(yyyy - MM - dd)
     * @throws:
     */
    public static String formatDate(LocalDate localDate) {
        if (localDate == null) {
            return null;
        }
        return formatDate(localDate, DATE_PATTERN);
    }

    /**
     * 格式化日期(yyyy-MM-dd)
     *
     * @param dateTime LocalDateTime对象
     * @return
     */
    public static String formatDate(String dateTime, String pattern) {
        return formatDateTime(parseDate(dateTime), pattern);
    }

    /**
     * 按pattern格式化时间-默认yyyy-MM-dd HH:mm:ss格式
     *
     * @param dateTime LocalDateTime对象
     * @param pattern  要格式化的字符串
     * @return
     */
    public static String formatDateTime(LocalDateTime dateTime, String pattern) {
        if (dateTime == null) {
            return null;
        }
        if (pattern == null || pattern.isEmpty()) {
            pattern = DATE_TIME_PATTERN;
        }
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return dateTime.format(formatter);
    }

    /**
     * @param dateTime
     * @param pattern
     * @return java.lang.String
     * @title: formatDate
     * @description: 转换LocalDate的时间格式
     * @throws:
     */
    public static String formatDate(LocalDate dateTime, String pattern) {
        if (dateTime == null) {
            return null;
        }
        if (pattern == null || pattern.isEmpty()) {
            pattern = DATE_TIME_PATTERN;
        }
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        return dateTime.format(formatter);
    }

    /**
     * 解析时间-(yyyy-MM-dd HH:mm:ss)
     *
     * @param dateTime 日期时间字符串
     * @return LocalDateTime对象
     */
    public static LocalDateTime parseDateTime(String dateTime) {
        return parseDateTime(dateTime, DATE_TIME_PATTERN);
    }

    /**
     * 解析日期(yyyy-MM-dd)
     *
     * @param date 日期字符串
     * @return LocalDateTime对象
     */
    public static LocalDateTime parseDate(String date, String... pattern) {
        if (date == null || date.length() == 0) {
            return null;
        }
        if (pattern == null || pattern.length == 0) {
            return LocalDate.parse(date, DateTimeFormatter.ofPattern(DATE_PATTERN)).atStartOfDay();
        } else {
            return LocalDate.parse(date, DateTimeFormatter.ofPattern(pattern[0])).atStartOfDay();
        }
    }

    /**
     * @param date yyyy-MM-dd格式字符串
     * @return java.time.LocalDate
     * @title: stringToLocalDate
     * @description: 字符串转LocalDate
     */
    public static LocalDate stringToLocalDate(String date) {
        if (StringUtils.isBlank(date)) {
            return null;
        }

        String datePattern;
        if (date.contains("/")) {
            datePattern = "yyyy/M/d";
        } else if (date.contains("-")) {
            datePattern = "yyyy-M-d";
        } else if (date.contains(".")) {
            datePattern = "yyyy.M.d";
        } else if (date.contains("年")) {
            datePattern = "yyyy年M月d日";
        } else {
            datePattern = "yyyyMMdd";
        }

        return LocalDate.parse(date, DateTimeFormatter.ofPattern(datePattern));
    }

    /**
     * 按指定规则解析时间(默认 yyyy-MM-dd HH:mm:ss)
     *
     * @param dateTime String
     * @param pattern  要解析的字符串
     * @return
     */
    public static LocalDateTime parseDateTime(String dateTime, String pattern) {
        if (dateTime == null) {
            return null;
        }
        if (pattern == null || pattern.isEmpty()) {
            pattern = DATE_TIME_PATTERN;
        }
        return LocalDateTime.parse(dateTime, DateTimeFormatter.ofPattern(pattern));
    }


    /**
     * 获取今天的00:00:00
     *
     * @return
     */
    public static String getDayStart() {
        return getDayStart(LocalDateTime.now());
    }

    /**
     * 获取今天的23:59:59
     *
     * @return
     */
    public static String getDayEnd() {
        return getDayEnd(LocalDateTime.now());
    }

    /**
     * 获取某天的00:00:00
     *
     * @param dateTime
     * @return
     */
    public static String getDayStart(LocalDateTime dateTime) {
        return formatDateTime(dateTime.with(LocalTime.MIN));
    }

    /**
     * 获取某天的23:59:59
     *
     * @param dateTime
     * @return
     */
    public static String getDayEnd(LocalDateTime dateTime) {
        return formatDateTime(dateTime.with(LocalTime.MAX));
    }

    /**
     * 获取本月第一天的00:00:00
     *
     * @return
     */
    public static String getFirstDayOfMonth() {
        return getFirstDayOfMonth(LocalDateTime.now());
    }

    /**
     * 获取本月最后一天的23:59:59
     *
     * @return
     */
    public static String getLastDayOfMonth() {
        return getLastDayOfMonth(LocalDateTime.now());
    }

    /**
     * 获取某月第一天的00:00:00
     *
     * @param dateTime LocalDateTime对象
     * @return
     */
    public static String getFirstDayOfMonth(LocalDateTime dateTime) {
        return formatDateTime(dateTime.with(TemporalAdjusters.firstDayOfMonth()).with(LocalTime.MIN));
    }

    /**
     * 获取某月最后一天的23:59:59
     *
     * @param dateTime LocalDateTime对象
     * @return
     */
    public static String getLastDayOfMonth(LocalDateTime dateTime) {
        return formatDateTime(dateTime.with(TemporalAdjusters.lastDayOfMonth()).with(LocalTime.MAX));
    }

    /**
     * 日期偏移
     *
     * @param dateTime 日期
     * @param day      偏移天数(支持负数)
     * @return
     */
    public static LocalDateTime offsetDay(LocalDateTime dateTime, int day) {
        return dateTime.plusDays(day);
    }

    /**
     * 日期偏移
     *
     * @param date 日期
     * @param day  偏移天数(支持负数)
     * @return
     */
    public static String offsetDay(String date, int day) {
        return formatDate(parseDate(date).plusDays(day));
    }

    /**
     * 日期相隔天数
     *
     * @param startDay 开始日期(yyyy-MM-dd)
     * @param endDay   结束日期(yyyy-MM-dd)
     * @return
     */
    public static Long betweenDay(String startDay, String endDay) {
        return betweenDay(parseDate(startDay), parseDate(endDay));
    }

    /**
     * @param startDay 开始日期
     * @param endDay   结束日期
     * @return java.lang.Long 相隔天数
     * @title: betweenDay
     * @description: 日期相隔天数
     */
    public static Long betweenDay(LocalDateTime startDay, LocalDateTime endDay) {
        return Duration.between(startDay, endDay).toDays();
    }

    /**
     * @param startDay
     * @param endDay
     * @return java.lang.Long
     * @title: betweenDay
     * @description: 相隔天数
     * @throws:
     */
    public static Long betweenDay(LocalDate startDay, LocalDate endDay) {
        LocalTime time = LocalTime.of(0, 0, 0);
        LocalDateTime start = LocalDateTime.of(startDay, time);
        LocalDateTime end = LocalDateTime.of(endDay, time);
        return Duration.between(start, end).toDays();
    }


    /**
     * 校验是否是年月日时分秒
     *
     * @param dateStr
     * @return
     */
    public static boolean verifyDateTime(String dateStr) {
        if (Validator.isMatchRegex(Validator.BIRTHDAY, dateStr)) {
            Matcher matcher = Validator.BIRTHDAY.matcher(dateStr);
            if (matcher.find()) {
                int year = Integer.parseInt(matcher.group(1));
                int month = Integer.parseInt(matcher.group(3));
                int day = Integer.parseInt(matcher.group(5));
                return verifyYearMonthDay(year, month, day);
            }
        } else if (Validator.isMatchRegex(DATE_TIME_PATTERN_2, dateStr)) {
            Matcher matcher = DATE_TIME_PATTERN_2.matcher(dateStr);
            if (matcher.find()) {
                int year = Integer.parseInt(matcher.group(1));
                int month = Integer.parseInt(matcher.group(3));
                int day = Integer.parseInt(matcher.group(5));
                int hour = Integer.parseInt(matcher.group(6));
                int minute = Integer.parseInt(matcher.group(8));
                int second = Integer.parseInt(matcher.group(10));
                //校验日期的年、月、日、时、分、秒是否正确
                if (verifyYearMonthDay(year, month, day) && verifyHourMinuteSecond(hour, minute, second)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 校验是否是年月日
     *
     * @param dateStr
     * @return
     */
    public static boolean verifyDate(String dateStr) {
        if (Validator.isMatchRegex(Validator.BIRTHDAY, dateStr)) {
            Matcher matcher = Validator.BIRTHDAY.matcher(dateStr);
            if (matcher.find()) {
                int year = Integer.parseInt(matcher.group(1));
                int month = Integer.parseInt(matcher.group(3));
                int day = Integer.parseInt(matcher.group(5));
                return verifyYearMonthDay(year, month, day);
            }
        }
        return false;
    }

    /**
     * 验证年、月、日是否正确
     *
     * @param year
     * @param month
     * @param day
     * @return
     */
    public static boolean verifyYearMonthDay(int year, int month, int day) {
        // 验证年
        if (year < 1900 || year > 9999) {
            return false;
        }

        // 验证月
        if (month < 1 || month > 12) {
            return false;
        }

        // 验证日
        if (day < 1 || day > 31) {
            return false;
        }
        boolean isMonthWithout31Days = (month == 4 || month == 6 || month == 9 || month == 11) && day == 31;
        if (isMonthWithout31Days) {
            return false;
        }
        if (month == 2) {
            boolean isLeapYear = day > 29 || (day == 29 && false == DateUtil.isLeapYear(year));
            if (isLeapYear) {
                return false;
            }
        }
        return true;
    }

    /**
     * 验证时、分、秒是否正确
     *
     * @param hour
     * @param minute
     * @param second
     * @return
     */
    public static boolean verifyHourMinuteSecond(int hour, int minute, int second) {
        // 验证时
        if (hour < 0 || hour > 24) {
            return false;
        }

        // 验证分
        if (minute < 0 || minute > 60) {
            return false;
        }

        // 验证秒
        if (second < 0 || second > 60) {
            return false;
        }
        return true;
    }

    /**
     * 字符转日期转LocalDateTime
     * 支持格式：yyyyMMdd、yyyy.MM.dd、yyyy-MM-dd、yyyy/MM/dd、yyyy年MM月dd日
     * yyyy年MM月dd日 HH时mm分ss秒、yyyy-MM-dd HH:mm:ss、yyyy/MM/dd HH:mm:ss、yyyyMMddHH:mm:ss
     *
     * @param date
     * @return
     */
    public static LocalDateTime stringToLocalDateTime(String date) {
        if (StringUtils.isNotEmpty(date)) {
            if (Validator.isMatchRegex(Validator.BIRTHDAY, date)) {
                Matcher matcher = Validator.BIRTHDAY.matcher(date);
                if (matcher.find()) {
                    int year = Integer.parseInt(matcher.group(1));
                    int month = Integer.parseInt(matcher.group(3));
                    int day = Integer.parseInt(matcher.group(5));
                    //校验日期的年、月、日是否正确
                    if (verifyYearMonthDay(year, month, day)) {
                        return LocalDateTime.of(year, month, day, 0, 0, 0);
                    }
                }
            } else if (Validator.isMatchRegex(Constants.DATE_TIME_PATTERN, date)) {
                if (Validator.isMatchRegex(Constants.DATE_TIME_PATTERN, date)) {
                    Matcher matcher = Constants.DATE_TIME_PATTERN.matcher(date);
                    if (matcher.find()) {
                        int year = Integer.parseInt(matcher.group(1));
                        int month = Integer.parseInt(matcher.group(3));
                        int day = Integer.parseInt(matcher.group(5));
                        int hour = Integer.parseInt(matcher.group(6));
                        int minute = Integer.parseInt(matcher.group(8));
                        int second = Integer.parseInt(matcher.group(10));
                        //校验日期的年、月、日、时、分、秒是否正确
                        if (verifyYearMonthDay(year, month, day) && verifyHourMinuteSecond(hour, minute, second)) {
                            return LocalDateTime.of(year, month, day, hour, minute, second);
                        }
                    }
                }
            }
        }
        return null;
    }

    /**
     * 字符转日期转LocalDate
     * 支持格式：yyyyMMdd、yyyy.MM.dd、yyyy-MM-dd、yyyy/MM/dd、yyyy年MM月dd日
     *
     * @param date
     * @return
     */
    public static LocalDate stringToLocalDatePlus(String date) {
        if (StringUtils.isNotEmpty(date)) {
            if (Validator.isMatchRegex(BIRTHDAY, date)) {
                Matcher matcher = BIRTHDAY.matcher(date);
                if (matcher.find()) {
                    int year = Integer.parseInt(matcher.group(1));
                    int month = Integer.parseInt(matcher.group(3));
                    int day = Integer.parseInt(matcher.group(5));
                    //校验日期的年、月、日是否正确
                    if (verifyYearMonthDay(year, month, day)) {
                        return LocalDate.of(year, month, day);
                    }
                }
            }
        }
        return null;
    }

    /**
     * 日期格式校验
     * 支持格式：yyyyMMdd、yyyy.MM.dd、yyyy-MM-dd、yyyy/MM/dd、yyyy年MM月dd日
     *
     * @param dateStr
     * @return
     */
    public static boolean verifyDateFormat(String dateStr) {
        if (Validator.isMatchRegex(Validator.BIRTHDAY, dateStr)) {
            Matcher matcher = Validator.BIRTHDAY.matcher(dateStr);
            if (matcher.find()) {
                int year = Integer.parseInt(matcher.group(1));
                int month = Integer.parseInt(matcher.group(3));
                int day = Integer.parseInt(matcher.group(5));
                return verifyYearMonthDay(year, month, day);
            }
        }
        return false;
    }

    /**
     * 判断两个日期相差的时长
     *
     * @param data1
     * @param data2
     * @return
     */
    public static long between(LocalDate data1, LocalDate data2) {
        long day = data2.toEpochDay() - data1.toEpochDay();
        return day;
    }

    /**
     * 获取某月最后一天
     *
     * @param localDate LocalDateTime对象
     * @return
     */
    public static String getLastDay(LocalDate localDate) {
        return formatDate(localDate.with(TemporalAdjusters.lastDayOfMonth()));
    }

    /**
     * 获取上个月最后一天的2021-01-31
     *
     * @param localDate LocalDateTime对象
     * @return
     */
    public static String getFirstDay(LocalDate localDate) {
        LocalDate firstMonth = localDate.minusMonths(1);
        return formatDate(firstMonth.with(TemporalAdjusters.lastDayOfMonth()));
    }


    /**
     * 日期大于等于比较
     * targetDate1 >= targetDate2
     *
     * @param targetDate1
     * @param targetDate2
     * @return
     */
    public static boolean dateGeCompare(LocalDate targetDate1, LocalDate targetDate2) {
        if (targetDate1 == null || targetDate2 == null) {
            return false;
        }

        if ((targetDate1.isEqual(targetDate2) || targetDate1.isAfter(targetDate2))) {
            return true;
        }
        return false;
    }

    /**
     * 日期小于等于比较
     * targetDate1 <= targetDate2
     *
     * @param targetDate1
     * @param targetDate2
     * @return
     */
    public static boolean dateLeCompare(LocalDate targetDate1, LocalDate targetDate2) {
        if (targetDate1 == null || targetDate2 == null) {
            return false;
        }

        if ((targetDate1.isEqual(targetDate2) || targetDate1.isBefore(targetDate2))) {
            return true;
        }
        return false;
    }

}