Java-Datum LocalDate LocalDateTime

Java-Datum LocalDate LocalDateTime

Date LocalDate LocalDateTime ist ein in Java häufig verwendeter Zeittyp, der häufig in der Arbeit verwendet wird.
Das Schreiben von Codes für viele gängige Funktionen ist jedoch jedes Mal mühsam, daher die folgenden drei Tools Klassen sind gekapselt:

• DateUtil-Datumstoolklasse
• LocalDateUtil neue Datumstoolklasse
• LocalDateTimeUtil neue Datumstoolklasse

Für den täglichen Gebrauch.

Datumsdienstprogrammklasse

package cn.lihaozhe.util.date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.temporal.TemporalAdjusters;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;

/**
 * 日期工具类
 *
 * @author 李昊哲
 * @version 1.0
 */
public class DateUtil {
    
    

  /**
   * 默认时区
   */
  private final static String timeZone = "Asia/Shanghai";
  /**
   * 默认时区为东 8 区
   */
  private final static ZoneOffset zoneOffset = ZoneOffset.of("+8");

  /**
   * 默认时间字符串模板
   */
  private final static String pattern = "yyyy-MM-dd HH:mm:ss";

  /**
   * 获取当前系统日期
   *
   * @return 当前系统日期
   */
  public static Date date() {
    
    
    return new Date();
  }

  /**
   * 获取当前系统日期日期字符串
   *
   * @return 当前系统日期字符串
   */
  public static String now() {
    
    
    return format(new Date());
  }

  /**
   * 获取当前系统日期日期字符串
   *
   * @param pattern 日期格式化字符串模板
   * @return 当前系统日期字符串
   */
  public static String now(String pattern) {
    
    
    return format(new Date(), pattern);
  }


  /**
   * 日期对象格式化为字符串
   *
   * @param date Date对象
   * @return Date对象格式化后的日期字符串
   */
  public static String format(Date date) {
    
    
    return format(date, pattern);
  }

  /**
   * 日期对象格式化为字符串
   *
   * @param date    Date对象
   * @param pattern 日期格式化字符串模板
   * @return Date对象格式化后的日期字符串
   */
  public static String format(Date date, String pattern) {
    
    
    if (date == null) {
    
    
      return null;
    }
    SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
    return dateFormat.format(date);
  }

  /**
   * 日期对象格式化为字符串
   *
   * @param date     Date对象
   * @param pattern  日期格式化字符串模板
   * @param timeZone 时区
   * @return Date对象格式化后的日期字符串
   */
  public static String format(Date date, String pattern, String timeZone) {
    
    
    SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
    dateFormat.setTimeZone(TimeZone.getTimeZone(timeZone));
    return dateFormat.format(date);
  }

  /**
   * 获取根据时间毫秒数获取日期
   *
   * @param time 时间毫秒数
   * @return 日期
   */
  public static Date parse(long time) {
    
    
    return new Date(time);
  }

  /**
   * 将日期字符串解析为日期对象
   *
   * @param src 日期字符串
   * @return 日期字符串解析后日期对象
   * @throws ParseException 日期解析异常
   */
  public static Date parse(String src) throws ParseException {
    
    
    return parse(src, pattern);
  }

  /**
   * 将日期字符串解析为日期对象
   *
   * @param src     日期字符串
   * @param pattern 日期格式化字符串模板
   * @return 日期字符串解析后日期对象
   * @throws ParseException 日期解析异常
   */
  public static Date parse(String src, String pattern) throws ParseException {
    
    
    return new SimpleDateFormat(pattern).parse(src);
  }

  /**
   * 将日期字符串解析为日期对象
   *
   * @param src      日期字符串
   * @param pattern  日期格式化字符串模板
   * @param timeZone 时区
   * @return 日期字符串解析后日期对象
   * @throws ParseException 日期解析异常
   */
  public static Date parse(String src, String pattern, String timeZone) throws ParseException {
    
    
    SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
    dateFormat.setTimeZone(TimeZone.getTimeZone(timeZone));
    return dateFormat.parse(src);
  }

  /**
   * 获取系统当前日期时间毫秒数
   *
   * @return 当前时间毫秒数
   */
  public static long getTime() {
    
    
    return getTime(new Date());
  }

  /**
   * 获取日期时间毫秒数
   *
   * @param date 日期
   * @return 时间毫秒数
   */
  public static long getTime(Date date) {
    
    
    return date.getTime();
  }

  /**
   * 时间补零占位
   *
   * @param time 时间
   * @return 补零后的字符串
   */
  public static String zeroCompensation(int time) {
    
    
    if (time < 10) {
    
    
      return "0" + time;
    }
    return String.valueOf(time);
  }

  /**
   * 生成范围的随机时间，位于[start,end)范围内 时间倒序排列
   *
   * @param start 开始时间格式字符串
   * @param end   结束时间格式字符串
   * @param count 生成时间数量
   * @return 随机时间的集合
   */
  public static List<Date> random(String start, String end, int count) throws ParseException {
    
    
    return random(parse(start), parse(end), count);
  }

  /**
   * 生成范围的随机时间，位于[start,end)范围内 时间倒序排列
   *
   * @param start 开始时间
   * @param end   结束时间
   * @param count 生成时间数量
   * @return 随机时间的集合
   */
  public static List<Date> random(Date start, Date end, int count) {
    
    
    return ThreadLocalRandom.current()
        .longs(count, start.getTime(), end.getTime())
        .mapToObj(Date::new).sorted(Date::compareTo).collect(Collectors.toList());
  }

  /**
   * 生成范围的随机时间，位于[start,end)范围内 时间倒序排列
   *
   * @param start 开始时间
   * @param end   结束时间
   * @param count 生成时间数量
   * @return 随机时间的集合
   */
  public static List<LocalDate> random(LocalDate start, LocalDate end, int count) {
    
    
    List<Date> dateList = ThreadLocalRandom.current()
        .longs(count, LocalDateUtils.getMilliSeconds(start), LocalDateUtils.getMilliSeconds(end))
        .mapToObj(Date::new).sorted(Date::compareTo).toList();
    return dateList.stream().map(DateUtils::toLocalDate).collect(Collectors.toList());
  }

  /**
   * 生成范围的随机时间，位于[start,end)范围内 时间倒序排列
   *
   * @param start 开始时间
   * @param end   结束时间
   * @param count 生成时间数量
   * @return 随机时间的集合
   */
  public static List<LocalDateTime> random(LocalDateTime start, LocalDateTime end, int count) {
    
    
    List<Date> dateList = ThreadLocalRandom.current()
        .longs(count, LocalDateTimeUtils.getTime(start), LocalDateTimeUtils.getTime(end))
        .mapToObj(Date::new).sorted(Date::compareTo).toList();
    return dateList.stream().map(DateUtils::toLocalDateTime).collect(Collectors.toList());
  }

  /**
   * LocalDate 转 Date
   *
   * @param localDate LocalDate对象
   * @return Date对象
   */
  private static Date from(LocalDate localDate) {
    
    
    return from(localDate, zoneOffset);
  }

  /**
   * LocalDate 转 Date
   *
   * @param localDate LocalDate对象
   * @param zoneId    zoneId
   * @return Date对象
   */
  private static Date from(LocalDate localDate, String zoneId) {
    
    
    return from(localDate, ZoneOffset.of(zoneId));
  }

  /**
   * LocalDate 转 Date
   *
   * @param localDate  LocalDate对象
   * @param zoneOffset 时区
   * @return Date对象
   */

  private static Date from(LocalDate localDate, ZoneOffset zoneOffset) {
    
    
    return Date.from(localDate.atStartOfDay(zoneOffset).toInstant());
  }

  /**
   * LocalDateTime 转 Date
   *
   * @param localDateTime LocalDateTime对象
   * @return Date对象
   */
  private static Date from(LocalDateTime localDateTime) {
    
    
    return from(localDateTime, zoneOffset);
  }


  /**
   * LocalDateTime 转 Date
   *
   * @param localDateTime LocalDateTime
   * @param zoneId        zoneId
   * @return Date对象
   */
  private static Date from(LocalDateTime localDateTime, String zoneId) {
    
    
    return from(localDateTime, ZoneOffset.of(zoneId));
  }

  /**
   * LocalDateTime 转 Date
   *
   * @param localDateTime LocalDateTime对象
   * @param zoneOffset    时区
   * @return Date对象
   */

  private static Date from(LocalDateTime localDateTime, ZoneOffset zoneOffset) {
    
    
    return Date.from(localDateTime.toInstant(zoneOffset));
  }

  /**
   * Date 转 LocalDate
   *
   * @param date Date对象
   * @return LocalDateTime对象
   */
  public static LocalDate toLocalDate(Date date) {
    
    
    return toLocalDate(date, zoneOffset);
  }

  /**
   * Date 转 LocalDate
   *
   * @param date   Date对象
   * @param zoneId 时区ID
   * @return LocalDateTime对象
   */
  public static LocalDate toLocalDate(Date date, String zoneId) {
    
    
    return toLocalDate(date, ZoneOffset.of(zoneId));
  }

  /**
   * Date 转 LocalDate
   *
   * @param date       Date对象
   * @param zoneOffset 时区
   * @return LocalDate对象
   */
  public static LocalDate toLocalDate(Date date, ZoneOffset zoneOffset) {
    
    
    return date.toInstant().atOffset(zoneOffset).toLocalDate();
  }

  /**
   * Date 转 LocalDate
   *
   * @param date Date对象
   * @return Date对象
   */
  public static LocalDateTime toLocalDateTime(Date date) {
    
    
    return toLocalDateTime(date, zoneOffset);
  }


  /**
   * Date 转 LocalDate
   *
   * @param date   Date对象
   * @param zoneId 时区ID
   * @return LocalDateTime对象
   */
  public static LocalDateTime toLocalDateTime(Date date, String zoneId) {
    
    
    return toLocalDateTime(date, ZoneOffset.of(zoneId));
  }

  /**
   * Date 转 LocalDateTime
   *
   * @param date       Date对象
   * @param zoneOffset 时区
   * @return LocalDateTime对象
   */
  public static LocalDateTime toLocalDateTime(Date date, ZoneOffset zoneOffset) {
    
    
    return date.toInstant().atOffset(zoneOffset).toLocalDateTime();
  }

  /**
   * 获取某日期所在年份的第一天的日期
   *
   * @param date 日期
   * @return 所在年份的第一天的日期
   * @throws ParseException ParseException
   */
  public static Date firstDateOfYear(Date date) throws ParseException {
    
    
    return parse(format(date, "yyyy"), "yyyy");
  }

  /**
   * 获取某日期所在年份的最后一天的日期
   *
   * @param date 日期
   * @return 所在年份的最后一天的日期
   * @throws ParseException ParseException
   */
  public static Date lastDateOfYear(Date date) throws ParseException {
    
    
    return parse(format(date, "yyyy") + "-12-31 23:59:59", pattern);
  }

  /**
   * 获取某日期所在月份的第一天的日期
   *
   * @param date 日期
   * @return 所在月份的第一天的日期
   * @throws ParseException ParseException
   */
  public static Date firstDateOfMonth(Date date) throws ParseException {
    
    
    return parse(format(date, "yyyy-MM") + "-01", "yyyy-MM-dd");
  }

  /**
   * 获取某日期所在月份的最后一天的日期
   *
   * @param date 日期
   * @return 所在月份的最后一天的日期
   * @throws ParseException ParseException
   */
  public static Date lastDateOfMonth(Date date) throws ParseException {
    
    
    return from(toLocalDateTime(date).with(TemporalAdjusters.lastDayOfMonth()));
  }
}

LocalDate-Dienstprogrammklasse

package cn.lihaozhe.util.date;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

/**
 * LocalDate 工具类
 *
 * @author 李昊哲
 * @version 1.0
 */
public class LocalDateUtil {
    
    
  /**
   * 日期格式化模板字符串
   */
  private static final String formatter = "yyyy-MM-dd";

  /**
   * 默认时区为东 8 区
   */
  private final static ZoneOffset zoneOffset = ZoneOffset.of("+8");

  /**
   * 将LocalDate格式化为默认的日期格式字符串 例如：1983-11-22
   *
   * @param localDate 欲被格式化的日期
   * @return 根据日期格式字符串模板格式化的时间字符串
   */
  public static String format(LocalDate localDate) {
    
    
    return format(localDate, formatter);
  }

  /**
   * 将LocalDate格式化为指定的日期格式字符串
   *
   * @param localDate 欲被格式化的日期
   * @param formatter 日期字符串模板
   * @return 根据日期格式字符串模板格式化的时间字符串
   */
  public static String format(LocalDate localDate, String formatter) {
    
    
    if (localDate == null) {
    
    
      return null;
    }
    return DateTimeFormatter.ofPattern(formatter).format(localDate);
    // return localDate.format(DateTimeFormatter.ofPattern(formatter));
  }

  /**
   * 根据默认日期字符串模板将日期格式字符串解析为LocalDate
   * 默认日期字符串模板 yyyy-MM-dd
   *
   * @param text 日期格式字符串
   * @return LocalDate
   */
  public static LocalDate parse(String text) {
    
    
    return parse(text, formatter);
  }

  /**
   * 根据日期字符串模板将日期格式字符串解析为LocalDate
   *
   * @param text      日期格式字符串
   * @param formatter 日期格式字符串模板
   * @return LocalDate
   */
  public static LocalDate parse(String text, String formatter) {
    
    
    return LocalDate.parse(text, DateTimeFormatter.ofPattern(formatter));
  }

  /**
   * Date类型的时间转为LocalDateTime类型的时间
   *
   * @param date Date
   * @return LocalDate
   */
  public static LocalDate from(Date date) {
    
    
    return from(date, zoneOffset);
  }

  /**
   * Date类型的时间转为LocalDateTime类型的时间
   *
   * @param date   Date
   * @param zoneId 时区ID
   * @return LocalDate
   */
  public static LocalDate from(Date date, String zoneId) {
    
    
    return from(date, ZoneOffset.of(zoneId));
  }

  /**
   * Date类型的时间转为LocalDateTime类型的时间
   *
   * @param date Date
   * @param zone 时区
   * @return LocalDate
   */
  public static LocalDate from(Date date, ZoneId zone) {
    
    
    return date.toInstant().atZone(zone).toLocalDate();
  }

  /**
   * Date类型的时间转为LocalDateTime类型的时间
   *
   * @param date       Date
   * @param zoneOffset 时区
   * @return LocalDate
   */
  public static LocalDate from(Date date, ZoneOffset zoneOffset) {
    
    
    return date.toInstant().atOffset(zoneOffset).toLocalDate();
  }

  /**
   * LocalDate 转 Date
   *
   * @param localDate LocalDate对象
   * @return Date对象
   */
  public static Date toDate(LocalDate localDate) {
    
    
    return toDate(localDate, zoneOffset);
  }

  /**
   * LocalDate 转 Date
   *
   * @param localDate LocalDate对象
   * @param zoneId    zoneId
   * @return Date对象
   */
  public static Date toDate(LocalDate localDate, String zoneId) {
    
    
    return toDate(localDate, ZoneOffset.of(zoneId));
  }

  /**
   * LocalDate 转 Date
   *
   * @param localDate  LocalDate对象
   * @param zoneOffset 时区
   * @return Date对象
   */

  public static Date toDate(LocalDate localDate, ZoneOffset zoneOffset) {
    
    
    return Date.from(localDate.atStartOfDay(zoneOffset).toInstant());
  }

  /**
   * LocalDateTime 转 LocalDateTime
   *
   * @param localDate LocalDate对象
   * @return LocalDateTime对象
   */
  public static LocalDateTime toLocalDateTime(LocalDate localDate) {
    
    
    return toLocalDateTime(localDate, zoneOffset);
  }

  /**
   * LocalDateTime 转 LocalDateTime
   *
   * @param localDate LocalDate对象
   * @param zoneId    时区ID
   * @return LocalDateTime对象
   */
  public static LocalDateTime toLocalDateTime(LocalDate localDate, String zoneId) {
    
    
    return toLocalDateTime(localDate, ZoneOffset.of(zoneId));
  }

  /**
   * LocalDateTime 转 LocalDateTime
   *
   * @param localDate  LocalDate对象
   * @param zoneOffset 时区
   * @return LocalDateTime对象
   */
  public static LocalDateTime toLocalDateTime(LocalDate localDate, ZoneOffset zoneOffset) {
    
    
    return localDate.atStartOfDay(zoneOffset).toLocalDateTime();
  }

  /**
   * 获取时间毫秒数
   *
   * @return 时间毫秒数
   */
  public static long getMilliSeconds() {
    
    
    return getMilliSeconds(LocalDate.now());
  }

  /**
   * 获取时间毫秒数
   *
   * @param localDate LocalDate对象
   * @return 时间毫秒数
   */
  public static long getMilliSeconds(LocalDate localDate) {
    
    
    return getMilliSeconds(localDate, zoneOffset);
  }

  /**
   * 获取时间毫秒数
   *
   * @param localDate LocalDate对象
   * @param zoneId    时区ID
   * @return 时间毫秒数
   */
  public static long getMilliSeconds(LocalDate localDate, String zoneId) {
    
    
    return getMilliSeconds(localDate, ZoneOffset.of(zoneId));
  }

  /**
   * 获取时间毫秒数
   *
   * @param localDate  LocalDate对象
   * @param zoneOffset 时区
   * @return 时间毫秒数
   */
  public static long getMilliSeconds(LocalDate localDate, ZoneOffset zoneOffset) {
    
    
    return toLocalDateTime(localDate, zoneOffset).toInstant(zoneOffset).toEpochMilli();
  }

  /**
   * 时间毫秒数转LocalDate 使用系统默认时区
   *
   * @param milliSeconds 时间毫秒数
   * @return LocalDate
   */
  public static LocalDate parseMilliSeconds(Long milliSeconds) {
    
    
    return parseMilliSeconds(milliSeconds, ZoneId.systemDefault());
  }

  /**
   * 时间毫秒数转LocalDate
   *
   * @param milliSeconds 时间毫秒数
   * @param zoneId       时区
   * @return LocalDate
   */
  public static LocalDate parseMilliSeconds(Long milliSeconds, ZoneId zoneId) {
    
    
    return Instant.ofEpochMilli(milliSeconds).atZone(zoneId).toLocalDate();
  }

  /**
   * 随机生成 LocalDate 集合
   *
   * @param start 开始日期字符串 日期字符串格式 yyyy-MM-dd
   * @param end   结束日期字符串 日期字符串格式 yyyy-MM-dd
   * @param count 随机数量
   * @return LocalDate LocalDate集合
   */
  public static List<LocalDate> random(String start, String end, int count) {
    
    
    return random(start, end, count, formatter);
  }

  /**
   * 随机生成 LocalDate 集合
   *
   * @param start     开始日期字符串
   * @param end       结束日期字符串
   * @param count     随机数量
   * @param formatter 日期字符串模板
   * @return LocalDate LocalDate集合
   */
  public static List<LocalDate> random(String start, String end, int count, String formatter) {
    
    
    return random(parse(start, formatter), parse(end, formatter), count);
  }

  /**
   * 随机生成 LocalDate 集合
   *
   * @param start 开始日期
   * @param end   结束日期
   * @param count 随机数量
   * @return LocalDate LocalDate集合
   */
  public static List<LocalDate> random(LocalDate start, LocalDate end, int count) {
    
    
    List<LocalDate> list = new ArrayList<>();
    for (int i = 0; i < count; i++) {
    
    
      list.add(parseMilliSeconds(ThreadLocalRandom.current().nextLong(getMilliSeconds(start), getMilliSeconds(end))));
    }
    if (!list.isEmpty()) {
    
    
      list.sort(LocalDate::compareTo);
    }
    return list;
  }
}

LocalDateTime-Dienstprogrammklasse

package cn.lihaozhe.util.date;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;


/**
 * LocalDateTime 工具类
 *
 * @author 李昊哲
 * @version 1.0
 * @create 2023-10-18
 */
public class LocalDateTimeUtil {
    
    
  /**
   * 时间格式化模板字符串
   */
  private static final String formatter = "yyyy-MM-dd HH:mm:ss";
  /**
   * 默认时区为东 8 区
   */
  private static final ZoneOffset zoneOffset = ZoneOffset.of("+8");

  /**
   * 将LocalDateTime格式化为时间指定的时间格式字符串
   *
   * @param localDateTime 欲被格式化的时间
   * @return 根据时间格式字符串模板格式化的时间字符串
   */
  public static String format(LocalDateTime localDateTime) {
    
    
    return format(localDateTime, formatter);
  }

  /**
   * 将LocalDateTime格式化为时间指定的时间格式字符串
   *
   * @param localDateTime 欲被格式化的时间
   * @param formatter     时间字符串模板
   * @return 根据时间格式字符串模板格式化的时间字符串
   */
  public static String format(LocalDateTime localDateTime, String formatter) {
    
    
    if (localDateTime == null) {
    
    
      return null;
    }
    return DateTimeFormatter.ofPattern(formatter).format(localDateTime);
    // return localDateTime.format(DateTimeFormatter.ofPattern(formatter));
  }

  /**
   * 根据时间字符串模板将时间格式字符串解析为LocalDateTime
   *
   * @param text 时间字符串
   * @return LocalDateTime
   */
  public static LocalDateTime parse(String text) {
    
    
    return parse(text, formatter);
  }

  /**
   * 根据时间字符串模板将时间格式字符串解析为LocalDateTime
   *
   * @param text      时间字符串
   * @param formatter 时间字符串模板
   * @return LocalDateTime
   */
  public static LocalDateTime parse(String text, String formatter) {
    
    
    return LocalDateTime.parse(text, DateTimeFormatter.ofPattern(formatter));
  }

  /**
   * Date类型的时间转为LocalDateTime类型的时间
   *
   * @param date Date
   * @return LocalDate
   */
  public static LocalDateTime from(Date date) {
    
    
    return from(date, zoneOffset);
  }

  /**
   * Date类型的时间转为LocalDateTime类型的时间
   *
   * @param date   Date
   * @param zoneId 时区ID
   * @return LocalDate
   */
  public static LocalDateTime from(Date date, String zoneId) {
    
    
    return from(date, ZoneOffset.of(zoneId));
  }

  /**
   * Date类型的时间转为LocalDateTime类型的时间
   *
   * @param date Date
   * @param zone 时区
   * @return LocalDate
   */
  public static LocalDateTime from(Date date, ZoneId zone) {
    
    
    return date.toInstant().atZone(zone).toLocalDateTime();
  }

  /**
   * Date类型的时间转为LocalDateTime类型的时间
   *
   * @param date       Date
   * @param zoneOffset 时区
   * @return LocalDateTime
   */
  public static LocalDateTime from(Date date, ZoneOffset zoneOffset) {
    
    
    return date.toInstant().atOffset(zoneOffset).toLocalDateTime();
  }

  /**
   * LocalDate 转 Date
   *
   * @param localDateTime LocalDateTime对象
   * @return Date对象
   */
  public static Date toDate(LocalDateTime localDateTime) {
    
    
    return toDate(localDateTime, zoneOffset);
  }

  /**
   * LocalDate 转 Date
   *
   * @param localDateTime LocalDateTime对象
   * @param zoneId        zoneId
   * @return Date对象
   */
  public static Date toDate(LocalDateTime localDateTime, String zoneId) {
    
    
    return toDate(localDateTime, ZoneOffset.of(zoneId));
  }

  /**
   * LocalDate 转 Date
   *
   * @param localDateTime LocalDateTime对象
   * @param zoneOffset    时区
   * @return Date对象
   */

  public static Date toDate(LocalDateTime localDateTime, ZoneOffset zoneOffset) {
    
    
    return Date.from(localDateTime.toInstant(zoneOffset));
  }

  /**
   * 获取当前时间毫秒数
   *
   * @return 当前时间毫秒数
   */
  public static long getTime() {
    
    
    return LocalDateTime.now(ZoneOffset.of("+8")).toInstant(ZoneOffset.of("+8")).toEpochMilli();
  }

  /**
   * 获取时间毫秒数
   *
   * @param localDateTime 日期时间
   * @return 当前时间毫秒数
   */
  public static long getTime(LocalDateTime localDateTime) {
    
    
    return localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
  }

  /**
   * 时间毫秒数转LocalDateTime
   *
   * @param milliseconds 时间毫秒数
   * @return LocalDateTime
   */
  public static LocalDateTime parseMilliSeconds(Long milliseconds) {
    
    
    return LocalDateTime.ofInstant(Instant.ofEpochMilli(milliseconds), ZoneId.systemDefault());
  }

  /**
   * 时间毫秒数转LocalDateTime
   *
   * @param milliseconds 时间毫秒数
   * @param zoneId       ZoneId
   * @return LocalDateTime
   */
  public static LocalDateTime parseMilliSeconds(Long milliseconds, ZoneId zoneId) {
    
    
    return LocalDateTime.ofInstant(Instant.ofEpochMilli(milliseconds), zoneId);
  }

  /**
   * 随机生成 LocalDate 集合
   *
   * @param start 开始时间字符串 时间字符串格式 yyyy-MM-dd HH:mm:ss
   * @param end   结束时间字符串 时间字符串格式 yyyy-MM-dd HH:mm:ss
   * @param count 随机数量
   * @return LocalDateTime 集合
   */
  public static List<LocalDateTime> random(String start, String end, int count) {
    
    
    return random(start, end, count, formatter);
  }

  /**
   * 随机生成 LocalDateTime 集合
   *
   * @param start     开始时间字符串
   * @param end       结束时间字符串
   * @param count     随机数量
   * @param formatter 时间字符串模板
   * @return LocalDateTime LocalDateTime集合
   */
  public static List<LocalDateTime> random(String start, String end, int count, String formatter) {
    
    
    return random(parse(start, formatter), parse(end, formatter), count);
  }

  /**
   * 随机生成 LocalDateTime 集合
   *
   * @param start 开始时间
   * @param end   结束时间
   * @param count 随机数量
   * @return LocalDateTime 集合
   */
  public static List<LocalDateTime> random(LocalDateTime start, LocalDateTime end, int count) {
    
    
    List<LocalDateTime> list = new ArrayList<>();
    for (int i = 0; i < count; i++) {
    
    
      list.add(parseMilliSeconds(ThreadLocalRandom.current().nextLong(getTime(start), getTime(end))));
    }
    if (!list.isEmpty()) {
    
    
      list.sort(LocalDateTime::compareTo);
    }
    return list;
  }
}