时间转换工具类

在项目中，会出现频繁的一个时间转换的操作，时间戳转换为String、LocalDateTime转换为字符串等等。为此，笔者特地写了一个时间转换的工具类，以便快速地进行时间类型转换。

最终的效果如下：

测试的部分样例如下：

    public static void main(String[] args) {
        LocalDateTime time1 = TimeUtil.transfer("2021-12-21 12:12:12", LocalDateTime.class);
        Date time2 = TimeUtil.transfer("2021-12-21 12:12:12", Date.class);
        String time3 = TimeUtil.transfer("2021-12-21 12:12:12", String.class);
        LocalDate time4 = TimeUtil.transfer("2021-12-21 12:12:12", LocalDate.class);
        Long time5 = TimeUtil.transfer("2021-12-21 12:12:12", Long.class);
        System.out.println("time1 = " + time1);
        System.out.println("time2 = " + time2);
        System.out.println("time3 = " + time3);
        System.out.println("time4 = " + time4);
        System.out.println("time5 = " + time5);
    }

输出结果如下：

代码

package cn.stopyc;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author stopyc
 * @program: util
 * @description: 时间工具类
 * @author: stop.yc
 * @create: 2023-01-16 00:28
 **/
public class TimeUtil {

    /**默认的时间格式*/
    private static final String LOCAL_DATE_TIME = "yyyy-MM-dd HH:mm:ss";

    /**默认的日期格式*/
    private static final String LOCAL_DATE = "yyyy-MM-dd";

    /**默认的时间格式正则表达式*/
    private static final String LOCAL_DATE_TIME_PATTERN = "^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$";

    /**默认的日期格式正则表达式*/
    private static final String LOCAL_DATE_PATTERN = "^\\d{4}-\\d{2}-\\d{2}$";

    /**
     * 默认的时间格式校验器
     */
    private static final Pattern R_LOCAL_DATE_TIME = Pattern.compile(LOCAL_DATE_TIME_PATTERN);

    /**
     * 默认的日期格式校验器
     */
    private static final Pattern R_LOCAL_DATE = Pattern.compile(LOCAL_DATE_PATTERN);

    /**
     * 时间格式转换器
     */
    private static DateTimeFormatter formatter;

    /**
     * 获取时间格式转换器
     * @param formatStr :时间格式
     * @return :时间格式器
     */
    private static DateTimeFormatter getFormatter(String formatStr) {
        return DateTimeFormatter.ofPattern(formatStr);
    }

    /**
     * LocalDateTime2指定类型时间
     * @param time :LocalDateTime
     * @param targetTimeClazz :指定时间类型
     * @param <T> :指定时间类型
     * @return :指定时间
     */
    public static <T> T transfer(LocalDateTime time, Class<T> targetTimeClazz) {
        String timeStr = allTypeToTimeStr(time, LocalDateTime.class);
        return transferIn(timeStr, targetTimeClazz);
    }

    /**
     * LocalDate2指定类型时间
     * @param time :LocalDate
     * @param targetTimeClazz :指定时间类型
     * @param <T> :指定时间类型
     * @return :指定时间
     */
    public static <T> T transfer(LocalDate time, Class<T> targetTimeClazz) {

        String timeStr = allTypeToTimeStr(time, LocalDate.class);

        return transferIn(timeStr, targetTimeClazz);
    }

    /**
     * date2指定类型时间
     * @param time :date
     * @param targetTimeClazz :指定时间类型
     * @param <T> :指定时间类型
     * @return :指定时间
     */
    public static <T> T transfer(Date time, Class<T> targetTimeClazz) {

        String timeStr = allTypeToTimeStr(time, Date.class);

        return transferIn(timeStr, targetTimeClazz);
    }

    /**
     * 时间字符串2指定类型时间
     * @param time :时间字符串
     * @param targetTimeClazz :指定时间类型
     * @param <T> :指定时间类型
     * @return :指定时间
     */
    public static <T> T transfer(String time, Class<T> targetTimeClazz) {
        String timeStr = allTypeToTimeStr(time, String.class);
        return transferIn(timeStr, targetTimeClazz);
    }

    /**
     * 时间戳2指定类型时间
     * @param time :时间戳
     * @param targetTimeClazz :指定时间类型
     * @param <T> :指定时间类型
     * @return :指定时间
     */
    public static <T> T transfer(Long time, Class<T> targetTimeClazz) {
        String timeStr = allTypeToTimeStr(time, Long.class);
        return transferIn(timeStr, targetTimeClazz);
    }

    /**
     * 任意类型转化为时间格式字符串
     * @param time :时间
     * @param timeClazz :时间类型字节码
     * @param <T> :时间类型
     * @return :时间格式字符串
     */
    private static <T> String allTypeToTimeStr(T time, Class<T> timeClazz) {
        if (String.class.equals(timeClazz)) {
            return (String) time;
        } else if (LocalDateTime.class.equals(timeClazz)) {
            return localDateTimeToTimeStr((LocalDateTime) time);
        } else if (LocalDate.class.equals(timeClazz)) {
            return timeStrToDateTimeStr(((LocalDate) time).format(getFormatter(LOCAL_DATE)));
        } else if (Long.class.equals(timeClazz)) {
            LocalDateTime localDateTime = LocalDateTime.ofEpochSecond((Long) time, 0, ZoneOffset.ofHours(8));
            return localDateTimeToTimeStr(localDateTime);
        } else {
            throw new RuntimeException("传入的时间类型错误!");
        }
    }

    /**
     * 内部实际转换器
     * @param timeStr :时间字符串
     * @param targetTimeClazz :指定时间类型
     * @param <T> :指定时间类型
     * @return :指定时间
     */
    @SuppressWarnings("unchecked")
    private static <T> T transferIn(String timeStr,Class<T> targetTimeClazz) {
        checkTimeFormat(timeStr);

        timeStr = timeStrToDateTimeStr(timeStr);
        if (LocalDateTime.class.equals(targetTimeClazz)) {
            return (T) timeStrToLocalDateTime(timeStr);
        } else if (LocalDate.class.equals(targetTimeClazz)) {
            return (T) timeStrToLocalDate(timeStr);
        } else if (Long.class.equals(targetTimeClazz)) {
            return (T) timeStrToLong(timeStr);
        } else if (Date.class.equals(targetTimeClazz)) {
            return (T) timeStrToDate(timeStr);
        } else if (String.class.equals(targetTimeClazz)) {
            return (T) timeStr;
        } else {
            throw new RuntimeException("只可以转换为LocalDateTime、Long、Date、LocalDate、String类型!");
        }
    }

    /**
     * 检查时间日期格式
     * @param time :时间日期字符串
     */
    private static void checkTimeFormat(String time) {
        //首先匹配是否为正确的字符串
        Matcher m = R_LOCAL_DATE_TIME.matcher(time);
        Matcher n = R_LOCAL_DATE.matcher(time);
        if (!(m.find() || n.find())) {
            throw new RuntimeException("时间格式错误!");
        }
    }

    /**
     * localDateTimeToTimeStr
     * @param time :localDateTime
     * @return :时间字符串
     */
    private static String localDateTimeToTimeStr(LocalDateTime time) {
        formatter = getFormatter(LOCAL_DATE_TIME);
        return formatter.format(time);
    }

    /**
     * timeStrToDate
     * @param time :timeStr
     * @return :date
     */
    private static Date timeStrToDate(String time) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(LOCAL_DATE_TIME);
        try {
            return dateFormat.parse(time);
        } catch (ParseException e) {
            throw new RuntimeException("时间转换错误!");
        }
    }

    /**
     * timeStrToDateTimeStr
     * @param time: timeStr
     * @return :date格式的时间字符串
     */
    private static String timeStrToDateTimeStr(String time) {
        Matcher m = R_LOCAL_DATE_TIME.matcher(time);
        if (!m.find()) {
            return time + " 00:00:00";
        }
        return time;
    }

    /**
     * localDateTimeToLong
     * @param localDateTime :localDateTime
     * @return: 时间戳
     */
    private static Long localDateTimeToLong(LocalDateTime localDateTime) {
        ZoneId zone = ZoneId.systemDefault();
        Instant instant = localDateTime.atZone(zone).toInstant();
        return instant.toEpochMilli();
    }

    /**
     * timeStrToLocalDateTime
     * @param time :timeStr
     * @return :localDateTime
     */
    private static LocalDateTime timeStrToLocalDateTime(String time) {
        return LocalDateTime.parse(time, getFormatter(LOCAL_DATE_TIME));
    }

    /**
     * timeStrToLocalDate
     * @param time :timeStr
     * @return :LocalDate
     */
    private static LocalDate timeStrToLocalDate(String time) {
        return timeStrToLocalDateTime(time).toLocalDate();
    }

    /**
     * timeStrToLong
     * @param time :timeStr
     * @return :long
     */
    private static Long timeStrToLong(String time) {
        return localDateTimeToLong(timeStrToLocalDateTime(time));
    }
}