DateHelper.java

package com.yanzuoguang.util.helper;

import com.yanzuoguang.util.exception.ExceptionHelper;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;


/**
 * 日期工具类
 *
 * @author 颜佐光
 */
public class DateHelper {

    public static final String FORMAT_YEAR_STRING = "yyyy-01-01";
    public static final String FORMAT_YEAR_END_STRING = "yyyy-12-31";
    public static final String FORMAT_MONTH_STRING = "yyyy-MM-01";
    public static final String FORMAT_DAY_STRING = "yyyy-MM-dd";
    public static final String FORMAT_TIME_STRING = "HH:mm:ss";
    public static final String INIT_TIME = "00:00:00";
    public static final String FORMAT_DAY_HOUR_STRING = "yyyy-MM-dd HH:00:00";
    public static final String FORMAT_SECOND_STRING = "yyyy-MM-dd HH:mm:ss";

    private static final int MONTH_1 = 1;
    private static final int MONTH_2 = 2;
    private static final int MONTH_3 = 3;
    private static final int MONTH_4 = 4;
    private static final int MONTH_5 = 5;
    private static final int MONTH_6 = 6;
    private static final int MONTH_7 = 7;
    private static final int MONTH_8 = 8;
    private static final int MONTH_9 = 9;
    private static final int MONTH_10 = 10;
    private static final int MONTH_11 = 11;
    private static final int MONTH_12 = 12;

    /**
     * 判断时间是否是初始化时间
     *
     * @param time 历史初始化日期
     * @return 新的日期
     */
    public static final boolean isInitTime(String time) {
        if (StringHelper.isEmpty(time)) {
            return true;
        }
        return StringHelper.compare(time, INIT_TIME.substring(0, time.length()));
    }

    /**
     * 判断日期是否需要初始化，当需要时，返回新的日期
     *
     * @param initDay 历史初始化日期
     * @param content 新的日期
     * @return 新的日期
     */
    public static final String getInitDay(String initDay, String content) {
        String today = DateHelper.getToday();
        String contentDay = DateHelper.getToday(content);
        if (!StringHelper.isEmpty(initDay)) {
            initDay = DateHelper.getToday(initDay);
            if (StringHelper.compare(contentDay, initDay)) {
                return StringHelper.EMPTY;
            }
        }
        if (!StringHelper.compare(contentDay, today)) {
            return StringHelper.EMPTY;
        }
        return today;
    }

    /**
     * 获取时间
     *
     * @param from           来源时间
     * @param initMillSecond 是否初始化毫秒为0
     * @return 结束时间
     */
    public static Date getDateTime(Object from, boolean initMillSecond) {
        if (StringHelper.isEmpty(from)) {
            return null;
        }
        try {
            Date to = null;
            if (from instanceof Date) {
                to = (Date) from;
            } else {
                to = DateAutoHelper.getAutoDate(String.valueOf(from));
            }
            to = initMillSecond(to);
            return to;
        } catch (Exception ex) {
            ExceptionHelper.handleException(DateHelper.class, ex, from);
        }
        return null;
    }


    /**
     * 组合日期和时间
     *
     * @param today 日期
     * @param time  时间
     * @return today(日期)+时间
     */
    public static Date mergeTodayTime(Object today, String time) {
        if (StringHelper.isEmpty(today)) {
            return null;
        }
        time = StringHelper.getFirst(time, "00:00:00");
        String day = DateHelper.getToday(today);
        String toResult = String.format("%s %s", day, time);
        return DateHelper.getDateTime(toResult);
    }

    /**
     * 获取时间，会自动初始化毫秒为0
     *
     * @param from 来源时间
     * @return 结束时间
     */
    public static Date getDateTime(Object from) {
        return getDateTime(from, true);
    }

    /**
     * Timestamp 转成 "yyyy-MM-dd HH:mm:ss"字符串
     *
     * @param date 需要处理的日期
     * @return 转换后的字符串
     */
    public static String toString(Timestamp date) {
        if (date == null) {
            return StringHelper.EMPTY;
        }
        SimpleDateFormat format = new SimpleDateFormat(FORMAT_SECOND_STRING);
        return format.format(date);
    }

    /**
     * 取得当前日期对象
     *
     * @return 返回java.util.Date日期对象
     */
    public static Date getCurDate() {
        return new Date();
    }

    /**
     * 将指定Date类型转换成指定格式的字符串,格式串参见类注释
     *
     * @param date   日期方式
     * @param format 指定的格式,当format为NULL或空串时,<BR>
     *               默认为 yyyy-MM-dd 格式
     * @return 当date为NULL时, 返回空串
     */
    public static String getDate(Date date, String format) {
        if (date == null) {
            return StringHelper.EMPTY;
        }
        if (format == null || format.length() == 0) {
            format = "yyyy-MM-dd";
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }

    /**
     * 获取日期 yyyy-MM-dd
     *
     * @param date 日期参数
     * @return 返回的结果
     */
    public static String getYearMonthDay(Date date) {
        return getDate(date, FORMAT_DAY_STRING);
    }

    /**
     * 取得当前日期的字符串表示,格式为 yyyy-MM-dd
     *
     * @return 返回日期的字符串表示
     */
    public static String getToday() {
        return getYearMonthDay(getCurDate());
    }

    /**
     * 取得当前日期的字符串表示,格式为 yyyy-MM-dd
     *
     * @param date
     * @return
     */
    public static String getToday(Object date) {
        return getYearMonthDay(DateHelper.getDateTime(date));
    }

    /**
     * 取得当前日期的字符串表示,格式为 yyyy-MM-dd
     *
     * @param date
     * @return
     */
    public static String getToday(Date date) {
        return getYearMonthDay(date);
    }

    /**
     * 获取日期 yyyy-MM-dd HH:00:00
     *
     * @param date 日期参数
     * @return 返回的结果
     */
    public static String getYearMonthDayHour(Date date) {
        return getDate(date, FORMAT_DAY_HOUR_STRING);
    }

    /**
     * 取得当前日期的字符串表示,格式为 yyyy-MM-dd HH:00:00
     *
     * @return 返回日期的字符串表示
     */
    public static String getTodayHour() {
        return getYearMonthDayHour(getCurDate());
    }

    /**
     * 取得当前日期的字符串表示,格式为 yyyy-MM-dd HH:00:00
     *
     * @param date
     * @return
     */
    public static String getTodayHour(Object date) {
        return getYearMonthDayHour(DateHelper.getDateTime(date));
    }

    /**
     * 取得当前日期的字符串表示,格式为 yyyy-MM-dd HH:00:00
     *
     * @param date
     * @return
     */
    public static String getTodayHour(Date date) {
        return getYearMonthDayHour(date);
    }

    /**
     * 获取年份
     *
     * @param date 需要处理的日期
     * @return 获取到的年份
     */
    public static int getYear(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.YEAR);
    }

    /**
     * 获取月份
     *
     * @param date 需要处理的日期
     * @return 获取到的月份
     */
    public static int getMonth(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.MONTH);
    }

    /**
     * 获取日期
     *
     * @param date 需要处理的日期
     * @return 获取的天数
     */
    public static int getDay(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.DAY_OF_MONTH);
    }

    /**
     * 获取当天的日期
     *
     * @param date 需要的日期
     * @return 返回的日期
     */
    public static Calendar getDayCalendarBegin(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        //当前起始日期
        Calendar begin = Calendar.getInstance();
        begin.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        begin.set(Calendar.MILLISECOND, 0);
        return begin;
    }

    /**
     * 获取当天的日期
     *
     * @param date 需要的日期
     * @return 返回的日期
     */
    public static Date initMillSecond(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.set(Calendar.MILLISECOND, 0);
        return c.getTime();
    }

    private static void setDayEnd(Calendar cal) {
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
    }

    private static void setDayStart(Calendar cal) {
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
    }


    /**
     * 获取某一天起始和结束时间
     *
     * @param date 某一天
     * @return 返回的日期
     */
    public static Date getDayStart(Date date) {
        Calendar begin = getDayCalendarBegin(date);
        return begin.getTime();
    }

    /**
     * 获取某一天起始和结束时间
     *
     * @param date 某一天
     * @return 返回的日期
     */
    public static Date getDayEnd(Date date) {
        Calendar end = getDayCalendarBegin(date);
        setDayEnd(end);
        return end.getTime();
    }


    /**
     * 获取本月开始时间
     *
     * @param date 某一天
     * @return 返回的日期
     */
    public static Date getMonthStart(Date date) {
        Calendar cal = getDayCalendarBegin(date);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        setDayStart(cal);
        return cal.getTime();
    }

    /**
     * 获得本月最后一天24点时间
     *
     * @param date 某一天
     * @return 返回的值
     */
    public static Date getMonthEnd(Date date) {
        Calendar cal = getDayCalendarBegin(date);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        setDayEnd(cal);
        return cal.getTime();
    }


    /**
     * 获取本季度开始时间
     *
     * @param date 某一天
     * @return 返回的日期
     */
    public static Date getMonth3Start(Date date) {
        Calendar cal = getDayCalendarBegin(date);
        int month = cal.get(Calendar.MONTH) / 3 * 3;
        cal.set(Calendar.MONTH, month);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        setDayStart(cal);
        return cal.getTime();
    }

    /**
     * 获得本月最后一天24点时间
     *
     * @param date 某一天
     * @return 返回的值
     */
    public static Date getMonth3End(Date date) {
        Calendar cal = getDayCalendarBegin(date);
        int month = cal.get(Calendar.MONTH) / 3 * 3;
        cal.set(Calendar.MONTH, month + 2);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        setDayEnd(cal);
        return cal.getTime();
    }

    /**
     * 获取本年开始时间
     *
     * @param date 某一天
     * @return 返回值
     */
    public static Date getYearStart(Date date) {
        Calendar cal = getDayCalendarBegin(date);
        cal.set(Calendar.MONTH, 0);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        setDayStart(cal);
        return cal.getTime();
    }

    /**
     * 获取本年结束时间
     *
     * @param date 某一天
     * @return 返回值
     */
    public static Date getYearEnd(Date date) {
        Calendar cal = getDayCalendarBegin(date);
        cal.set(Calendar.MONTH, 11);
        cal.set(Calendar.DAY_OF_MONTH, 31);
        setDayEnd(cal);
        return cal.getTime();
    }

    /**
     * 当日期长度只有到日期时，在最后免补足时间
     *
     * @param from
     * @param patchHour
     * @return
     */
    public static String initDate(String from, String patchHour) {
        if (StringHelper.isEmpty(from)) {
            return from;
        }
        if (from.length() <= 10) {
            return from + patchHour;
        } else {
            return from;
        }
    }

    /**
     * 本季度开始时间
     *
     * @param date 某一天
     * @return 返回值
     */
    public static Date getQuarterStart(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        int currentMonth = c.get(Calendar.MONTH) + 1;
        SimpleDateFormat longSdf = new SimpleDateFormat(FORMAT_SECOND_STRING);
        SimpleDateFormat shortSdf = new SimpleDateFormat(FORMAT_DAY_STRING);
        Date now = null;
        try {
            if (currentMonth >= MONTH_1 && currentMonth <= MONTH_3) {
                c.set(Calendar.MONTH, 0);
            } else if (currentMonth >= MONTH_4 && currentMonth <= MONTH_6) {
                c.set(Calendar.MONTH, MONTH_3);
            } else if (currentMonth >= MONTH_7 && currentMonth <= MONTH_9) {
                c.set(Calendar.MONTH, MONTH_6);
            } else if (currentMonth >= MONTH_10 && currentMonth <= MONTH_12) {
                c.set(Calendar.MONTH, MONTH_9);
            }
            c.set(Calendar.DATE, 1);
            now = longSdf.parse(shortSdf.format(c.getTime()) + " 00:00:00");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }

    /**
     * 本季度的结束时间，即2012-03-31 23:59:59
     *
     * @param date 某一天
     * @return 返回值
     */
    public static Date getQuarterEnd(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getQuarterStart(date));
        cal.add(Calendar.MONTH, 3);
        cal.add(Calendar.MILLISECOND, -1);
        return cal.getTime();
    }

    /**
     * 获取当前时间的年、月
     *
     * @param format 需要的格式
     * @return 返回值
     */
    public static String geYearMonth(String format) {
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }

    /**
     * 获取当前时间的年
     *
     * @return 当前年份
     */
    public static String getCurrentYear() {
        Calendar calendar = Calendar.getInstance();
        return calendar.get(Calendar.YEAR) + "";
    }

    /**
     * 将时间格式转为yyyy-MM-dd HH:mm:ss格式
     *
     * @param date 某一天
     * @return 返回值
     */
    public static String parseToStr(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat(FORMAT_SECOND_STRING);
        return sdf.format(date);
    }


    /**
     * 判断字符串日期是否为同一天
     *
     * @param strFrom 对比的某一天
     * @param strTo   对比的某一天
     * @return 需要的返回值
     */
    public static boolean isEqualsDay(String strFrom, String strTo) {
        try {
            Date dateFrom = DateAutoHelper.getAutoDate(strFrom);
            Date dateTo = DateAutoHelper.getAutoDate(strTo);
            SimpleDateFormat format = new SimpleDateFormat(FORMAT_DAY_STRING);
            return format.format(dateFrom).equals(format.format(dateTo));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 判断两个日期是否为同一年(排除同月同天的情况)
     *
     * @param dateFrom 对比的某一天
     * @param dateTo   对比的某一天
     * @return 需要的返回值
     */
    public static boolean isEqualsYear(Date dateFrom, Date dateTo) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy");
        return format.format(dateFrom).equals(format.format(dateTo));
    }

    /**
     * 判断两个日期是否为同一月
     *
     * @param dateFrom 对比的某一天
     * @param dateTo   对比的某一天
     * @return 需要的返回值
     */
    public static boolean isEqualsMonth(Date dateFrom, Date dateTo) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
        return format.format(dateFrom).equals(format.format(dateTo));
    }

    /**
     * 计算两个日期之间相差的天数
     *
     * @param from 较小的时间
     * @param to   较大的时间
     * @return 相差天数
     */
    public static long betweenDay(Date from, Date to) {
        long mill = betweenMillSecond(from, to, FORMAT_DAY_STRING);
        return mill / (1000 * 3600 * 24);
    }

    /**
     * 计算两个日期之间相差的秒数
     *
     * @param from 较小的时间
     * @param to   较大的时间
     * @return 相差秒数
     */
    public static long betweenSecond(Date from, Date to) {
        long mill = betweenMillSecond(from, to, FORMAT_SECOND_STRING);
        return mill / 1000;
    }

    /**
     * 计算两个时间相差的毫秒数
     *
     * @param from   开始时间
     * @param to     结束时间
     * @param format 通过format来确定精度
     * @return 相差毫秒数
     */
    public static long betweenMillSecond(Date from, Date to, String format) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            from = sdf.parse(sdf.format(from));
            to = sdf.parse(sdf.format(to));

            Calendar cal = Calendar.getInstance();
            cal.setTime(from);
            long fromMill = cal.getTimeInMillis();
            cal.setTime(to);
            long toMill = cal.getTimeInMillis();
            long mill = toMill - fromMill;
            return mill;
        } catch (ParseException ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 获取周,从星期1开始,索引号为0
     *
     * @param dt 传入时间
     * @return 星期序号
     */
    public static int getWeek(Date dt) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(dt);
        int w = cal.get(Calendar.DAY_OF_WEEK);
        if (w < 1) {
            w = 1;
        }
        w = (w + 5) % 7;
        return w;
    }

    /**
     * 获取当前日期是星期几<br>
     *
     * @param dt 传入的时间
     * @return 当前日期是星期几
     */
    public static String getWeekName(Date dt) {
        String[] weekDays = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
        int w = getWeek(dt);
        return weekDays[w];
    }

    /**
     * 根据时间字符串获取对应的周几
     *
     * @param date 时间字符串
     * @return 获取后的结果
     */
    public static String getWeekName1(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int weekIndex = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (weekIndex < 0) {
            weekIndex = 0;
        }
        String[] weeks = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        return weeks[weekIndex];
    }

    /**
     * 增加年份处理
     *
     * @param date 当前日期
     * @param year 需要增加的年份
     * @return 增加之后的值
     */
    public static Date addYear(Date date, int year) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.YEAR, year);
        return cal.getTime();
    }

    /**
     * 增加月份处理
     *
     * @param date  当前日期
     * @param month 需要增加的月份
     * @return 增加之后的值
     */
    public static Date addMonth(Date date, int month) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MONTH, month);
        return cal.getTime();
    }

    /**
     * 增加日期处理
     *
     * @param date 当前日期
     * @param day  需要增加的日期
     * @return 增加之后的值
     */
    public static Date addDay(Date date, int day) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.DATE, day);
        return cal.getTime();
    }

    /**
     * 增加小时处理
     *
     * @param date 当前日期
     * @param hour 需要增加的小时
     * @return 增加之后的值
     */
    public static Date addHour(Date date, int hour) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.HOUR, hour);
        return cal.getTime();
    }

    /**
     * 增加分钟处理
     *
     * @param date   当前日期
     * @param minute 需要增加的分钟
     * @return 增加之后的值
     */
    public static Date addMinute(Date date, int minute) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MINUTE, minute);
        return cal.getTime();
    }

    /**
     * 增加秒处理
     *
     * @param date   当前日期
     * @param second 需要增加的分钟
     * @return 增加之后的值
     */
    public static Date addSecond(Date date, int second) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.SECOND, second);
        return cal.getTime();
    }

    /**
     * 获取当前时间，精准到秒,格式为: yyyy-MM-dd HH:mm:ss
     *
     * @return 当前时间
     */
    public static String getNow() {
        return getDateTimeString(new Date());
    }

    /**
     * 获取时间的字符串，精准到秒，为null则返回空字符串,格式为: yyyy-MM-dd HH:mm:ss
     *
     * @param date 需要获取的时间
     * @return 获取到的结果
     */
    public static String getDateTimeString(Date date) {
        return getDateTimeString(FORMAT_SECOND_STRING, date);
    }

    /**
     * 获取时间为指定格式的字符串，为null则返回空字符串
     *
     * @param format 格式 yyyy-MM-dd HH:mm:ss
     * @param date   字符串
     * @return 转换后的结果
     */
    public static String getDateTimeString(String format, Date date) {
        String to = "";
        if (date != null) {
            to = new SimpleDateFormat(format).format(date);
        }
        return to;
    }

    /**
     * 获取时间为指定格式的字符串，为null则返回空字符串
     *
     * @param format 格式 yyyy-MM-dd HH:mm:ss
     * @param date   字符串
     * @return 转换后的结果
     */
    public static String getDateTimeString(String format, String date) {
        Date dt = getDateTime(date);
        return getDateTimeString(format, dt);
    }

    /**
     * 比较时间
     *
     * @param from 对比时间
     * @param to   结束时间
     * @return 对别结果
     */
    public static int compare(Date from, Date to) {
        if (from == null && to == null) {
            return 0;
        } else if (from == null) {
            return 1;
        } else if (to == null) {
            return -1;
        } else if (from.getTime() < to.getTime()) {
            return 1;
        } else if (from.getTime() > to.getTime()) {
            return -1;
        } else {
            return 0;
        }
    }


    /**
     * 将时间字符串格式化为 yyyy-MM-dd hh:mm:ss
     *
     * @param from 需要格式化的字符串
     * @return 格式化后的结果
     * @throws ParseException 可能抛出不能解释字符串的异常
     */
    public static String formatDateString(String from) {
        try {
            SimpleDateFormat format = new SimpleDateFormat(FORMAT_SECOND_STRING);
            Date dt = format.parse(from);
            return format.format(dt);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }


    /**
     * 判断时间是否在时间段内
     *
     * @param date 当前时间 yyyy-MM-dd HH:mm:ss
     * @param from 开始时间 00:00:00
     * @param to   结束时间 00:05:00
     * @return 是否在时间范围之内
     */
    public static boolean isBetween(Date date, String from, String to) {
        if (date == null) {
            return false;
        }
        Date fromDate = getDateTime(getDateTimeString(FORMAT_DAY_STRING + " " + from, date));
        Date toDate = getDateTime(getDateTimeString(FORMAT_DAY_STRING + " " + to, date));
        if (fromDate != null && date.getTime() < fromDate.getTime()) {
            return false;
        }
        return toDate == null || date.getTime() <= toDate.getTime();
    }

    /**
     * 获取当前日期
     *
     * @param from 当前时间 yyyy-MM-dd HH:mm:ss
     * @return 返回日期: yyyy-MM-dd
     */
    public static String toDay(String from) {
        if (StringHelper.isEmpty(from)) {
            return from;
        }
        try {
            SimpleDateFormat format = new SimpleDateFormat(FORMAT_DAY_STRING);
            return format.format(format.parse(from));
        } catch (ParseException e) {
            ExceptionHelper.handleException(DateHelper.class, e, from);
        }
        return StringHelper.EMPTY;
    }

    /**
     * 获取当前日期字符串
     *
     * @param date 需要获取的日期
     * @return 获取到的日期字符串
     */
    public static String toDay(Date date) {
        SimpleDateFormat format = new SimpleDateFormat(FORMAT_DAY_STRING);
        return format.format(date);
    }

    /**
     * 获取当前日期
     *
     * @param date 需要获取的日期
     * @return 获取到的日期字符串
     */
    public static String toDay(long date) {
        SimpleDateFormat format = new SimpleDateFormat(FORMAT_DAY_STRING);
        return format.format(new Date(date));
    }

    /**
     * 获取指定时间月份的第一天
     *
     * @param time 需要获取的时间
     * @return 指定时间月份的第一天
     */
    public static String toMonth(Date time) {
        return getDateTimeString(FORMAT_MONTH_STRING, time);
    }

    /**
     * 获取指定时间年份的第一天
     *
     * @param time 需要获取的时间
     * @return 指定时间年份的第一天
     */
    public static String toYear(Date time) {
        return getDateTimeString(FORMAT_YEAR_STRING, time);
    }

    /**
     * 判断是否时时间格式字符串
     *
     * @param from 来源字符串
     * @return 是否时时间字符串
     */
    public static boolean isDateFormat(String from) {
        try {
            return DateAutoHelper.getAutoDate(from) != null;
        } catch (Exception ex) {
            return false;
        }
    }

    private static final long MINUTE_UNIT = 1000 * 60;
    private static final long HOUR_MINUTE_UNIT = 15;

    /**
     * 获取小时中的刻度时间
     *
     * @param from 来源时间
     * @return
     */
    public static String getHourUnitTime(Object from) {
        return getHourUnitTime(from, HOUR_MINUTE_UNIT);
    }

    /**
     * 获取小时中的刻度时间
     *
     * @param from 来源时间
     * @return
     */
    public static String getHourUnitTime(Object from, long minute) {
        Date dateTime = getDateTime(from);
        if (dateTime == null) {
            return null;
        }
        // 获取当前小时，用于累加
        Date hour = DateHelper.getDateTime(DateHelper.getDateTimeString("yyyy-MM-dd HH:00:00.000", dateTime));
        // 获取当前小时毫秒数量
        long totalMill = dateTime.getTime() - hour.getTime();
        // 计算分钟单位
        long unit = totalMill / MINUTE_UNIT / minute;
        // 计算四舍五入后的时间
        Date to = new Date(hour.getTime() + unit * MINUTE_UNIT * minute);
        // 将时间转换为字符串
        return DateHelper.getDateTimeString(to);
    }


    /**
     * 获取小时中的刻度时间
     *
     * @param from 来源时间
     * @return
     */
    public static int getMonthBetween(Object from, Object to) {
        Date fromDate = getDateTime(from);
        Date toDate = getDateTime(to);
        if (from == null || toDate == null) {
            return 0;
        }
        Calendar bef = Calendar.getInstance();
        bef.setTime(fromDate);
        Calendar aft = Calendar.getInstance();
        aft.setTime(getDateTime(toDate));
        int surplus = aft.get(Calendar.DATE) - bef.get(Calendar.DATE);
        int result = aft.get(Calendar.MONTH) - bef.get(Calendar.MONTH);
        int month = (aft.get(Calendar.YEAR) - bef.get(Calendar.YEAR)) * 12;
        surplus = surplus <= 0 ? 1 : 0;
        return (Math.abs(month + result) + surplus);
    }

}