时间相关工具类

/**
 * 时间相关工具类
 */
public final class TimeUtil {
    private static final String TAG = TimeUtil.class.getClass().getSimpleName();
    /* 默认的时间格式 */
    private static final String DEF_FORMAT = "yyyy-MM-dd HH:mm:ss";

    private TimeUtil() {
        throw new UnsupportedOperationException("cannot be instantiated");
    }

    /**
     * 将时间戳转为时间字符串
     *
     * @param millis 时间戳
     * @return 时间字符串
     */
    public static String millis2String(long millis) {
        return millis2String(millis, DEF_FORMAT);
    }

    /**
     * 将时间戳转为时间字符串
     *
     * @param millis 时间戳
     * @param format 时间格式
     * @return 时间字符串
     */
    public static String millis2String(long millis, @Nullable String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(new Date(millis));
    }

    /**
     * 将时间字符串转换为时间戳
     *
     * @param timeStr 时间字符串
     * @return 毫秒时间戳
     */
    public static long string2Millis(String timeStr) {
        return TextUtils.isEmpty(timeStr) ? 0 : string2Millis(timeStr, DEF_FORMAT);
    }

    /**
     * 将时间字符串转换为时间戳
     *
     * @param timeStr 时间字符串
     * @param format  时间格式
     * @return
     */
    public static long string2Millis(String timeStr, @Nullable String format) {
        if (TextUtils.isEmpty(timeStr)) return 0;
        long millis = 0;
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            Date date = sdf.parse(timeStr);
            millis = date.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
            LogUtil.e(TAG, "String2Millis Error ========> timeStr: " + timeStr);
        }
        return millis;
    }

    /**
     * 将时间字符串转为 Date 类型
     *
     * @param timeStr 时间字符串
     * @return Date 类型
     */
    public static Date string2Date(String timeStr) {
        return TextUtils.isEmpty(timeStr) ? null : string2Date(timeStr, DEF_FORMAT);
    }

    /**
     * 将时间字符串转为 Date 类型
     *
     * @param timeStr 时间字符串
     * @param format  时间格式
     * @return Date 类型
     */
    public static Date string2Date(String timeStr, @Nullable String format) {
        if (TextUtils.isEmpty(timeStr)) return null;
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            return sdf.parse(timeStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 将 Date 类型转为时间字符串
     *
     * @param date Date 类型时间
     * @return 时间字符串
     */
    public static String date2String(Date date) {
        return date == null ? null : date2String(date, DEF_FORMAT);
    }

    /**
     * 将 Date 类型转为时间字符串
     * <p>格式为 format</p>
     *
     * @param date   Date 类型时间
     * @param format 时间格式
     * @return 时间字符串
     */
    public static String date2String(Date date, @Nullable String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }

    /**
     * 将 Date 类型转为时间戳
     *
     * @param date Date 类型时间
     * @return 毫秒时间戳
     */
    public static long date2Millis(Date date) {
        return date == null ? null : date.getTime();
    }

    /**
     * 将时间戳转为 Date 类型
     *
     * @param millis 毫秒时间戳
     * @return Date 类型时间
     */
    public static Date millis2Date(long millis) {
        return new Date(millis);
    }

    /**
     * 将时间转换天数、小时数、分钟数、秒数
     *
     * @param timeStr 时间字符串
     * @return int[0]: 天数 <br> int[1]: 小时数 <br> int[2]: 分钟数 <br> int[3]: 秒数
     */
    public static int[] millis2Array(String timeStr) {
        return millis2Array(timeStr, DEF_FORMAT);
    }

    /**
     * 将时间转换天数、小时数、分钟数、秒数
     *
     * @param timeStr 时间字符串
     * @param format  时间格式
     * @return int[0]: 天数 <br> int[1]: 小时数 <br> int[2]: 分钟数 <br> int[3]: 秒数
     */
    public static int[] millis2Array(String timeStr, @Nullable String format) {
        return TextUtils.isEmpty(timeStr) ? null : millis2Array(string2Millis(timeStr));
    }

    /**
     * 将时间转换天数、小时数、分钟数、秒数
     *
     * @param date 时间
     * @return int[0]: 天数 <br> int[1]: 小时数 <br> int[2]: 分钟数 <br> int[3]: 秒数
     */
    public static int[] millis2Array(Date date) {
        return date == null ? null : millis2Array(date.getTime());
    }

    /**
     * 将时间转换天数、小时数、分钟数、秒数
     *
     * @param millis 毫秒数
     * @return int[0]: 天数 <br> int[1]: 小时数 <br> int[2]: 分钟数 <br> int[3]: 秒数
     */
    public static int[] millis2Array(long millis) {
        long secondDiff = millis / 1000;
        int days = (int) (secondDiff / (60 * 60 * 24));
        int hours = (int) ((secondDiff - days * (60 * 60 * 24)) / (60 * 60));
        int minutes = (int) ((secondDiff - days * (60 * 60 * 24) - hours * (60 * 60)) / 60);
        int seconds = (int) ((secondDiff - days * (60 * 60 * 24) - hours * (60 * 60) - minutes * 60));
        return new int[]{days, hours, minutes, seconds};
    }

    /**
     * 计算时间差
     *
     * @param startTime 起始时间
     * @param endTime   结束时间
     * @return 毫秒级时间差
     */
    public static long caculateTimeDiff(@NonNull Object startTime, @NonNull Object endTime) {
        return caculateTimeDiff(startTime, endTime, DEF_FORMAT);
    }

    /**
     * 计算时间差
     *
     * @param startTime 起始时间
     * @param endTime   结束时间
     * @param foramt    时间格式
     * @return 毫秒级时间差
     */
    public static long caculateTimeDiff(@NonNull Object startTime, @NonNull Object endTime, @Nullable String foramt) {
        long milliStart, milliEnd;
        if (startTime instanceof String) {
            milliStart = string2Millis((String) startTime, foramt);
        } else if (startTime instanceof Long) {
            milliStart = (long) startTime;
        } else if (startTime instanceof Date) {
            milliStart = ((Date) startTime).getTime();
        } else {
            LogUtil.e(TAG, "Error startTime in the caculateTimeDiff () method ========> startTime: " + startTime);
            throw new UnsupportedOperationException("startTime foramt error");
        }
        if (endTime instanceof String) {
            milliEnd = string2Millis((String) endTime, foramt);
        } else if (endTime instanceof Long) {
            milliEnd = (long) endTime;
        } else if (endTime instanceof Date) {
            milliEnd = ((Date) endTime).getTime();
        } else {
            LogUtil.e(TAG, "Error endTime in the caculateTimeDiff () method ========> endTime: " + endTime);
            throw new UnsupportedOperationException("endTime foramt error");
        }
        return (milliEnd - milliStart);
    }

    /**
     * 计算时间差
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return int[0]: 天数 <br> int[1]: 小时数 <br> int[2]: 分钟数 <br> int[3]: 秒数
     */
    public static int[] caculateTimeDiffArray(@NonNull Object startTime, @NonNull Object endTime) {
        return caculateTimeDiffArray(startTime, endTime);
    }

    /**
     * 计算时间差
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @param format    时间格式
     * @return int[0]: 天数 <br> int[1]: 小时数 <br> int[2]: 分钟数 <br> int[3]: 秒数
     */
    public static int[] caculateTimeDiffArray(@NonNull Object startTime, @NonNull Object endTime, @Nullable String format) {
        return millis2Array(caculateTimeDiff(startTime, endTime, format));
    }

    /**
     * 比较两个时间的大小
     *
     * @param t1 时间 1
     * @param t2 时间 2
     * @return {@code true}: t1 >= t2<br>{@code false}: t1 < t2
     */
    public static boolean judgeTime(@NonNull Object t1, @NonNull Object t2) {
        return caculateTimeDiff(t2, t1) >= 0;
    }
}