LocalDateTime(JAVA8)时间工具类

import org.apache.commons.lang3.StringUtils;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * @description: <br/>
 * 时间工具类
 * <p>
 * <br/>
 * @author: Qz1997
 * @create 2021/6/22 14:16
 */
@SuppressWarnings("unused")
public final class LocalDateTimeUtils {

    /**
     * 当前时间 减 多少小时
     *
     * @param hours 小时数
     * @return 时间 LocalDateTime类型
     */
    public static LocalDateTime tidyNow(int hours) {
        return tidy(null, hours);
    }

    /**
     * 当前时间 减 多少小时
     *
     * @param pattern 格式化
     * @param hours   小时数
     * @return 时间 String类型
     */
    public static String tidyNowString(String pattern, int hours) {
        return tidyString(null, pattern, hours);
    }

    /**
     * 指定时间 减 多少小时
     *
     * @param dateTime 时间
     * @param pattern  格式化
     * @param hours    小时数
     * @return 时间 String类型
     */
    public static String tidyString(LocalDateTime dateTime, String pattern, int hours) {
        return tidy(dateTime, hours).format(StringUtils.isBlank(pattern) ? LocalDateTimeUtils.Time.DATE_TIME_FORMAT_DEFAULT : DateTimeFormatter.ofPattern(pattern));
    }

    /**
     * 指定时间 减 多少小时
     *
     * @param dateTime 时间
     * @param hours    小时数
     * @return 时间 LocalDateTime类型
     */
    public static LocalDateTime tidy(LocalDateTime dateTime, int hours) {
        dateTime = null == dateTime ? LocalDateTime.now() : dateTime;
        LocalDateTime dateTimeTarget = dateTime.minusHours(hours);
        return LocalDateTime.of(dateTimeTarget.toLocalDate(), LocalTime.of(dateTimeTarget.getHour(), 0, 0));
    }

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

    /**
     * 格式化  指定格式
     *
     * @param dateTime 时间
     * @return 格式化后的时间
     */
    public static String formatDateTime(LocalDateTime dateTime, String pattern) {
        return dateTime.format(StringUtils.isBlank(pattern) ? LocalDateTimeUtils.Time.DATE_TIME_FORMAT_DEFAULT : DateTimeFormatter.ofPattern(pattern));
    }

    /**
     * 当前时间格式化  指定格式
     *
     * @param pattern 格式化
     * @return 格式化后的时间字符串
     */
    public static String now(String pattern) {
        return formatDateTime(LocalDateTime.now(), pattern);
    }

    /**
     * 当前时间格式化 默认格式为 yyyy-MM-dd HH:mm:ss
     *
     * @return 格式化后的时间串
     */
    public static String now() {
        return now(null);
    }

    /**
     * 获取之前几天 (不包含今天)
     *
     * @param days 之前的天数
     * @return 之前天数的LocalDate 的 list
     */
    public static List<LocalDate> listLatestDate(int days) {
        if (days <= 0) {
            throw new IllegalArgumentException("天数不能小于等于 0 ");
        }
        LocalDate today = LocalDate.now();
        return IntStream.range(0, days).mapToObj((index) -> today.plusDays(index - days)).collect(Collectors.toList());
    }

    /**
     * 获取之前几天 (包含今天)
     *
     * @param days 之前的天数
     * @return 之前天数的LocalDate 的 list
     */
    public static List<LocalDate> listLatestDateClosed(int days) {
        if (days <= 0) {
            throw new IllegalArgumentException("天数不能小于等于 0 ");
        }
        LocalDate today = LocalDate.now();
        return IntStream.rangeClosed(0, days).mapToObj((index) -> today.plusDays(index - days)).collect(Collectors.toList());

    }

    /**
     * 获取LocalDate最早的时间 2021年6月22日 00:00:00
     *
     * @param date LocalDate日期
     * @return LocalDateTime 时间
     */
    public static LocalDateTime begin(LocalDate date) {
        return LocalDateTime.of(null == date ? LocalDate.now() : date, LocalTime.MIN);
    }

    /**
     * 获取今天开始的时间
     *
     * @return 开始的时间 字符串
     */
    public static String beginDateString() {
        return beginString(null);
    }

    /**
     * 获取指定日期的开始时间 默认 yyyy-MM-dd HH:mm:ss
     *
     * @param date 指定日期
     * @return 开始的时间 字符串
     */
    public static String beginString(LocalDate date) {
        return beginString(date, null);
    }

    /**
     * 获取指定日期的开始时间 指定格式
     *
     * @param date    指定日期
     * @param pattern 格式
     * @return 开始的时间 字符串
     */
    public static String beginString(LocalDate date, String pattern) {
        return begin(Objects.isNull(date) ? LocalDate.now() : date).format(StringUtils.isBlank(pattern) ? LocalDateTimeUtils.Time.DATE_TIME_FORMAT_DEFAULT : DateTimeFormatter.ofPattern(pattern));
    }

    /**
     * 获取当前日期最后的时间  默认 yyyy-MM-dd HH:mm:ss
     *
     * @return 当前日期最后的时间  yyyy-MM-dd HH:mm:ss
     */
    public static String endString() {
        return endDateString(null);
    }

    /**
     * 获取指定日期最后的时间
     *
     * @param date 指定日期
     * @return 指定日期最后的时间 LocalDateTime
     */
    public static LocalDateTime end(LocalDate date) {
        return LocalDateTime.of(null == date ? LocalDate.now() : date, LocalTime.MAX);
    }

    /**
     * 获取指定日期最后的时间
     *
     * @param date 指定日期
     * @return 指定日期最后的时间 String
     */
    public static String endDateString(LocalDate date) {
        return end(date).format(LocalDateTimeUtils.Time.DATE_TIME_FORMAT_DEFAULT);
    }

    /**
     * 获取指定日期最后的时间
     *
     * @param date    指定日期
     * @param pattern 格式
     * @return 指定日期最后的时间 String
     */
    public static String endString(LocalDate date, String pattern) {
        return end(Objects.isNull(date) ? LocalDate.now() : date).format(StringUtils.isBlank(pattern) ? LocalDateTimeUtils.Time.DATE_TIME_FORMAT_DEFAULT : DateTimeFormatter.ofPattern(pattern));
    }

    /**
     * 获取指定时间与当前时间 间隔分钟数
     *
     * @param begin 指定时间
     * @return 间隔分钟
     */
    public static long goneMinutes(LocalDateTime begin) {
        return goneMinutes(begin, null);
    }

    /**
     * 指定的两个之间的 间隔分钟数
     *
     * @param begin 开始时间
     * @param end   结束时间
     * @return 间隔分钟
     */
    public static long goneMinutes(LocalDateTime begin, LocalDateTime end) {
        if (null == begin) {
            throw new IllegalArgumentException("时间不能为空");
        } else {
            return ChronoUnit.MINUTES.between(begin, null == end ? LocalDateTime.now() : end);
        }
    }

    /**
     * 获取指定时间与当前时间 间隔小时数
     *
     * @param begin 指定时间
     * @return 间隔小时
     */
    public static long goneHours(LocalDateTime begin) {
        return goneHours(begin, null);
    }

    /**
     * 指定的两个之间的 间隔小时数
     *
     * @param begin 开始时间
     * @param end   结束时间
     * @return 间隔小时
     */
    public static long goneHours(LocalDateTime begin, LocalDateTime end) {
        if (null == begin) {
            throw new IllegalArgumentException("时间不能为空");
        } else {
            return ChronoUnit.HOURS.between(begin, null == end ? LocalDateTime.now() : end);
        }
    }

    /**
     * 获取指定时间与当前时间 间隔天数
     *
     * @param begin 指定时间
     * @return 间隔天
     */
    public static long goneDays(LocalDate begin) {
        return goneDays(begin, null);
    }

    /**
     * 指定的两个之间的 间隔天数
     *
     * @param begin 开始时间
     * @param end   结束时间
     * @return 间隔天数
     */
    public static long goneDays(LocalDate begin, LocalDate end) {
        if (null == begin) {
            throw new IllegalArgumentException("LocalDateTime begin is null.");
        } else {
            return ChronoUnit.DAYS.between(begin, null == end ? LocalDate.now() : end);
        }
    }

    /**
     * 获取指定时间与当前时间 间隔月数
     *
     * @param begin 指定时间
     * @return 间隔月数
     */
    public static long goneMonths(LocalDate begin) {
        return goneMonths(begin, null);
    }

    /**
     * 指定的两个之间的 间隔月数
     *
     * @param begin 开始时间
     * @param end   结束时间
     * @return 间隔月数
     */
    public static long goneMonths(LocalDate begin, LocalDate end) {
        if (null == begin) {
            throw new IllegalArgumentException("开始时间不能为空");
        } else {
            return ChronoUnit.MONTHS.between(begin, null == end ? LocalDate.now() : end);
        }
    }

    /**
     * 获取指定时间与当前时间 间隔秒数
     *
     * @param begin 指定时间
     * @return 间隔秒数
     */
    public static long goneSeconds(LocalDateTime begin) {
        return goneSeconds(begin, null);
    }

    /**
     * 获取指定时间与当前时间 间隔秒数
     *
     * @param begin 指定时间
     * @return 间隔秒数
     */
    public static long goneSeconds(LocalDateTime begin, LocalDateTime end) {
        return ChronoUnit.SECONDS.between(begin, null == end ? LocalDateTime.now() : end);
    }

    /**
     * 解析字符串时间 默认 yyyy-MM-dd HH:mm:ss
     *
     * @param dateTime 默认 yyyy-MM-dd HH:mm:ss 的时间字符串
     * @return 解析后的LocalDateTime
     */
    public static LocalDateTime parseDateTime(String dateTime) {
        return parseDateTime(dateTime, null);
    }

    /**
     * 解析字符串时间 指定格式
     *
     * @param dateTime 默认 yyyy-MM-dd HH:mm:ss 的时间字符串
     * @param pattern  格式
     * @return 解析后的LocalDateTime
     */
    public static LocalDateTime parseDateTime(String dateTime, String pattern) {
        if (StringUtils.isBlank(dateTime)) {
            throw new IllegalArgumentException("时间不能为空");
        } else {
            return LocalDateTime.parse(dateTime, DateTimeFormatter.ofPattern(null == pattern ? Time.DATE_TIME_PATTERN_DEFAULT : pattern));
        }
    }

    /**
     * 解析字符串时间 默认 yyyy-MM-dd
     *
     * @param date 默认 yyyy-MM-dd 的时间字符串
     * @return 解析后的LocalDate
     */
    public static LocalDate parseDate(String date) {
        return parseDate(date, null);
    }

    /**
     * 解析字符串时间 指定格式
     *
     * @param date    默认 yyyy-MM-dd 的时间字符串
     * @param pattern 指定格式
     * @return 解析后的LocalDate
     */
    public static LocalDate parseDate(String date, String pattern) {
        if (StringUtils.isBlank(date)) {
            throw new IllegalArgumentException("时间不能为空");
        } else {
            return LocalDate.parse(date, DateTimeFormatter.ofPattern(null == pattern ? Time.DATE_PATTERN : pattern));
        }
    }

    /**
     * 解析字符串时间 指定格式
     *
     * @param time 默认  HH:mm:ss 的时间字符串
     * @return 解析后的LocalTime
     */
    public static LocalTime parseTime(String time) {
        return parseTime(time, null);
    }

    /**
     * 解析字符串时间 指定格式
     *
     * @param time    默认  HH:mm:ss 的时间字符串
     * @param pattern 格式
     * @return 解析后的LocalTime
     */
    public static LocalTime parseTime(String time, String pattern) {
        if (StringUtils.isBlank(time)) {
            throw new IllegalArgumentException("时间不能为空");
        } else {
            return LocalTime.parse(time, DateTimeFormatter.ofPattern(null == pattern ? Time.TIME_PATTERN : pattern));
        }
    }

    /**
     * 时间戳 =>  LocalDateTime
     *
     * @param timestamp 时间戳
     * @return 该时间戳对应的 LocalDateTime
     */
    public static LocalDateTime timestamp2DateTime(long timestamp) {
        return LocalDateTime.ofEpochSecond(timestamp / 1000L, 0, ZoneOffset.ofHours(8));
    }

    /**
     * LocalDateTime => 时间戳
     *
     * @param localDateTime 时间戳
     * @return LocalDateTime时间对应的时间戳
     */
    public static long dateTime2Timestamp(LocalDateTime localDateTime) {
        return localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
    }

    /**
     * Date =>  LocalDateTime
     *
     * @param date Date
     * @return 该时间对应的 LocalDateTime
     */
    public static LocalDateTime date2LocalDateTime(Date date) {
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
    }

    /**
     * Date =>  LocalDate
     *
     * @param date Date
     * @return 该时间对应的 LocalDate
     */
    public static LocalDate date2LocalDate(Date date) {
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()).toLocalDate();
    }

    /**
     * Date =>  LocalTime
     *
     * @param date Date
     * @return 该时间对应的 LocalTime
     */
    public static LocalTime date2LocalTime(Date date) {
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()).toLocalTime();
    }

    /**
     * localDateTime =>  Date
     *
     * @param localDateTime localDateTime
     * @return 该时间对应的 Date
     */
    public static Date localDateTime2Date(LocalDateTime localDateTime) {
        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * localDate =>  Date
     *
     * @param localDate localDate
     * @return 该时间对应的 Date
     */
    public static Date localDate2Date(LocalDate localDate) {
        return Date.from(localDate.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * localTime =>  Date
     *
     * @param localTime localTime
     * @return 该时间对应的 Date
     */
    public static Date localTime2Date(LocalTime localTime) {
        return Date.from(localTime.atDate(LocalDate.now()).atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 时间格式
     */
    public interface Time {
        String DATE_TIME_PATTERN_DEFAULT = "yyyy-MM-dd HH:mm:ss";
        String DATE_TIME_PATTERN_TINY = "yyyyMMddHHmmss";
        String DATE_PATTERN = "yyyy-MM-dd";
        String TIME_PATTERN = "HH:mm:ss";
        DateTimeFormatter DATE_TIME_FORMAT_DEFAULT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        DateTimeFormatter DATE_TIME_FORMAT_TINY = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
        DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        DateTimeFormatter TIME_FORMAT = DateTimeFormatter.ofPattern("HH:mm:ss");

    }
}