java 时间类详解（二）

时间在我们平时的工作中是不可缺少的，而时间又可以单独提取出来做为一个工具类，可以多处利用，避免重复代码，提供代码的复用。

public class DateUtils {

    private static final String DEFAULT_FORMATTER = "yyyy-MM-dd HH:mm:ss";

    private static final String YAER = "YEAR";
    private static final String MONTH = "MONTH";
    private static final String DAY = "DAY";
    private static final String HOURS = "HOURS";
    private static final String MINUTES = "MINUTES";

    /**
     * 功能描述 用于时间格式化 时间格式为 yyyy-MM-dd HH:mm:ss
     */
    public static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern(DEFAULT_FORMATTER);

    /**
     * 功能描述 用于日期的剧本格式 时间格式为 yyyy-MM-dd
     */
    public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    /**
     * 获取到秒的时间的当前时间，使用的使用默认的格式化 @see FORMATTER
     *
     * @return currentTime
     * @returnType String
     */
    public static String getCurrentDateTime() {
        LocalDateTime now = LocalDateTime.now();
        return FORMATTER.format(now);
    }

    /**
     * 获取到秒的时间的当前时间，使用的使用调用放传过来的自定类型
     *
     * @param pattern
     * @return currentTime
     * @returnType String
     */
    public static String getCurrentDateTime(String pattern) {
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern(pattern);
        return dtf.format(now);
    }

    /**
     * 根据不同的时间类型返回时间串
     *
     * @param param
     * @return convertResult
     * @returnType String
     */
    public static String getDifferentTypeTime(Object param) {
        if (param instanceof Date) {
            SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_FORMATTER);
            return sdf.format(param);
        }
        if (param instanceof Calendar) {
            SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_FORMATTER);
            return sdf.format(((Calendar) param).getTime());
        }
        if (param instanceof LocalDateTime) {
            return FORMATTER.format((LocalDateTime) param);
        }
        if (param instanceof LocalDate) {
            return DATE_FORMATTER.format((LocalDate) param);
        }
        throw new UnsupportedOperationException("暂不支持该类型的时间转换");
    }

    /**
     * 根据不同的时间类型返回时间串
     *
     * @param param
     * @return convertResult
     * @returnType String
     */
    public static String getDifferentTypeTime(Object param, String pattern) {
        if (param instanceof Date) {
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
            return sdf.format(param);
        }
        if (param instanceof Calendar) {
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
            return sdf.format(((Calendar) param).getTime());
        }
        if (param instanceof LocalDateTime) {
            DateTimeFormatter dtf = DateTimeFormatter.ofPattern(pattern);
            return dtf.format((LocalDateTime) param);
        }
        if (param instanceof LocalDate) {
            DateTimeFormatter dtf = DateTimeFormatter.ofPattern(pattern);
            try {
                return dtf.format((LocalDate) param);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        throw new UnsupportedOperationException("暂不支持该类型的时间转换");
    }


    /**
     * 根据不同时间串对这个时间的对应的年或月、日、小时、分钟做操作（fieldName决定）
     *
     * @param date      待操作的时间串
     * @param filedName 要操作的字段名称
     * @param num       具体操作的值
     * @return convertResult
     * @returnType String
     */
    public static String operationTime(String date, String filedName, Integer num) {
        // 传过来的字段不为空才做具体操作, 为空返回默认值.
        if (!isEmptyStr(filedName)) {
            LocalDateTime dateTime = LocalDateTime.parse(date, FORMATTER);
            if (filedName.equalsIgnoreCase(YAER)) {
                if (num >= 0) {
                    dateTime.plusYears(num);
                } else {
                    dateTime.minusYears(Math.abs(num));
                }
            }
            if (filedName.equalsIgnoreCase(MONTH)) {
                if (num >= 0) {
                    dateTime.plusMonths(num);
                } else {
                    dateTime.minusMinutes(Math.abs(num));
                }
            }
            if (filedName.equalsIgnoreCase(DAY)) {
                if (num >= 0) {
                    dateTime.plusDays(num);
                } else {
                    dateTime.minusDays(Math.abs(num));
                }
            }
            if (filedName.equalsIgnoreCase(MINUTES)) {
                if (num >= 0) {
                    dateTime.plusMinutes(num);
                } else {
                    dateTime.minusMinutes(Math.abs(num));
                }
            }
            if (filedName.equalsIgnoreCase(HOURS)) {
                if (num >= 0) {
                    dateTime.plusHours(num);
                } else {
                    dateTime.minusHours(Math.abs(num));
                }
            }
            return FORMATTER.format(dateTime);
        }
        return date;
    }

    /**
     * 带判断的时间串（当前时间），小于当前时间则返回  <0，
     * 大于则返回 > 0
     * 等于 则放回 0
     *
     * @param string 待判断的字符串
     * @returnType String
     */
    public static int compareNow(String string) {
        LocalDateTime now = LocalDateTime.now();
        return FORMATTER.format(now).compareTo(string);
    }

    /**
     * 带判断的时间串（当前时间），小于当前时间则返回  <0，
     * 大于则返回 > 0
     * 等于 则放回 0
     *
     * @param firstTime  第一个参数（待对比对象）
     * @param secondTime 第二个参数（待对比对象）
     * @returnType String
     */
    public static int compareNow(String firstTime, String secondTime) {
        return firstTime.compareTo(secondTime);
    }

    /**
     * 判断字符串是否为空
     *
     * @param string 待判断的字符串
     * @returnType String
     */
    public static boolean isEmptyStr(String string) {
        return ("".equals(string) || string == null) == true ? true : false;
    }

    /**
     * 计算的时间串的与当前时间的差值为多少
     *
     * @param dateStr 待判断的时间串
     * @returnType int
     */
    public static int calcDuration(String dateStr) {
        LocalDateTime dateTime = LocalDateTime.parse(dateStr, FORMATTER);
        LocalDateTime now = LocalDateTime.now();
        long minutes = Duration.between(dateTime, now).toMinutes();
        return (int) minutes;
    }

}