java8时间处理

java8时间处理

关键类

• Instant：瞬时实例。

• LocalDate：本地日期，不包含具体时间 例如：2014-01-14 可以用来记录生日、纪念日、加盟日等。

• LocalTime：本地时间，不包含日期。

• LocalDateTime：组合了日期和时间，但不包含时差和时区信息。

• ZonedDateTime：最完整的日期时间，包含时区和相对UTC或格林威治的时差。

新API还引入了 ZoneOffSet 和 ZoneId 类，使得解决时区问题更为简便。解析、格式化时间的 DateTimeFormatter 类也全部重新设计。

测试：

public static void java8DateTest() {
    /**
     * LocalDate
     */
    System.out.println(">>>>>>>>>LocalDate<<<<<<<<");
    
    //获取当前日期,2018-08-21
    LocalDate localDate = LocalDate.now();
    System.err.println("当前日期>" + localDate);
    
    //获取当前年 2018
    System.err.println(localDate + "当前年>" + localDate.getYear());
    
    //获取当前月 8
    System.err.println(localDate + "当前月>" + localDate.getMonthValue());
    
    //获取当前年中的日 233
    System.err.println(localDate + "当前年中的日>" + localDate.getDayOfYear());
    
    //获取当前月中的日 21
    System.err.println(localDate + "当前月中的日>" + localDate.getDayOfMonth());
    
    //获取当前星期中的日 2
    System.err.println(localDate + "当前星期中的日>" + localDate.getDayOfWeek().getValue());
    
    //当前日期前一天,2018-08-20 minus:（表示运算）减去
    System.err.println(localDate + "前一天>" + localDate.minusDays(1));
    
    //当前日期后一天,2018-08-20 plus:（表示运算）加
    System.err.println(localDate + "后一天>" + localDate.plusDays(1));
    
    //当前日期前一月,2018-07-21 minus:（表示运算）减去
    System.err.println(localDate + "前一月>" + localDate.minusMonths(1));
    
    //当前日期后一月,2018-09-21 plus:（表示运算）加
    System.err.println(localDate + "后一月>" + localDate.plusMonths(1));
    
    //当前日期前一年,2017-08-21 minus:（表示运算）减去
    System.err.println(localDate + "前一年>" + localDate.minusYears(1));
    
    //当前日期后一年,2019-08-21 plus:（表示运算）加
    System.err.println(localDate + "后一年>" + localDate.plusYears(1));
    
    //当前日期前一周,2018-08-14 minus:（表示运算）减去
    System.err.println(localDate + "前一周>" + localDate.minusWeeks(1));
    
    //当前日期后一周,2018-08-28 plus:（表示运算）加
    System.err.println(localDate + "后一周>" + localDate.plusWeeks(1));
    
    
    /**
     * LocalTime
     */
    System.out.println(">>>>>>>>>LocalTime<<<<<<<<");
    //获取当前时间 11:36:13.693
    LocalTime localTime = LocalTime.now();
    System.err.println("当前时间>" + localTime);
    
    //获取当前时 11
    System.err.println(localTime + "当前时>" + localTime.getHour());
    
    //获取当前分 38
    System.err.println(localTime + "当前分>" + localTime.getMinute());
    
    //获取当前秒 26
    System.err.println(localTime + "当前秒>" + localTime.getSecond());
    
    //当前时间前一时,11:36:12.693 minus:（表示运算）减去
    System.err.println(localTime + "前一时>" + localTime.minusHours(1));
    
    //当前时间后一时,11:36:12.693 minus:（表示运算）减去
    System.err.println(localTime + "后一时>" + localTime.plusHours(1));
    
    //当前时间前一分,11:39:05.970 minus:（表示运算）减去
    System.err.println(localTime + "前一分>" + localTime.minusMinutes(1));
    
    //当前时间后一分,11:36:12.693 minus:（表示运算）减去
    System.err.println(localTime + "后一分>" + localTime.plusMinutes(1));
    
    //当前时间前一秒,11:36:12.693 minus:（表示运算）减去
    System.err.println(localTime + "前一秒>" + localTime.minusSeconds(1));
    
    //当前时间后一秒,11:36:12.693 minus:（表示运算）减去
    System.err.println(localTime + "后一秒>" + localTime.plusSeconds(1));
    
    /**
     * localDateTime
     * LocalDateTime类是Java 8中日期时间功能里，用于表示当地的日期与时间的类，它的值是无时区属性的。
     * 你可以将其视为Java 8中LocalDate与LocalTime两个类的结合。
     * 你可以通过这些方法访问其日期时间
     *     getYear()
        getMonth()
        getDayOfMonth()
        getDayOfWeek()
        getDayOfYear()
        getHour()
        getMinute()
        getSecond()
        getNano()
     */
    System.out.println(">>>>>>>>>localDateTime<<<<<<<<");
    
    LocalDateTime localDateTime = LocalDateTime.now();
    System.err.println("当前完整日期>" + localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
    
    
    /**
     * 时间格式化
     */
    System.out.println(">>>>>>>>>时间格式化<<<<<<<<");
    
    DateTimeFormatter formatDataTime = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    DateTimeFormatter formatDate = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    DateTimeFormatter formatTime = DateTimeFormatter.ofPattern("HH:mm:ss");
    
    String formatDataTimeStr = localDateTime.format(formatDataTime);
    String formatDateStr = localDateTime.format(formatDate);
    String formatTimeStr = localDateTime.format(formatTime);
    
    System.err.println("完整日期格式化之后" + formatDataTimeStr);
    System.err.println("日期格式化之后" + formatDateStr);
    System.err.println("时间格式化之后" + formatTimeStr);
    
    /**
     * 时间比较大小
     */
    System.out.println(">>>>>时间比较大小<<<<<");
    
    LocalDateTime time1 = LocalDateTime.parse("2018-05-12 08:30:30", formatDataTime);
    LocalDateTime time2 = LocalDateTime.parse("2018-04-20 16:30:30", formatDataTime);
    
    System.err.println("time1=" + time1);
    System.err.println("time2=" + time2);
    
    System.err.println("time1==time2:" + time1.isEqual(time2));
    System.err.println("time1>time2:" + time1.isAfter(time2));
    System.err.println("time1<time2:" + time1.isBefore(time2));
}

基于java8封装的时间处理工具类

package com.ipw.utils;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Date;

/**
 * @Author dw
 * @ClassName DateUtil
 * @Description
 * @Date 2020/8/25 16:39
 * @Version 1.0
 */
public class DateUtil {

    /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间格式的连接符 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    /**
     * 连接符 -
     */
    private static final String HYPHEN = "-";
    /**
     * 连接符 ：
     */
    private static final String COLON = ":";

    /**
     * 连接符 .
     */
    private static final String POINT = ".";

    /**
     * 连接符 "年"
     */
    private static final String YEAR = "年";

    /**
     * 连接符 "月"
     */
    private static final String MONTH = "月";

    /**
     * 连接符 "日"
     */
    private static final String DAY = "日";


    /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间格式 字符串 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/

    /**
     * 年的时间格式
     * 返回 "yyyy" 字符串
     */
    public static final String YEAR_FORMAT_YYYY = "yyyy";

    /**
     * 月的时间格式
     * 返回 "MM" 字符串
     */
    public static final String MONTH_FORMAT_MM = "MM";

    /**
     * 日的时间格式
     * 返回 "dd" 字符串
     */
    public static final String DAY_FORMAT_DD = "dd";

    /**
     * 小时的时间格式
     * 返回 "HH" 字符串
     */
    public static final String HOUR_FORMAT_HH = "HH";

    /**
     * 分的时间格式
     * 返回 "mm" 字符串
     */
    public static final String MINUTE_FORMAT_MM = "mm";

    /**
     * 秒的时间格式
     * 返回 "ss" 字符串
     */
    public static final String SECOND_FORMAT_SS = "ss";

    /**
     * 返回 "yyyy-MM-dd" 字符串
     */
    public static final String DATE_FORMAT_HYPHEN = new StringBuffer()
            .append(YEAR_FORMAT_YYYY)
            .append(HYPHEN)
            .append(MONTH_FORMAT_MM)
            .append(HYPHEN)
            .append(DAY_FORMAT_DD).toString();
    /**
     * 返回 "yyyy:MM:dd" 字符串
     */
    public static final String DATE_FORMAT_COLON = new StringBuffer()
            .append(YEAR_FORMAT_YYYY)
            .append(COLON)
            .append(MONTH_FORMAT_MM)
            .append(COLON)
            .append(DAY_FORMAT_DD).toString();

    /**
     * 返回  "yyyy年MM月dd日" 字符串
     */
    public static final String DATE_FORMAT_CHINESE = new StringBuffer()
            .append(YEAR_FORMAT_YYYY)
            .append(YEAR)
            .append(MONTH_FORMAT_MM)
            .append(MONTH)
            .append(DAY_FORMAT_DD)
            .append(DAY).toString();

    /**
     * 返回  "yyyy.MM.dd" 字符串
     */
    public static final String DATE_FORMAT_POINT = new StringBuffer()
            .append(YEAR_FORMAT_YYYY)
            .append(POINT)
            .append(MONTH_FORMAT_MM)
            .append(POINT)
            .append(DAY_FORMAT_DD).toString();
    /**
     * 返回  "yyyyMMdd" 字符串
     */
    public static final String DATE_FORMAT_WITH_NO_JOINER = new StringBuffer()
            .append(YEAR_FORMAT_YYYY)
            .append(MONTH_FORMAT_MM)
            .append(DAY_FORMAT_DD).toString();

    /**
     * 返回 "HH:mm:ss" 字符串
     */
    public static final String TIME_FORMAT_COLON = new StringBuffer()
            .append(HOUR_FORMAT_HH)
            .append(COLON)
            .append(MINUTE_FORMAT_MM)
            .append(COLON)
            .append(SECOND_FORMAT_SS).toString();

    /**
     * 返回 "HHmmss" 字符串
     */
    public static final String TIME_FORMAT_NO_JOINER = new StringBuffer()
            .append(HOUR_FORMAT_HH)
            .append(MINUTE_FORMAT_MM)
            .append(SECOND_FORMAT_SS).toString();

    /**
     * 返回 "yyyy-MM-dd HH:mm:ss" 字符串
     */
    public static final String DATE_TIME_FORMAT_HYPHEN = new StringBuffer()
            .append(DATE_FORMAT_HYPHEN)
            .append(" ")
            .append(TIME_FORMAT_COLON).toString();
    /**
     * 返回 "yyyyMMddHHmmss" 字符串
     */
    public static final String DATE_TIME_FORMAT_WITH_NO_JOINER = new StringBuffer()
            .append(DATE_FORMAT_WITH_NO_JOINER)
            .append(TIME_FORMAT_NO_JOINER).toString();


    /*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间格式 字符串 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/


    /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间格式 DateTimeFormatter (Java8) ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
  public  enum FormatEnum {
        /**
         * 返回 DateTimeFormatter "yyyy-MM-dd" 时间格式
         */
        DATE_FORMAT_HYPHEN(DateTimeFormatter.ofPattern(DateUtil.DATE_FORMAT_HYPHEN)),

        /**
         * 返回 DateTimeFormatter "yyyy:MM:dd" 时间格式
         */
        DATE_FORMAT_COLON(DateTimeFormatter.ofPattern(DateUtil.DATE_FORMAT_COLON)),

        /**
         * 返回 DateTimeFormatter "yyyy年MM月dd日" 时间格式
         */
        DATE_FORMAT_CHINESE(DateTimeFormatter.ofPattern(DateUtil.DATE_FORMAT_CHINESE)),

        /**
         * 返回 DateTimeFormatter "yyyy.MM.dd日" 时间格式
         */
        DATE_FORMAT_POINT(DateTimeFormatter.ofPattern(DateUtil.DATE_FORMAT_POINT)),

        /**
         * 返回 DateTimeFormatter "yyyyMMdd"  时间格式
         */
        DATE_FORMAT_WITH_NO_JOINER(DateTimeFormatter.ofPattern(DateUtil.DATE_FORMAT_WITH_NO_JOINER)),

        /**
         * 返回 DateTimeFormatter "HH:mm:ss"  时间格式
         */
        TIME_FORMAT_COLON(DateTimeFormatter.ofPattern(DateUtil.TIME_FORMAT_COLON)),

        /**
         * 返回 DateTimeFormatter "yyyy-MM-dd HH:mm:ss" 时间格式
         */
        DATE_TIME_FORMAT_HYPHEN(DateTimeFormatter.ofPattern(DateUtil.DATE_TIME_FORMAT_HYPHEN)),

        /**
         * 返回 DateTimeFormatter "yyyyMMddHHmmss"的时间格式
         */
        DATE_TIME_FORMAT_WITH_NO_JOINER(DateTimeFormatter.ofPattern(DateUtil.DATE_TIME_FORMAT_WITH_NO_JOINER));


        private DateTimeFormatter value;

        FormatEnum(DateTimeFormatter format) {
            this.value = format;
        }
    }
    /*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间格式 DateTimeFormatter (Java8) ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/


    /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间戳 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/

    /**
     * 获取秒级时间戳
     */
    public static Long currentTimestampBySecond() {
        return localDateTime().toEpochSecond(ZoneOffset.of("+8"));
    }

    /**
     * 获取毫秒级时间戳
     */
    public static Long currentTimestampByMillisecond() {
        return localDateTime().toInstant(ZoneOffset.of("+8")).toEpochMilli();
    }

    /*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间戳 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/


    /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 当前时间相关 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/

    /**
     * 获取当前详细时间，like 2018-08-27 17:20:06
     */
    public static String currentDateTime() {
        return localDateTime().format(FormatEnum.DATE_TIME_FORMAT_HYPHEN.value);
    }

    /**
     * 获取当前详细时间，like 20180827172006
     */
    public static String currentDateTimeNoJoiner() {
        return localDateTime().format(FormatEnum.DATE_TIME_FORMAT_WITH_NO_JOINER.value);
    }
    /**
     * 获取 LocalDateTime
     */
    private static LocalDateTime localDateTime() {
        return LocalDateTime.now();
    }

    /**
     * 获取当前日期，like 2018-08-27
     */
    public static String currentDate() {
        return LocalDate.now().format(FormatEnum.DATE_FORMAT_HYPHEN.value);
    }

    /**
     * 获取当前时间，like 17:20:06
     */
    public static String currentTime() {
        return LocalTime.now().format(FormatEnum.TIME_FORMAT_COLON.value);
    }

    /**
     * 获取当前年
     */
    public static Integer currentYear() {
        return LocalDate.now().getYear();
    }

    /**
     * 获取当前月
     */
    public static int currentMonth() {
        return LocalDate.now().getMonthValue();
    }

    /**
     * 获取当前时间在年中的第几天
     */
    public static Integer currentDayOfYear() {
        return LocalDate.now().getDayOfYear();
    }

    /**
     * 获取当前时间在月中的第几天
     */
    public static Integer currentDayOfMonth() {
        return LocalDate.now().getDayOfMonth();
    }

    /**
     * 获取当前时间在星期中的第几天
     */
    public static Integer currentDayOfWeek() {
        return LocalDate.now().getDayOfWeek().getValue();
    }

    /**
     * 获取当前小时
     */
    public static Integer currentHour() {
        return LocalTime.now().getHour();
    }

    /**
     * 获取当前分钟
     */
    public static Integer currentMinute() {
        return LocalTime.now().getMinute();
    }

    /**
     * 获取当前秒
     */
    public static Integer currentSecond() {
        return LocalTime.now().getSecond();
    }

    /*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 当前时间相关 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/



    /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 当前时间的未来、历史时间相关 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/

    /**
     * 获取当前年的 前几年 的日期 (年相减)
     * @param years      前几年 正整数
     * @param formatEnum 格式
     * @return 当前年的 前几年 的 对应 格式 日期
     */
    public static String currentYearsMinus(Long years, FormatEnum formatEnum) {
        return minusOrPlusYears(-years, formatEnum);
    }

    /**
     * 获取当前年的 后几年 的日期 （年相加）
     * @param years      后几年 正整数
     * @param formatEnum 格式
     * @return 当前年的 后几年 的 对应 格式 日期
     */
    public static String currentYearsPlus(Long years, FormatEnum formatEnum) {
        return minusOrPlusYears(years, formatEnum);
    }

    /**
     * 获取当前月的 前几月 日期
     * @param months     前几月 正整数
     * @param formatEnum 格式
     * @return 当前月的 前几月 的 对应 格式 日期
     */
    public static String currentMonthsMinus(Long months, FormatEnum formatEnum) {
        return minusOrPlusMonths(-months, formatEnum);
    }

    /**
     * 获取当前月的 后几月 的日期
     * @param months     后几月 正整数
     * @param formatEnum 格式
     * @return 当前月的 后几月 的 对应 格式 日期
     */
    public static String currentMonthsPlus(Long months, FormatEnum formatEnum) {
        return minusOrPlusMonths(months, formatEnum);
    }

    /**
     * 获取当前日的 前几日 的日期
     * @param days       前几日 正整数
     * @param formatEnum 格式
     * @return 当前日的 前几日 的 对应 格式 日期
     */
    public static String currentDaysMinus(Long days, FormatEnum formatEnum) {
        return minusOrPlusDays(-days, formatEnum);
    }

    /**
     * 获取当前日的 后几日 的日期
     * @param days       后几日 正整数
     * @param formatEnum 格式
     * @return 当前日的 后几日 的 对应 格式 日期
     */
    public static String currentDaysPlus(Long days, FormatEnum formatEnum) {
        return minusOrPlusDays(days, formatEnum);
    }

    /**
     * 获取当前星期的 前几星期 的日期
     * @param weeks      前几星期 正整数
     * @param formatEnum 格式
     * @return 当前星期的 前几星期 的 对应 格式 日期
     */
    public static String currentWeeksMinus(Long weeks, FormatEnum formatEnum) {
        return minusOrPlusWeeks(-weeks, formatEnum);
    }

    /**
     * 获取当前星期的 后几星期 的日期
     * @param weeks      后几星期 正整数
     * @param formatEnum 格式
     * @return 当前星期的 后几星期 的 对应 格式 日期
     */
    public static String currentWeeksPlus(Long weeks, FormatEnum formatEnum) {
        return minusOrPlusWeeks(weeks, formatEnum);
    }

    /**
     * 获取当前小时的 前几小时 的日期
     * @param hours      前几小时 正整数
     * @param formatEnum 格式
     * @return 当前小时的 前几小时 的 对应 格式 日期
     */
    public static String currentHoursMinus(Long hours, FormatEnum formatEnum) {
        return minusOrPlusHours(-hours, formatEnum);
    }

    /**
     * 获取当前小时的 后几小时 的日期
     * @param hours      后几小时 正整数
     * @param formatEnum 格式
     * @return 当前小时的 后几小时 的 对应 格式 日期
     */
    public static String currentHoursPlus(Long hours, FormatEnum formatEnum) {
        return minusOrPlusHours(hours, formatEnum);
    }

    /**
     * 获取当前分钟的 前几分钟 的日期
     * @param minutes    前几分钟 正整数
     * @param formatEnum 格式
     * @return 当前分钟的 前几分钟 的 对应 格式 日期
     */
    public static String currentMinutesMinus(Long minutes, FormatEnum formatEnum) {
        return minusOrPlusMinutes(-minutes, formatEnum);
    }

    /**
     * 获取当前分钟的 后几分钟 的日期
     * @param minutes    后几分钟 正整数
     * @param formatEnum 格式
     * @return 当前分钟的 后几分钟 的 对应 格式 日期
     */
    public static String currentMinutesPlus(Long minutes, FormatEnum formatEnum) {
        return minusOrPlusMinutes(minutes, formatEnum);
    }

    /**
     * 获取当前秒的 前几秒 的日期
     * @param seconds    前几秒 正整数
     * @param formatEnum 格式
     * @return 当前秒的 前几秒 的 对应 格式 日期
     */
    public static String currentSecondsMinus(Long seconds, FormatEnum formatEnum) {
        return minusOrPlusSeconds(-seconds, formatEnum);
    }

    /**
     * 获取当前秒的 前几秒/后几秒 的日期
     * @param seconds    后几秒 正整数
     * @param formatEnum 格式
     * @return 当前秒的 后几秒 的 对应 格式 日期
     */
    public static String currentSecondsPlus(Long seconds, FormatEnum formatEnum) {
        return minusOrPlusSeconds(seconds, formatEnum);
    }

    /*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 当前时间的未来、历史时间相关 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/


    /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间转换相关 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/

    /**
     * Date类型转LocalDateTime
     * @param date date类型时间
     * @return LocalDateTime
     */
    public static LocalDateTime convertToLocalDateTime(Date date) {
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
    }

    /**
     * Date类型转LocalDate
     * @param date date类型时间
     * @return LocalDate
     */
    public static LocalDate convertToLocalDate(Date date) {
        return convertToLocalDateTime(date).toLocalDate();
    }

    /**
     * Date类型转LocalTime
     * @param date date类型时间
     * @return LocalTime
     */
    public static LocalTime convertToLocalTime(Date date) {
        return convertToLocalDateTime(date).toLocalTime();
    }

    /**
     * LocalDateTime 类型转 Date
     * @param localDateTime localDateTime
     * @return 转换后的Date类型日期
     */
    public static Date convertToDate(LocalDateTime localDateTime) {
        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * LocalDate类型转Date
     * @param localDate localDate
     * @return 转换后的Date类型日期
     */
    public static Date convertToDate(LocalDate localDate) {
        return convertToDate(localDate.atStartOfDay());
    }

    /**
     * LocalTime类型转Date
     *
     * @param localTime localTime
     * @return 转换后的Date类型日期
     */
    public static Date convertToDate(LocalTime localTime) {
        return convertToDate(LocalDateTime.of(LocalDate.now(), localTime));
    }
    /**
     * String格式 转 LocalDateTime
     */
    public static LocalDateTime convertToLocalDateTime(String dateStr, FormatEnum formatEnum){
        LocalDateTime localDateTime = LocalDateTime.parse(dateStr, formatEnum.value);
        return localDateTime;
    }

    /**
     * String格式 转 LocalDate
     */
    public static LocalDate convertToLocalDate(String dateStr, FormatEnum formatEnum){
        LocalDate localDate = LocalDateTime.parse(dateStr, formatEnum.value).toLocalDate();
        return localDate;
    }

    /**
     * LocalDateTime 转  String格式
     */
    public static String convertToStr(LocalDateTime localDateTime, FormatEnum formatEnum){
        String format = localDateTime.format(formatEnum.value);
        return format;
    }

    /**
     * LocalDate  转 String格式
     */
    public static String convertToStr(LocalDate localDate, FormatEnum formatEnum){
        String strData = localDate.format(formatEnum.value);
        return strData;
    }


    /*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间转换相关 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/


    /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间间隔相关 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/

    /**
     * 获取 endDate-startDate 时间间隔天数
     * @param startDate 开始时间
     * @param endDate   结束时间
     * @return 时间间隔天数
     */
    public static Long daysInterval(LocalDate startDate, LocalDate endDate) {
        return endDate.toEpochDay() - startDate.toEpochDay();
    }

    /**
     * 获取 endDate-startDate 时间间隔天数
     * @param startDate 开始时间
     * @param endDate   结束时间
     * @return 时间间隔天数
     */
    public static Long daysInterval(String startDate, String endDate) {
        return daysInterval(convertToLocalDate(startDate, FormatEnum.DATE_FORMAT_HYPHEN),
                convertToLocalDate(endDate, FormatEnum.DATE_FORMAT_HYPHEN));
    }

    /**
     * 获取 endDate-startDate 时间间隔天数
     * @param startDate 开始时间
     * @param endDate   结束时间
     * @return 时间间隔天数
     */
    public static Long daysInterval(LocalDateTime startDate, LocalDateTime endDate) {
        return daysInterval(startDate.toLocalDate(), endDate.toLocalDate());
    }

    /*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间间隔相关 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/


    /*↓↓↓只允许此类调用↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/

    /**
     * 获取 当前年 的前几年/后几年的日期
     * <p>
     *
     * @param yearsToAddOrSubtract 后几年传正整数，前几年传负数
     * @param formatEnum           格式
     * @return 当前年的前几年/后几年的对应 格式 日期
     */
    private static String minusOrPlusYears(Long yearsToAddOrSubtract, FormatEnum formatEnum) {
        return localDateTime().plusYears(yearsToAddOrSubtract).format(formatEnum.value);
    }

    /**
     * 获取 当前月 的前几月/后几月的日期
     *
     * @param monthsToAddOrSubtract 后几月传正整数，前几月传负数
     * @param formatEnum            格式
     * @return 当前月的前几月/后几月的对应 格式 日期
     */
    private static String minusOrPlusMonths(Long monthsToAddOrSubtract, FormatEnum formatEnum) {
        return localDateTime().plusMonths(monthsToAddOrSubtract).format(formatEnum.value);
    }

    /**
     * 获取 当前日 的前几日/后几日的日期
     *
     * @param daysToAddOrSubtract 后几日传正整数，前几日传负数
     * @param formatEnum          格式
     * @return 当前日的前几日/后几日的 对应 格式 日期
     */
    private static String minusOrPlusDays(Long daysToAddOrSubtract, FormatEnum formatEnum) {
        return localDateTime().plusDays(daysToAddOrSubtract).format(formatEnum.value);
    }

    /**
     * 获取当前星期的前几星期/后几星期的日期
     *
     * @param weeksToAddOrSubtract 后几星期传正整数，前几星期传负数
     * @param formatEnum           格式
     * @return 当前星期的前几星期/后几星期的 对应 格式 日期
     */
    private static String minusOrPlusWeeks(Long weeksToAddOrSubtract, FormatEnum formatEnum) {
        return localDateTime().plusWeeks(weeksToAddOrSubtract).format(formatEnum.value);
    }

    /**
     * 获取当前小时的前几小时/后几小时的日期
     *
     * @param hoursToAddOrSubtract 后几小时传正整数，前几小时传负数
     * @param formatEnum           格式
     * @return 当前小时的前几小时/后几小时的 对应 格式 日期
     */
    private static String minusOrPlusHours(Long hoursToAddOrSubtract, FormatEnum formatEnum) {
        return localDateTime().plusHours(hoursToAddOrSubtract).format(formatEnum.value);
    }

    /**
     * 获取当前分钟的前几分钟/后几分钟的日期
     *
     * @param minutesToAddOrSubtract 后几分钟传正整数，前几分钟传负数
     * @param formatEnum             格式
     * @return 当前分钟的前几分钟/后几分钟的 对应 格式 日期
     */
    private static String minusOrPlusMinutes(Long minutesToAddOrSubtract, FormatEnum formatEnum) {
        return localDateTime().plusMinutes(minutesToAddOrSubtract).format(formatEnum.value);
    }

    /**
     * 获取当前秒的前几秒/后几秒的日期
     *
     * @param secondsToAddOrSubtract 后几秒传正整数，前几秒传负数
     * @param formatEnum             格式
     * @return 当前秒的前几秒/后几秒的 对应 格式 日期
     */
    private static String minusOrPlusSeconds(Long secondsToAddOrSubtract, FormatEnum formatEnum) {
        return localDateTime().plusSeconds(secondsToAddOrSubtract).format(formatEnum.value);
    }



    /**
     * 处理mysql timestamp 转JavaString 多个.0的问题
     */
    private  static String handlerStrDate(String dataTime){
        return dataTime.substring(0, dataTime.length()-2);
    }



}