在Java开发中，日期和时间的处理是一个绕不开的话题。Java自身提供了丰富的API来处理日期和时间，但是使用起来可能较为繁琐。因此，许多开发者会使用一些工具类来简化日期和时间的处理。本文将介绍一个常用的日期处理工具类——DateUtils，并提供详细的代码和说明。

工具类介绍

 编写一个自定义的DateUtils，继承自org.apache.commons.lang3.time.DateUtils的Java类，提供一系列静态方法来简化日期和时间的处理。这些方法包括日期的格式化、解析、计算日期差等。

方法详解

1. 获取当前日期和时间

public static Date getNowDate()

这个方法返回当前的日期和时间，类型为java.util.Date。

2. 获取当前日期

public static String getDate()

这个方法返回当前的日期，格式为yyyy-MM-dd。

3. 获取当前时间

public static String getTime()

这个方法返回当前的时间，格式为yyyy-MM-dd HH:mm:ss。

4. 获取当前日期和时间（自定义格式）

public static String dateTimeNow(final String format)

这个方法返回当前日期和时间，格式由参数format指定。

5. 日期格式化

public static final String parseDateToStr(final String format, final Date date)

这个方法将java.util.Date对象格式化为字符串，格式由参数format指定。

6. 日期解析

public static final Date dateTime(final String format, final String ts)

这个方法将字符串解析为java.util.Date对象，格式由参数format指定。

7. 计算日期差

public static int differentDaysByMillisecond(Date date1, Date date2)

这个方法计算两个日期之间的天数差。

8. 计算时间差

public static String getDatePoor(Date endDate, Date nowDate)

这个方法计算两个时间之间的差，并以“天小时分钟”的格式返回。

9. LocalDateTime和Date之间的转换

public static Date toDate(LocalDateTime temporalAccessor)

这个方法将LocalDateTime对象转换为java.util.Date对象。

10. LocalDate和Date之间的转换

public static Date toDate(LocalDate temporalAccessor)

这个方法将LocalDate对象转换为java.util.Date对象。

使用示例

下面是一些使用DateUtils工具类的示例。

// 获取当前日期和时间
Date nowDate = DateUtils.getNowDate();
System.out.println(nowDate);
// 获取当前日期，格式为yyyy-MM-dd
String currentDate = DateUtils.getDate();
System.out.println(currentDate);
// 获取当前时间，格式为yyyy-MM-dd HH:mm:ss
String currentTime = DateUtils.getTime();
System.out.println(currentTime);
// 将日期和时间格式化为自定义格式
String dateTime = DateUtils.dateTimeNow("yyyyMMddHHmmss");
System.out.println(dateTime);
// 将日期和时间字符串解析为Date对象
Date parsedDate = DateUtils.dateTime("yyyy-MM-dd HH:mm:ss", "2021-08-08 08:08:08");
System.out.println(parsedDate);
// 计算两个日期之间的天数差
int daysDiff = DateUtils.differentDaysByMillisecond(new Date(), parsedDate);
System.out.println(daysDiff);
// 计算两个时间之间的差
String timeDiff = DateUtils.getDatePoor(new Date(), parsedDate);
System.out.println(timeDiff);

结果：

代码

import java.lang.management.ManagementFactory;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Date;
import org.apache.commons.lang3.time.DateFormatUtils;

/**
 * 时间工具类
 */
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
    public static String YYYY = "yyyy";

    public static String YYYY_MM = "yyyy-MM";

    public static String YYYY_MM_DD = "yyyy-MM-dd";

    public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

    public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

    private static String[] parsePatterns = {
            "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
            "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
            "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM" };

    /**
     * 获取当前Date型日期
     */
    public static Date getNowDate() {
        return new Date();
    }

    /**
     * 获取当前Date型日期 YYYY_MM_DD
     */
    public static String getDate() {
        return dateTimeNow(YYYY_MM_DD);
    }

    /**
     * 获取当前Date型日期 YYYY_MM_DD_HH_MM_SS
     */
    public static final String getTime() {
        return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
    }

    /**
     * 获取当前Date型日期 YYYYMMDDHHMMSS
     */
    public static final String dateTimeNow() {
        return dateTimeNow(YYYYMMDDHHMMSS);
    }

    /**
     * 获取当前Date型日期 format
     */
    public static final String dateTimeNow(final String format) {
        return parseDateToStr(format, new Date());
    }

    /**
     * 获取Date型日期 YYYY_MM_DD
     */
    public static final String dateTime(final Date date) {
        return parseDateToStr(YYYY_MM_DD, date);
    }

    /**
     * 将Date型日期转换为format型字符串
     */
    public static final String parseDateToStr(final String format, final Date date) {
        return new SimpleDateFormat(format).format(date);
    }

    /**
     * 获取Date型日期 format
     */
    public static final Date dateTime(final String format, final String ts) {
        try {
            return new SimpleDateFormat(format).parse(ts);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 日期路径 即年/月/日 如2018/08/08
     */
    public static final String datePath() {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyy/MM/dd");
    }

    /**
     * 日期路径 即年/月/日 如20180808
     */
    public static final String dateTime() {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyyMMdd");
    }

    /**
     * 日期型字符串转化为日期 格式
     */
    public static Date parseDate(Object str) {
        if (str == null) {
            return null;
        }
        try {
            return parseDate(str.toString(), parsePatterns);
        } catch (ParseException e) {
            return null;
        }
    }

    /**
     * 获取服务器启动时间
     */
    public static Date getServerStartDate() {
        long time = ManagementFactory.getRuntimeMXBean().getStartTime();
        return new Date(time);
    }

    /**
     * 计算相差天数
     */
    public static int differentDaysByMillisecond(Date date1, Date date2) {
        return Math.abs((int) ((date2.getTime() - date1.getTime()) / (1000 * 3600 * 24)));
    }

    /**
     * 计算两个时间差
     */
    public static String getDatePoor(Date endDate, Date nowDate) {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时" + min + "分钟";
    }

    /**
     * 将 LocalDateTime 对象转换为 Date 对象。
     *
     * @param temporalAccessor LocalDateTime 实例
     * @return 返回对应的 Date 实例
     */
    public static Date toDate(LocalDateTime temporalAccessor) {
        // 将 LocalDateTime 转换为系统默认时区的 ZonedDateTime
        ZonedDateTime zdt = temporalAccessor.atZone(ZoneId.systemDefault());
        // 使用 ZonedDateTime 的瞬时时间创建 Date 对象
        return Date.from(zdt.toInstant());
    }

    /**
     * 将 LocalDate 对象转换为 Date 对象。
     *
     * @param temporalAccessor LocalDate 实例
     * @return 返回对应的 Date 实例
     */
    public static Date toDate(LocalDate temporalAccessor) {
        // 将 LocalDate 转换为 LocalDateTime，时间为 00:00:00
        LocalDateTime localDateTime = LocalDateTime.of(temporalAccessor, LocalTime.of(0, 0, 0));
        // 将 LocalDateTime 转换为系统默认时区的 ZonedDateTime
        ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
        // 使用 ZonedDateTime 的瞬时时间创建 Date 对象
        return Date.from(zdt.toInstant());
    }

}

总结

 DateUtils是一个非常有用的日期处理工具类，它简化了日期和时间的处理，提高了开发效率。如果你需要在Java项目中处理日期和时间，不妨试试这个工具类。