Source/BladeX-Tool/blade-core-tool/src/main/java/org/springblade/core/tool/utils/DateTimeUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,226 @@
/*
 *      Copyright (c) 2018-2028, DreamLu All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
 *  Neither the name of the dreamlu.net developer nor the names of its
 *  contributors may be used to endorse or promote products derived from
 *  this software without specific prior written permission.
 *  Author: DreamLu å¢æ˜¥æ¢¦ (596392912@qq.com)
 */
package org.springblade.core.tool.utils;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.util.Date;

/**
 * DateTime å·¥å…·ç±»
 *
 * @author L.cm
 */
public class DateTimeUtil {
   public static final DateTimeFormatter DATETIME_FORMAT = DateTimeFormatter.ofPattern(DateUtil.PATTERN_DATETIME);
   public static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern(DateUtil.PATTERN_DATE);
   public static final DateTimeFormatter TIME_FORMAT = DateTimeFormatter.ofPattern(DateUtil.PATTERN_TIME);

   /**
    * æ—¥æœŸæ—¶é—´æ ¼å¼åŒ–
    *
    * @param temporal æ—¶é—´
    * @return æ ¼å¼åŒ–后的时间
    */
   public static String formatDateTime(TemporalAccessor temporal) {
      return DATETIME_FORMAT.format(temporal);
   }

   /**
    * æ—¥æœŸæ—¶é—´æ ¼å¼åŒ–
    *
    * @param temporal æ—¶é—´
    * @return æ ¼å¼åŒ–后的时间
    */
   public static String formatDate(TemporalAccessor temporal) {
      return DATE_FORMAT.format(temporal);
   }

   /**
    * æ—¶é—´æ ¼å¼åŒ–
    *
    * @param temporal æ—¶é—´
    * @return æ ¼å¼åŒ–后的时间
    */
   public static String formatTime(TemporalAccessor temporal) {
      return TIME_FORMAT.format(temporal);
   }

   /**
    * æ—¥æœŸæ ¼å¼åŒ–
    *
    * @param temporal æ—¶é—´
    * @param pattern  è¡¨è¾¾å¼
    * @return æ ¼å¼åŒ–后的时间
    */
   public static String format(TemporalAccessor temporal, String pattern) {
      return DateTimeFormatter.ofPattern(pattern).format(temporal);
   }

   /**
    * å°†å­—符串转换为时间
    *
    * @param dateStr æ—¶é—´å­—符串
    * @param pattern è¡¨è¾¾å¼
    * @return æ—¶é—´
    */
   public static LocalDateTime parseDateTime(String dateStr, String pattern) {
      DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
      return DateTimeUtil.parseDateTime(dateStr, formatter);
   }

   /**
    * å°†å­—符串转换为时间
    *
    * @param dateStr   æ—¶é—´å­—符串
    * @param formatter DateTimeFormatter
    * @return æ—¶é—´
    */
   public static LocalDateTime parseDateTime(String dateStr, DateTimeFormatter formatter) {
      return LocalDateTime.parse(dateStr, formatter);
   }

   /**
    * å°†å­—符串转换为时间
    *
    * @param dateStr æ—¶é—´å­—符串
    * @return æ—¶é—´
    */
   public static LocalDateTime parseDateTime(String dateStr) {
      return DateTimeUtil.parseDateTime(dateStr, DateTimeUtil.DATETIME_FORMAT);
   }

   /**
    * å°†å­—符串转换为时间
    *
    * @param dateStr æ—¶é—´å­—符串
    * @param pattern è¡¨è¾¾å¼
    * @return æ—¶é—´
    */
   public static LocalDate parseDate(String dateStr, String pattern) {
      DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
      return DateTimeUtil.parseDate(dateStr, formatter);
   }

   /**
    * å°†å­—符串转换为时间
    *
    * @param dateStr   æ—¶é—´å­—符串
    * @param formatter DateTimeFormatter
    * @return æ—¶é—´
    */
   public static LocalDate parseDate(String dateStr, DateTimeFormatter formatter) {
      return LocalDate.parse(dateStr, formatter);
   }

   /**
    * å°†å­—符串转换为日期
    *
    * @param dateStr æ—¶é—´å­—符串
    * @return æ—¶é—´
    */
   public static LocalDate parseDate(String dateStr) {
      return DateTimeUtil.parseDate(dateStr, DateTimeUtil.DATE_FORMAT);
   }

   /**
    * å°†å­—符串转换为时间
    *
    * @param dateStr æ—¶é—´å­—符串
    * @param pattern æ—¶é—´æ­£åˆ™
    * @return æ—¶é—´
    */
   public static LocalTime parseTime(String dateStr, String pattern) {
      DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
      return DateTimeUtil.parseTime(dateStr, formatter);
   }

   /**
    * å°†å­—符串转换为时间
    *
    * @param dateStr   æ—¶é—´å­—符串
    * @param formatter DateTimeFormatter
    * @return æ—¶é—´
    */
   public static LocalTime parseTime(String dateStr, DateTimeFormatter formatter) {
      return LocalTime.parse(dateStr, formatter);
   }

   /**
    * å°†å­—符串转换为时间
    *
    * @param dateStr æ—¶é—´å­—符串
    * @return æ—¶é—´
    */
   public static LocalTime parseTime(String dateStr) {
      return DateTimeUtil.parseTime(dateStr, DateTimeUtil.TIME_FORMAT);
   }

   /**
    * æ—¶é—´è½¬ Instant
    *
    * @param dateTime æ—¶é—´
    * @return Instant
    */
   public static Instant toInstant(LocalDateTime dateTime) {
      return dateTime.atZone(ZoneId.systemDefault()).toInstant();
   }

   /**
    * Instant è½¬ æ—¶é—´
    *
    * @param instant Instant
    * @return Instant
    */
   public static LocalDateTime toDateTime(Instant instant) {
      return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
   }

   /**
    * è½¬æ¢æˆ date
    *
    * @param dateTime LocalDateTime
    * @return Date
    */
   public static Date toDate(LocalDateTime dateTime) {
      return Date.from(DateTimeUtil.toInstant(dateTime));
   }

   /**
    * æ¯”较2个时间差，跨度比较小
    *
    * @param startInclusive å¼€å§‹æ—¶é—´
    * @param endExclusive   ç»“束时间
    * @return æ—¶é—´é—´éš”
    */
   public static Duration between(Temporal startInclusive, Temporal endExclusive) {
      return Duration.between(startInclusive, endExclusive);
   }

   /**
    * æ¯”较2个时间差，跨度比较大，年月日为单位
    *
    * @param startDate å¼€å§‹æ—¶é—´
    * @param endDate   ç»“束时间
    * @return æ—¶é—´é—´éš”
    */
   public static Period between(LocalDate startDate, LocalDate endDate) {
      return Period.between(startDate, endDate);
   }
}