Java8中对时间的处理主要是LocalDate、LocalTime、LocalDateTime这几个类实现，直接看下面的测试代码，注释很详细。

@

java8时间处理测试

/**

* java8时间处理测试

* LocalDate、LocalTime、LocalDateTime

* 说明：

*

* 创建人: LGQ

* 创建时间: 2018年8月21日 下午1:52:28

*

* 修改人：

* 修改时间：

* 修改备注：

*

*/

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

}

运行效果如下：

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

package com.blog.www.util;

import java.time.*;

import java.time.format.DateTimeFormatter;

import java.util.Date;

/**

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

*

* 创建人：leigq

* 创建时间：2018-11-07 09:21

*

* 修改人：

* 修改时间：

* 修改备注：

*

*/

public class DateUtil {

private static final String HYPHEN = "-";

private static final String COLON = ":";

/*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间格式 DateTimeFormatter (Java8) ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/

enum FormatEnum {

/**

* 返回 DateTimeFormatter "yyyy-MM-dd HH:mm:ss" 时间格式

*/

FORMAT_DATA_TIME(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)),

/**

* 返回 DateTimeFormatter "yyyyMMddHHmmss"的时间格式

*/

FORMAT_DATA_TIME_NO_SYMBOL(DateTimeFormatter.ofPattern(DATETIME_FORMAT)),

/**

* 返回 DateTimeFormatter "yyyy-MM-dd"的时间格式

*/

FORMAT_DATE(DateTimeFormatter.ofPattern(DATE_FORMAT)),

/**

* 返回 DateTimeFormatter "HH:mm:ss"的时间格式

*/

FORMAT_TIME(DateTimeFormatter.ofPattern(TIME_FORMAT));

private DateTimeFormatter value;

FormatEnum(DateTimeFormatter format) {

this.value = format;

}

}

/*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 时间格式 DateTimeFormatter (Java8) ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/

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

/**

* 年的时间格式

*

* 返回 "yyyy" 字符串

*/

public static final String YEAR_FORMAT = "yyyy";

/**

* 月的时间格式

*

* 返回 "MM" 字符串

*/

public static final String MONTH_FORMAT = "MM";

/**

* 日的时间格式

*

* 返回 "dd" 字符串

*/

public static final String DAY_FORMAT = "dd";

/**

* 时的时间格式

*

* 返回 "HH" 字符串

*/

public static final String HOUR_FORMAT = "HH";

/**

* 分的时间格式

*

* 返回 "mm" 字符串

*/

public static final String MINUTE_FORMAT = "mm";

/**

* 秒的时间格式

*

* 返回 "ss" 字符串

*/

public static final String SECOND_FORMAT = "ss";

/**

* 年-月-日的时间格式

*

* 返回 "yyyy-MM-dd" 字符串

*/

public static final String DATE_FORMAT = YEAR_FORMAT + HYPHEN + MONTH_FORMAT + HYPHEN + DAY_FORMAT;

/**

* 时:分:秒的时间格式

*

* 返回 "HH:mm:ss" 字符串

*/

public static final String TIME_FORMAT = HOUR_FORMAT + COLON + MINUTE_FORMAT + COLON + SECOND_FORMAT;

/**

* 年-月-日 时:分:秒的时间格式

*

* 返回 "yyyy-MM-dd HH:mm:ss" 字符串

*/

public static final String DATE_TIME_FORMAT = DATE_FORMAT + " " + TIME_FORMAT;

/**

* 年月日时分秒的时间格式(无符号)

*

* 返回 "yyyyMMddHHmmss" 字符串

*/

public static final String DATETIME_FORMAT = YEAR_FORMAT + MONTH_FORMAT + DAY_FORMAT + HOUR_FORMAT + MINUTE_FORMAT + SECOND_FORMAT;

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

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

/**

* 获取秒级时间戳

*/

public static Long epochSecond() {

return localDateTime().toEpochSecond(ZoneOffset.of("+8"));

}

/**

* 获取毫秒级时间戳

*/

public static Long epochMilli() {

return localDateTime().toInstant(ZoneOffset.of("+8")).toEpochMilli();

}

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

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

/**

* 获取当前详细时间，like 2018-08-27 17:20:06

*/

public static String dateTime() {

return localDateTime().format(FormatEnum.FORMAT_DATA_TIME.value);

}

/**

* 获取当前详细时间，like 20180827172006

*/

public static String dateTimeNoSymbol() {

return localDateTime().format(FormatEnum.FORMAT_DATA_TIME_NO_SYMBOL.value);

}

/**

* 获取当前日期，like 2018-08-27

*/

public static String date() {

return localDate() + "";

}

/**

* 获取当前时间，like 17:20:06

*/

public static String time() {

return localTime().format(FormatEnum.FORMAT_TIME.value);

}

/**

* 获取当前年

*/

public static Integer year() {

return localDate().getYear();

}

/**

* 获取当前月

*/

public static int month() {

return localDate().getMonthValue();

}

/**

* 获取当前年中的日

*/

public static Integer dayOfYear() {

return localDate().getDayOfYear();

}

/**

* 获取当前月中的日

*/

public static Integer dayOfMonth() {

return localDate().getDayOfMonth();

}

/**

* 获取当前星期中的日

*/

public static Integer dayOfWeek() {

return localDate().getDayOfWeek().getValue();

}

/**

* 获取当前小时

*/

public static Integer hour() {

return localTime().getHour();

}

/**

* 获取当前分钟

*/

public static Integer minute() {

return localTime().getMinute();

}

/**

* 获取当前秒

*/

public static Integer second() {

return localTime().getSecond();

}

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

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

/**

* 获取当前年的 前几年 的日期

*

*

* @param years 前几年 正整数

* @param format 格式

* @return 当前年的 前几年 的 对应 格式 日期

*/

public static String minusYears(Long years, FormatEnum formatEnum) {

return minusOrPlusYears(-years, formatEnum);

}

/**

* 获取当前年的 后几年 的日期

*

*

* @param years 后几年 正整数

* @param format 格式

* @return 当前年的 后几年 的 对应 格式 日期

*/

public static String plusYears(Long years, FormatEnum formatEnum) {

return minusOrPlusYears(years, formatEnum);

}

/**

* 获取当前月的 前几月 日期

*

* @param months 前几月 正整数

* @param formatEnum 格式

* @return 当前月的 前几月 的 对应 格式 日期

*/

public static String minusMonths(Long months, FormatEnum formatEnum) {

return minusOrPlusMonths(-months, formatEnum);

}

/**

* 获取当前月的 后几月 的日期

*

* @param months 后几月 正整数

* @param formatEnum 格式

* @return 当前月的 后几月 的 对应 格式 日期

*/

public static String plusMonths(Long months, FormatEnum formatEnum) {

return minusOrPlusMonths(months, formatEnum);

}

/**

* 获取当前日的 前几日 的日期

*

* @param days 前几日 正整数

* @param formatEnum 格式

* @return 当前日的 前几日 的 对应 格式 日期

*/

public static String minusDays(Long days, FormatEnum formatEnum) {

return minusOrPlusDays(-days, formatEnum);

}

/**

* 获取当前日的 后几日 的日期

*

* @param days 后几日 正整数

* @param formatEnum 格式

* @return 当前日的 后几日 的 对应 格式 日期

*/

public static String plusDays(Long days, FormatEnum formatEnum) {

return minusOrPlusDays(days, formatEnum);

}

/**

* 获取当前星期的 前几星期 的日期

*

* @param weeks 前几星期 正整数

* @param formatEnum 格式

* @return 当前星期的 前几星期 的 对应 格式 日期

*/

public static String minusWeeks(Long weeks, FormatEnum formatEnum) {

return minusOrPlusWeeks(-weeks, formatEnum);

}

/**

* 获取当前星期的 后几星期 的日期

*

* @param weeks 后几星期 正整数

* @param formatEnum 格式

* @return 当前星期的 后几星期 的 对应 格式 日期

*/

public static String plusWeeks(Long weeks, FormatEnum formatEnum) {

return minusOrPlusWeeks(weeks, formatEnum);

}

/**

* 获取当前小时的 前几小时 的日期

*

* @param hours 前几小时 正整数

* @param formatEnum 格式

* @return 当前小时的 前几小时 的 对应 格式 日期

*/

public static String minusHours(Long hours, FormatEnum formatEnum) {

return minusOrPlusHours(-hours, formatEnum);

}

/**

* 获取当前小时的 后几小时 的日期

*

* @param hours 后几小时 正整数

* @param formatEnum 格式

* @return 当前小时的 后几小时 的 对应 格式 日期

*/

public static String plusHours(Long hours, FormatEnum formatEnum) {

return minusOrPlusHours(hours, formatEnum);

}

/**

* 获取当前分钟的 前几分钟 的日期

*

* @param minutes 前几分钟 正整数

* @param formatEnum 格式

* @return 当前分钟的 前几分钟 的 对应 格式 日期

*/

public static String minusMinutes(Long minutes, FormatEnum formatEnum) {

return minusOrPlusMinutes(-minutes, formatEnum);

}

/**

* 获取当前分钟的 后几分钟 的日期

*

* @param minutes 后几分钟 正整数

* @param formatEnum 格式

* @return 当前分钟的 后几分钟 的 对应 格式 日期

*/

public static String plusMinutes(Long minutes, FormatEnum formatEnum) {

return minusOrPlusMinutes(minutes, formatEnum);

}

/**

* 获取当前秒的 前几秒 的日期

*

* @param seconds 前几秒 正整数

* @param formatEnum 格式

* @return 当前秒的 前几秒 的 对应 格式 日期

*/

public static String minusSeconds(Long seconds, FormatEnum formatEnum) {

return minusOrPlusSeconds(-seconds, formatEnum);

}

/**

* 获取当前秒的 前几秒/后几秒 的日期

*

* @param seconds 后几秒 正整数

* @param formatEnum 格式

* @return 当前秒的 后几秒 的 对应 格式 日期

*/

public static String plusSeconds(Long seconds, FormatEnum formatEnum) {

return minusOrPlusSeconds(seconds, formatEnum);

}

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

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

/**

* Date类型转LocalDateTime

*

*

* @param date date类型时间

* @return LocalDateTime

*/

public static LocalDateTime toLocalDateTime(Date date) {

return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());

}

/**

* Date类型转LocalDate

*

*

* @param date date类型时间

* @return LocalDate

*/

public static LocalDate toLocalDate(Date date) {

return toLocalDateTime(date).toLocalDate();

}

/**

* Date类型转LocalTime

*

*

* @param date date类型时间

* @return LocalTime

*/

public static LocalTime toLocalTime(Date date) {

return toLocalDateTime(date).toLocalTime();

}

/**

* LocalDateTime 类型转 Date

*

* @param localDateTime localDateTime

* @return 转换后的Date类型日期

*/

public static Date toDate(LocalDateTime localDateTime) {

return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());

}

/**

* LocalDate类型转Date

*

* @param localDate localDate

* @return 转换后的Date类型日期

*/

public static Date toDate(LocalDate localDate) {

return toDate(localDate.atStartOfDay());

}

/**

* LocalTime类型转Date

*

* @param localTime localTime

* @return 转换后的Date类型日期

*/

public static Date toDate(LocalTime localTime) {

return toDate(LocalDateTime.of(localDate(), localTime));

}

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

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

/**

* 获取 endDate-startDate 时间间隔天数

*
创建人： leigq

*
创建时间： 2018-11-07 09:55

*

*

* @param startDate 开始时间

* @param endDate 结束时间

* @return 时间间隔天数

*/

public static Long daysInterval(LocalDate startDate, LocalDate endDate) {

return endDate.toEpochDay() - startDate.toEpochDay();

}

/**

* 获取 endDate-startDate 时间间隔天数

*
创建人： leigq

*
创建时间： 2018-11-07 09:55

*

*

* @param startDate 开始时间

* @param endDate 结束时间

* @return 时间间隔天数

*/

public static Long daysInterval(String startDate, String endDate) {

return daysInterval(LocalDateTime.parse(endDate, FormatEnum.FORMAT_DATA_TIME.value).toLocalDate(),

LocalDateTime.parse(startDate, FormatEnum.FORMAT_DATA_TIME.value).toLocalDate());

}

/**

* 获取 endDate-startDate 时间间隔天数

*
创建人： leigq

*
创建时间： 2018-11-07 09:55

*

*

* @param startDate 开始时间

* @param endDate 结束时间

* @return 时间间隔天数

*/

public static Long daysInterval(LocalDateTime startDate, LocalDateTime endDate) {

return daysInterval(startDate.toLocalDate(), endDate.toLocalDate());

}

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

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

/**

* 获取 当前年 的前几年/后几年的日期

*

*

* @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);

}

/**

* 获取 LocalDate

*/

private static LocalDate localDate() {

return localDateTime().toLocalDate();

}

/**

* 获取 LocalTime

*/

private static LocalTime localTime() {

return localDateTime().toLocalTime();

}

/**

* 获取 LocalDateTime

*/

private static LocalDateTime localDateTime() {

return LocalDateTime.now();

}

}