zoukankan      html  css  js  c++  java
  • Java8中对时间的处理

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

    java8时间处理测试

    /**
     * java8时间处理测试
     * LocalDate、LocalTime、LocalDateTime
     * 说明:
     * <p>
     * 创建人: LGQ <br>
     * 创建时间: 2018年8月21日 下午1:52:28 <br>
     * <p>
     * 修改人: <br>
     * 修改时间: <br>
     * 修改备注: <br>
     * </p>
     */
    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));
    }
    

    运行效果如下:

    image.png

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

    package com.blog.www.util;
    
    
    import java.time.*;
    import java.time.format.DateTimeFormatter;
    import java.util.Date;
    
    /**
     * 基于java8封装的时间处理工具类
     * <p>
     * 创建人:leigq <br>
     * 创建时间:2018-11-07 09:21 <br>
     * <p>
     * 修改人: <br>
     * 修改时间: <br>
     * 修改备注: <br>
     * </p>
     */
    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) ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
    
        /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 时间格式 字符串 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    
        /**
         * 年的时间格式
         * <br/>
         * 返回 "yyyy" 字符串
         */
        public static final String YEAR_FORMAT = "yyyy";
    
        /**
         * 月的时间格式
         * <br/>
         * 返回 "MM" 字符串
         */
        public static final String MONTH_FORMAT = "MM";
    
        /**
         * 日的时间格式
         * <br/>
         * 返回 "dd" 字符串
         */
        public static final String DAY_FORMAT = "dd";
    
        /**
         * 时的时间格式
         * <br/>
         * 返回 "HH" 字符串
         */
        public static final String HOUR_FORMAT = "HH";
    
        /**
         * 分的时间格式
         * <br/>
         * 返回 "mm" 字符串
         */
        public static final String MINUTE_FORMAT = "mm";
    
        /**
         * 秒的时间格式
         * <br/>
         * 返回 "ss" 字符串
         */
        public static final String SECOND_FORMAT = "ss";
    
        /**
         * <span color='red'>年-月-日</span>的时间格式
         * <br/>
         * 返回 "yyyy-MM-dd" 字符串
         */
        public static final String DATE_FORMAT = YEAR_FORMAT + HYPHEN + MONTH_FORMAT + HYPHEN + DAY_FORMAT;
    
        /**
         * <span color='red'>时:分:秒</span>的时间格式
         * <br/>
         * 返回 "HH:mm:ss" 字符串
         */
        public static final String TIME_FORMAT = HOUR_FORMAT + COLON + MINUTE_FORMAT + COLON + SECOND_FORMAT;
    
        /**
         * <span color='red'>年-月-日 时:分:秒</span>的时间格式
         * <br/>
         * 返回 "yyyy-MM-dd HH:mm:ss" 字符串
         */
        public static final String DATE_TIME_FORMAT = DATE_FORMAT + " " + TIME_FORMAT;
    
        /**
         * <span color='red'>年月日时分秒</span>的时间格式(无符号)
         * <br/>
         * 返回 "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();
        }
    
        /*↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 当前时间相关 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑*/
    
    
    
        /*↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 未来、历史时间相关 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    
        /**
         * 获取当前年的 前几年 的日期
         * <p>
         *
         * @param years  前几年 正整数
         * @param format 格式
         * @return 当前年的 前几年 的 对应 格式 日期
         */
        public static String minusYears(Long years, FormatEnum formatEnum) {
            return minusOrPlusYears(-years, formatEnum);
        }
    
        /**
         * 获取当前年的 后几年 的日期
         * <p>
         *
         * @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
         * <p>
         *
         * @param date date类型时间
         * @return LocalDateTime
         */
        public static LocalDateTime toLocalDateTime(Date date) {
            return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        }
    
        /**
         * Date类型转LocalDate
         * <p>
         *
         * @param date date类型时间
         * @return LocalDate
         */
        public static LocalDate toLocalDate(Date date) {
            return toLocalDateTime(date).toLocalDate();
        }
    
        /**
         * Date类型转LocalTime
         * <p>
         *
         * @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 时间间隔天数
         * <br>创建人: leigq
         * <br>创建时间: 2018-11-07 09:55
         * <br>
         *
         * @param startDate 开始时间
         * @param endDate   结束时间
         * @return 时间间隔天数
         */
        public static Long daysInterval(LocalDate startDate, LocalDate endDate) {
            return endDate.toEpochDay() - startDate.toEpochDay();
        }
    
        /**
         * 获取 endDate-startDate 时间间隔天数
         * <br>创建人: leigq
         * <br>创建时间: 2018-11-07 09:55
         * <br>
         *
         * @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 时间间隔天数
         * <br>创建人: leigq
         * <br>创建时间: 2018-11-07 09:55
         * <br>
         *
         * @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);
        }
    
        /**
         * 获取 LocalDate
         */
        private static LocalDate localDate() {
            return localDateTime().toLocalDate();
        }
    
        /**
         * 获取 LocalTime
         */
        private static LocalTime localTime() {
            return localDateTime().toLocalTime();
        }
    
        /**
         * 获取 LocalDateTime
         */
        private static LocalDateTime localDateTime() {
            return LocalDateTime.now();
        }
    
    }
    

    参考

    Java8 时间类的使用
    Java 8 中 Date与LocalDateTime、LocalDate、LocalTime互转


    作者:不敲代码的攻城狮
    出处:https://www.cnblogs.com/leigq/
    任何傻瓜都能写出计算机可以理解的代码。好的程序员能写出人能读懂的代码。

     
  • 相关阅读:
    401. Binary Watch
    46. Permutations
    61. Rotate List
    142. Linked List Cycle II
    86. Partition List
    234. Palindrome Linked List
    19. Remove Nth Node From End of List
    141. Linked List Cycle
    524. Longest Word in Dictionary through Deleting
    android ListView详解
  • 原文地址:https://www.cnblogs.com/leigq/p/10850436.html
Copyright © 2011-2022 走看看