时间日期工具类

时间日期工具类

• import java.time.*;
  import java.time.format.DateTimeFormatter;
  import java.time.temporal.ChronoUnit;
   
  public class DateTimeUtils {
   
      private static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
      private static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
      private static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
      static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
   
      // 获取当前日期
      public static LocalDate getCurrentDate() {
          return LocalDate.now();
      }
   
      // 获取当前时间
      public static LocalTime getCurrentTime() {
          return LocalTime.now();
      }
   
      // 获取当前日期时间
      public static LocalDateTime getCurrentDateTime() {
          return LocalDateTime.now();
      }
   
      // 获取当前时间戳
      public static long getCurrentTimestamp() {
          return Instant.now().toEpochMilli();
      }
   
      /**
       *  生成当前时间字符串，默认格式yyyy-MM-dd HH:mm:ss
       * @return java.lang.String
       **/
      public static String currentDateStr() {
          LocalDateTime now = LocalDateTime.now();
          return now.format(formatter);
      }
   
      /**
       * 指定日期格式生成当前时间字符串
       * @param formatter
       * @return java.lang.String
       **/
      public static String currentDateStr(String formatter) {
          LocalDateTime now = LocalDateTime.now();
          DateTimeFormatter pattern = DateTimeFormatter.ofPattern(formatter);
          return now.format(pattern);
      }
   
      /**
       **时间转字符串，默认格式化：yyyy-MM-dd HH:mm:ss
       * @param dateTime
       * @return java.lang.String
       **/
      public static String dateToStr(LocalDateTime dateTime) {
          return dateTime.format(formatter);
      }
   
      /**
       **时间转字符串
       * @param dateTime
       * @param formatter 格式化
       * @return java.lang.String
       **/
      public static String dateToStr(LocalDateTime dateTime, DateTimeFormatter formatter) {
          return dateTime.format(formatter);
      }
   
      /**
       **判断bigTime是否大于smallTime
       * @param smallTime
       * @param bigTime
       * @return boolean
       **/
      public static boolean lessThanTime(String smallTime, String bigTime) {
          LocalDateTime smallDateTime = LocalDateTime.parse(smallTime, formatter);
          LocalDateTime bigDateTime = LocalDateTime.parse(bigTime, formatter);
          return smallDateTime.isBefore(bigDateTime);
      }
   
      /**
       **获取num天前的日期
       * @param num
       * @return java.lang.String
       **/
      public static String getPastDate(int num) {
          LocalDate currentDate = LocalDate.now();
          LocalDate pastDate = currentDate.minusDays(num);
          DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
          return pastDate.format(formatter);
      }
   
      /**
       **获取近n天的日期字符串集合
       * @param n
       * @return java.util.List<java.lang.String>
       **/
      public static List<String> getRecentNumDays(int n) {
          List<String> dates = new ArrayList<>();
          LocalDate today = LocalDate.now();
          for (int i = 0; i < n; i++) {
              LocalDate date = today.minusDays(i);
              String dateStr = date.format(DateTimeFormatter.ofPattern("MM-dd"));
              dates.add(dateStr);
          }
          return dates;
      }
   
      // 将日期字符串解析成LocalDate对象
      public static LocalDate parseDate(String date) {
          return LocalDate.parse(date);
      }
   
      // 将时间字符串解析成LocalTime对象
      public static LocalTime parseTime(String time) {
          return LocalTime.parse(time);
      }
   
      // 将日期时间字符串解析成LocalDateTime对象
      public static LocalDateTime parseDateTime(String dateTime) {
          return LocalDateTime.parse(dateTime);
      }
   
      // 将日期时间字符串按照指定格式解析成LocalDateTime对象
      public static LocalDateTime parseDateTime(String dateTime, String format) {
          DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
          return LocalDateTime.parse(dateTime, formatter);
      }
   
      // 将LocalDate对象格式化成日期字符串
      public static String formatDate(LocalDate date) {
          return date.format(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT));
      }
   
      // 将LocalTime对象格式化成时间字符串
      public static String formatTime(LocalTime time) {
          return time.format(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT));
      }
   
      // 将LocalDateTime对象格式化成日期时间字符串
      public static String formatDateTime(LocalDateTime dateTime) {
          return dateTime.format(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT));
      }
   
      // 将LocalDateTime对象按照指定格式格式化成日期时间字符串
      public static String formatDateTime(LocalDateTime dateTime, String format) {
          return dateTime.format(DateTimeFormatter.ofPattern(format));
      }
   
      // 获取指定日期的星期几（1-7，分别代表周一至周日）
      public static int getDayOfWeek(LocalDate date) {
          return date.getDayOfWeek().getValue();
      }
   
      // 获取指定日期的年份
      public static int getYear(LocalDate date) {
          return date.getYear();
      }
   
      // 获取指定日期的月份
      public static int getMonth(LocalDate date) {
          return date.getMonthValue();
      }
   
      // 获取指定日期的天数
      public static int getDayOfMonth(LocalDate date) {
          return date.getDayOfMonth();
      }
   
      // 获取指定日期是当年的第几天
      public static int getDayOfYear(LocalDate date) {
          return date.getDayOfYear();
      }
   
      // 获取指定日期是否为闰年
      public static boolean isLeapYear(LocalDate date) {
          return date.isLeapYear();
      }
   
      // 获取指定日期之前或之后的几天
      public static LocalDate plusDays(LocalDate date, long days) {
          return date.plusDays(days);
      }
   
      // 获取指定日期之前或之后的几周
      public static LocalDate plusWeeks(LocalDate date, long weeks) {
          return date.plusWeeks(weeks);
      }
   
      // 获取指定日期之前或之后的几个月
      public static LocalDate plusMonths(LocalDate date, long months) {
          return date.plusMonths(months);
      }
   
      // 获取指定日期之前或之后的几年
      public static LocalDate plusYears(LocalDate date, long years) {
          return date.plusYears(years);
      }
   
      // 获取指定日期之前或之后的几小时
      public static LocalDateTime plusHours(LocalDateTime dateTime, long hours) {
          return dateTime.plusHours(hours);
      }
   
      // 获取指定日期之前或之后的几分钟
      public static LocalDateTime plusMinutes(LocalDateTime dateTime, long minutes) {
          return dateTime.plusMinutes(minutes);
      }
   
      // 获取指定日期之前或之后的几秒钟
      public static LocalDateTime plusSeconds(LocalDateTime dateTime, long seconds) {
          return dateTime.plusSeconds(seconds);
      }
   
      // 获取指定日期之前或之后的几毫秒
      public static LocalDateTime plusMilliseconds(LocalDateTime dateTime, long milliseconds) {
          return dateTime.plus(milliseconds, ChronoUnit.MILLIS);
      }
   
      // 获取指定日期之前或之后的几纳秒
      public static LocalDateTime plusNanoseconds(LocalDateTime dateTime, long nanoseconds) {
          return dateTime.plus(nanoseconds, ChronoUnit.NANOS);
      }
   
      // 比较两个日期的先后顺序（返回值小于0表示date1在date2之前，等于0表示两个日期相等，大于0表示date1在date2之后）
      public static int compareDates(LocalDate date1, LocalDate date2) {
          return date1.compareTo(date2);
      }
   
      // 判断两个日期是否相等
      public static boolean areDatesEqual(LocalDate date1, LocalDate date2) {
          return date1.isEqual(date2);
      }
   
      // 计算两个日期之间的天数差
      public static long getDaysBetween(LocalDate date1, LocalDate date2) {
          return ChronoUnit.DAYS.between(date1, date2);
      }
   
      // 计算两个日期之间的周数差
      public static long getWeeksBetween(LocalDate date1, LocalDate date2) {
          return ChronoUnit.WEEKS.between(date1, date2);
      }
   
      // 计算两个日期之间的月数差
      public static long getMonthsBetween(LocalDate date1, LocalDate date2) {
          return ChronoUnit.MONTHS.between(date1, date2);
      }
   
      // 计算两个日期之间的年数差
      public static long getYearsBetween(LocalDate date1, LocalDate date2) {
          return ChronoUnit.YEARS.between(date1, date2);
      }
   
      // 判断指定日期是否在当前日期之前
      public static boolean isBeforeCurrentDate(LocalDate date) {
          return date.isBefore(getCurrentDate());
      }
   
      // 判断指定日期是否在当前日期之后
      public static boolean isAfterCurrentDate(LocalDate date) {
          return date.isAfter(getCurrentDate());
      }
   
      // 判断指定时间是否在当前时间之前
      public static boolean isBeforeCurrentTime(LocalTime time) {
          return time.isBefore(getCurrentTime());
      }
   
      // 判断指定时间是否在当前时间之后
      public static boolean isAfterCurrentTime(LocalTime time) {
          return time.isAfter(getCurrentTime());
      }
   
      // 判断指定日期时间是否在当前日期时间之前
      public static boolean isBeforeCurrentDateTime(LocalDateTime dateTime) {
          return dateTime.isBefore(getCurrentDateTime());
      }
   
      // 判断指定日期时间是否在当前日期时间之后
      public static boolean isAfterCurrentDateTime(LocalDateTime dateTime) {
          return dateTime.isAfter(getCurrentDateTime());
      }
   
      // 判断两个日期时间是否相等
      public static boolean areDateTimesEqual(LocalDateTime dateTime1, LocalDateTime dateTime2) {
          return dateTime1.isEqual(dateTime2);
      }
   
      // 计算两个日期时间之间的小时数差
      public static long getHoursBetween(LocalDateTime dateTime1, LocalDateTime dateTime2) {
          return ChronoUnit.HOURS.between(dateTime1, dateTime2);
      }
   
      // 计算两个日期时间之间的分钟数差
      public static long getMinutesBetween(LocalDateTime dateTime1, LocalDateTime dateTime2) {
          return ChronoUnit.MINUTES.between(dateTime1, dateTime2);
      }
   
      // 计算两个日期时间之间的秒数差
      public static long getSecondsBetween(LocalDateTime dateTime1, LocalDateTime dateTime2) {
          return ChronoUnit.SECONDS.between(dateTime1, dateTime2);
      }
   
      // 计算两个日期时间之间的毫秒数差
      public static long getMillisecondsBetween(LocalDateTime dateTime1, LocalDateTime dateTime2) {
          return ChronoUnit.MILLIS.between(dateTime1, dateTime2);
      }
   
      // 计算两个日期时间之间的纳秒数差
      public static long getNanosecondsBetween(LocalDateTime dateTime1, LocalDateTime dateTime2) {
          return ChronoUnit.NANOS.between(dateTime1, dateTime2);
      }
   
  }