AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

格式化各种类型时间格式

2021-08-31 509
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 功能齐全，使用方便

public final class TimeUtil {

public static String millis2String(final long millis, final DateFormat format) {
    return format.format(new Date(millis));
}

/**
 * 将时间字符串转为时间戳
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return 毫秒时间戳
 */
public static long string2Millis(final String time) {
    if (TextUtils.isEmpty(time)){
        return -1;
    }
    return string2Millis(time, DEFAULT_FORMAT);
}

/**
 * 将时间字符串转为时间戳
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return 毫秒时间戳
 */
public static long string2Millis(final String time, final DateFormat format) {
    try {
        return format.parse(time).getTime();
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return -1;
}

/**
 * 将时间字符串转为时间戳
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @return 毫秒时间戳
 */
public static String string2String(final String time,final DateFormat format) {
    try {
        return format.format(time);

// return DEFAULT_FORMAT.format(DEFAULT_FORMAT2.parse(time).getTime());

    } catch (Exception e) {
        e.printStackTrace();
    }
    return "";
}

/**
 * 将时间字符串转为Date类型
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return Date类型
 */
public static Date string2Date(final String time) {
    return string2Date(time, DEFAULT_FORMAT);
}

/**
 * 将时间字符串转为Date类型
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return Date类型
 */
public static Date string2Date(final String time, final DateFormat format) {
    try {
        return format.parse(time);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return null;
}

/**
 * 将Date类型转为时间字符串
 * <p>格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param date Date类型时间
 * @return 时间字符串
 */
public static String date2String(final Date date) {
    return date2String(date, DEFAULT_FORMAT);
}

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

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

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

/**
 * 获取两个时间差（单位：unit）
 * <p>time0和time1格式都为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time0 时间字符串0
 * @param time1 时间字符串1
 * @param unit  单位类型
 *              <ul>
 *              <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *              <li>{@link TimeConstants#SEC }: 秒</li>
 *              <li>{@link TimeConstants#MIN }: 分</li>
 *              <li>{@link TimeConstants#HOUR}: 小时</li>
 *              <li>{@link TimeConstants#DAY }: 天</li>
 *              </ul>
 * @return unit时间戳
 */
public static long getTimeSpan(final String time0, final String time1, @TimeConstants.Unit final int unit) {
    return getTimeSpan(time0, time1, DEFAULT_FORMAT, unit);
}

/**
 * 获取两个时间差（单位：unit）
 * <p>time0和time1格式都为format</p>
 *
 * @param time0  时间字符串0
 * @param time1  时间字符串1
 * @param format 时间格式
 * @param unit   单位类型
 *               <ul>
 *               <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *               <li>{@link TimeConstants#SEC }: 秒</li>
 *               <li>{@link TimeConstants#MIN }: 分</li>
 *               <li>{@link TimeConstants#HOUR}: 小时</li>
 *               <li>{@link TimeConstants#DAY }: 天</li>
 *               </ul>
 * @return unit时间戳
 */
public static long getTimeSpan(final String time0, final String time1, final DateFormat format, @TimeConstants.Unit final int unit) {
    return millis2TimeSpan(Math.abs(string2Millis(time0, format) - string2Millis(time1, format)), unit);
}

/**
 * 获取两个时间差（单位：unit）
 *
 * @param date0 Date类型时间0
 * @param date1 Date类型时间1
 * @param unit  单位类型
 *              <ul>
 *              <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *              <li>{@link TimeConstants#SEC }: 秒</li>
 *              <li>{@link TimeConstants#MIN }: 分</li>
 *              <li>{@link TimeConstants#HOUR}: 小时</li>
 *              <li>{@link TimeConstants#DAY }: 天</li>
 *              </ul>
 * @return unit时间戳
 */
public static long getTimeSpan(final Date date0, final Date date1, @TimeConstants.Unit final int unit) {
    return millis2TimeSpan(Math.abs(date2Millis(date0) - date2Millis(date1)), unit);
}

/**
 * 获取两个时间差（单位：unit）
 *
 * @param millis0 毫秒时间戳0
 * @param millis1 毫秒时间戳1
 * @param unit    单位类型
 *                <ul>
 *                <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                <li>{@link TimeConstants#SEC }: 秒</li>
 *                <li>{@link TimeConstants#MIN }: 分</li>
 *                <li>{@link TimeConstants#HOUR}: 小时</li>
 *                <li>{@link TimeConstants#DAY }: 天</li>
 *                </ul>
 * @return unit时间戳
 */
public static long getTimeSpan(final long millis0, final long millis1, @TimeConstants.Unit final int unit) {
    return millis2TimeSpan(Math.abs(millis0 - millis1), unit);
}

/**
 * 获取合适型两个时间差
 * <p>time0和time1格式都为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time0     时间字符串0
 * @param time1     时间字符串1
 * @param precision 精度
 *                  <p>precision = 0，返回null</p>
 *                  <p>precision = 1，返回天</p>
 *                  <p>precision = 2，返回天和小时</p>
 *                  <p>precision = 3，返回天、小时和分钟</p>
 *                  <p>precision = 4，返回天、小时、分钟和秒</p>
 *                  <p>precision &gt;= 5，返回天、小时、分钟、秒和毫秒</p>
 * @return 合适型两个时间差
 */
public static String getFitTimeSpan(final String time0, final String time1, final int precision) {
    return millis2FitTimeSpan(Math.abs(string2Millis(time0, DEFAULT_FORMAT) - string2Millis(time1, DEFAULT_FORMAT)), precision);
}

/**
 * 获取合适型两个时间差
 * <p>time0和time1格式都为format</p>
 *
 * @param time0     时间字符串0
 * @param time1     时间字符串1
 * @param format    时间格式
 * @param precision 精度
 *                  <p>precision = 0，返回null</p>
 *                  <p>precision = 1，返回天</p>
 *                  <p>precision = 2，返回天和小时</p>
 *                  <p>precision = 3，返回天、小时和分钟</p>
 *                  <p>precision = 4，返回天、小时、分钟和秒</p>
 *                  <p>precision &gt;= 5，返回天、小时、分钟、秒和毫秒</p>
 * @return 合适型两个时间差
 */
public static String getFitTimeSpan(final String time0, final String time1, final DateFormat format, final int precision) {
    return millis2FitTimeSpan(Math.abs(string2Millis(time0, format) - string2Millis(time1, format)), precision);
}

/**
 * 获取合适型两个时间差
 *
 * @param date0     Date类型时间0
 * @param date1     Date类型时间1
 * @param precision 精度
 *                  <p>precision = 0，返回null</p>
 *                  <p>precision = 1，返回天</p>
 *                  <p>precision = 2，返回天和小时</p>
 *                  <p>precision = 3，返回天、小时和分钟</p>
 *                  <p>precision = 4，返回天、小时、分钟和秒</p>
 *                  <p>precision &gt;= 5，返回天、小时、分钟、秒和毫秒</p>
 * @return 合适型两个时间差
 */
public static String getFitTimeSpan(final Date date0, final Date date1, final int precision) {
    return millis2FitTimeSpan(Math.abs(date2Millis(date0) - date2Millis(date1)), precision);
}

/**
 * 获取合适型两个时间差
 *
 * @param millis0   毫秒时间戳1
 * @param millis1   毫秒时间戳2
 * @param precision 精度
 *                  <p>precision = 0，返回null</p>
 *                  <p>precision = 1，返回天</p>
 *                  <p>precision = 2，返回天和小时</p>
 *                  <p>precision = 3，返回天、小时和分钟</p>
 *                  <p>precision = 4，返回天、小时、分钟和秒</p>
 *                  <p>precision &gt;= 5，返回天、小时、分钟、秒和毫秒</p>
 * @return 合适型两个时间差
 */
public static String getFitTimeSpan(final long millis0, final long millis1, final int precision) {
    return millis2FitTimeSpan(Math.abs(millis0 - millis1), precision);
}

/**
 * 获取当前毫秒时间戳
 *
 * @return 毫秒时间戳
 */
public static long getNowMills() {
    return System.currentTimeMillis();
}

/**
 * 获取当前时间字符串
 *
 * @param pattern 格式化时间的格式
 * @return
 */
public static String getNowString(String pattern) {
    return millis2String(System.currentTimeMillis(), TextUtils.isEmpty(pattern) ? DEFAULT_FORMAT : new SimpleDateFormat(pattern, Locale.getDefault()));
}

/**
 * 获取当前时间字符串
 * <p>格式为format</p>
 *
 * @param format 时间格式
 * @return 时间字符串
 */
public static String getNowString(final DateFormat format) {
    return millis2String(System.currentTimeMillis(), format);
}

/**
 * 获取当前Date
 *
 * @return Date类型时间
 */
public static Date getNowDate() {
    return new Date();
}

/**
 * 获取与当前时间的差（单位：unit）
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @param unit 单位类型
 *             <ul>
 *             <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *             <li>{@link TimeConstants#SEC }: 秒</li>
 *             <li>{@link TimeConstants#MIN }: 分</li>
 *             <li>{@link TimeConstants#HOUR}: 小时</li>
 *             <li>{@link TimeConstants#DAY }: 天</li>
 *             </ul>
 * @return unit时间戳
 */
public static long getTimeSpanByNow(final String time, @TimeConstants.Unit final int unit) {
    return getTimeSpan(getNowString(""), time, DEFAULT_FORMAT, unit);
}

/**
 * 获取与当前时间的差（单位：unit）
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @param unit   单位类型
 *               <ul>
 *               <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *               <li>{@link TimeConstants#SEC }: 秒</li>
 *               <li>{@link TimeConstants#MIN }: 分</li>
 *               <li>{@link TimeConstants#HOUR}: 小时</li>
 *               <li>{@link TimeConstants#DAY }: 天</li>
 *               </ul>
 * @return unit时间戳
 */
public static long getTimeSpanByNow(final String time, final DateFormat format, @TimeConstants.Unit final int unit) {
    return getTimeSpan(getNowString(format), time, format, unit);
}

/**
 * 获取与当前时间的差（单位：unit）
 *
 * @param date Date类型时间
 * @param unit 单位类型
 *             <ul>
 *             <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *             <li>{@link TimeConstants#SEC }: 秒</li>
 *             <li>{@link TimeConstants#MIN }: 分</li>
 *             <li>{@link TimeConstants#HOUR}: 小时</li>
 *             <li>{@link TimeConstants#DAY }: 天</li>
 *             </ul>
 * @return unit时间戳
 */
public static long getTimeSpanByNow(final Date date, @TimeConstants.Unit final int unit) {
    return getTimeSpan(new Date(), date, unit);
}

/**
 * 获取与当前时间的差（单位：unit）
 *
 * @param millis 毫秒时间戳
 * @param unit   单位类型
 *               <ul>
 *               <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *               <li>{@link TimeConstants#SEC }: 秒</li>
 *               <li>{@link TimeConstants#MIN }: 分</li>
 *               <li>{@link TimeConstants#HOUR}: 小时</li>
 *               <li>{@link TimeConstants#DAY }: 天</li>
 *               </ul>
 * @return unit时间戳
 */
public static long getTimeSpanByNow(final long millis, @TimeConstants.Unit final int unit) {
    return getTimeSpan(System.currentTimeMillis(), millis, unit);
}

/**
 * 获取合适型与当前时间的差
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time      时间字符串
 * @param precision 精度
 *                  <ul>
 *                  <li>precision = 0，返回null</li>
 *                  <li>precision = 1，返回天</li>
 *                  <li>precision = 2，返回天和小时</li>
 *                  <li>precision = 3，返回天、小时和分钟</li>
 *                  <li>precision = 4，返回天、小时、分钟和秒</li>
 *                  <li>precision &gt;= 5，返回天、小时、分钟、秒和毫秒</li>
 *                  </ul>
 * @return 合适型与当前时间的差
 */
public static String getFitTimeSpanByNow(final String time, final int precision) {
    return getFitTimeSpan(getNowString(""), time, DEFAULT_FORMAT, precision);
}

/**
 * 获取合适型与当前时间的差
 * <p>time格式为format</p>
 *
 * @param time      时间字符串
 * @param format    时间格式
 * @param precision 精度
 *                  <ul>
 *                  <li>precision = 0，返回null</li>
 *                  <li>precision = 1，返回天</li>
 *                  <li>precision = 2，返回天和小时</li>
 *                  <li>precision = 3，返回天、小时和分钟</li>
 *                  <li>precision = 4，返回天、小时、分钟和秒</li>
 *                  <li>precision &gt;= 5，返回天、小时、分钟、秒和毫秒</li>
 *                  </ul>
 * @return 合适型与当前时间的差
 */
public static String getFitTimeSpanByNow(final String time, final DateFormat format, final int precision) {
    return getFitTimeSpan(getNowString(format), time, format, precision);
}

/**
 * 获取合适型与当前时间的差
 *
 * @param date      Date类型时间
 * @param precision 精度
 *                  <ul>
 *                  <li>precision = 0，返回null</li>
 *                  <li>precision = 1，返回天</li>
 *                  <li>precision = 2，返回天和小时</li>
 *                  <li>precision = 3，返回天、小时和分钟</li>
 *                  <li>precision = 4，返回天、小时、分钟和秒</li>
 *                  <li>precision &gt;= 5，返回天、小时、分钟、秒和毫秒</li>
 *                  </ul>
 * @return 合适型与当前时间的差
 */
public static String getFitTimeSpanByNow(final Date date, final int precision) {
    return getFitTimeSpan(getNowDate(), date, precision);
}

/**
 * 获取合适型与当前时间的差
 *
 * @param millis    毫秒时间戳
 * @param precision 精度
 *                  <ul>
 *                  <li>precision = 0，返回null</li>
 *                  <li>precision = 1，返回天</li>
 *                  <li>precision = 2，返回天和小时</li>
 *                  <li>precision = 3，返回天、小时和分钟</li>
 *                  <li>precision = 4，返回天、小时、分钟和秒</li>
 *                  <li>precision &gt;= 5，返回天、小时、分钟、秒和毫秒</li>
 *                  </ul>
 * @return 合适型与当前时间的差
 */
public static String getFitTimeSpanByNow(final long millis, final int precision) {
    return getFitTimeSpan(System.currentTimeMillis(), millis, precision);
}

/**
 * 获取友好型与当前时间的差
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return 友好型与当前时间的差
 * <ul>
 * <li>如果小于1秒钟内，显示刚刚</li>
 * <li>如果在1分钟内，显示XXX秒前</li>
 * <li>如果在1小时内，显示XXX分钟前</li>
 * <li>如果在1小时外的今天内，显示今天15:32</li>
 * <li>如果是昨天的，显示昨天15:32</li>
 * <li>其余显示，2016-10-15</li>
 * <li>时间不合法的情况全部日期和时间信息，如星期六 十月 27 14:21:20 CST 2007</li>
 * </ul>
 */
public static String getFriendlyTimeSpanByNow(final String time) {
    return getFriendlyTimeSpanByNow(time, DEFAULT_FORMAT);
}

/**
 * 获取友好型与当前时间的差
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return 友好型与当前时间的差
 * <ul>
 * <li>如果小于1秒钟内，显示刚刚</li>
 * <li>如果在1分钟内，显示XXX秒前</li>
 * <li>如果在1小时内，显示XXX分钟前</li>
 * <li>如果在1小时外的今天内，显示今天15:32</li>
 * <li>如果是昨天的，显示昨天15:32</li>
 * <li>其余显示，2016-10-15</li>
 * <li>时间不合法的情况全部日期和时间信息，如星期六 十月 27 14:21:20 CST 2007</li>
 * </ul>
 */
public static String getFriendlyTimeSpanByNow(final String time, final DateFormat format) {
    return getFriendlyTimeSpanByNow(string2Millis(time, format));
}

/**
 * 获取友好型与当前时间的差
 *
 * @param date Date类型时间
 * @return 友好型与当前时间的差
 * <ul>
 * <li>如果小于1秒钟内，显示刚刚</li>
 * <li>如果在1分钟内，显示XXX秒前</li>
 * <li>如果在1小时内，显示XXX分钟前</li>
 * <li>如果在1小时外的今天内，显示今天15:32</li>
 * <li>如果是昨天的，显示昨天15:32</li>
 * <li>其余显示，2016-10-15</li>
 * <li>时间不合法的情况全部日期和时间信息，如星期六 十月 27 14:21:20 CST 2007</li>
 * </ul>
 */
public static String getFriendlyTimeSpanByNow(final Date date) {
    return getFriendlyTimeSpanByNow(date.getTime());
}

/**
 * 获取友好型与当前时间的差
 *
 * @param millis 毫秒时间戳
 * @return 友好型与当前时间的差
 * <ul>
 * <li>如果小于1秒钟内，显示刚刚</li>
 * <li>如果在1分钟内，显示XXX秒前</li>
 * <li>如果在1小时内，显示XXX分钟前</li>
 * <li>如果在1小时外的今天内，显示今天15:32</li>
 * <li>如果是昨天的，显示昨天15:32</li>
 * <li>其余显示，2016-10-15</li>
 * <li>时间不合法的情况全部日期和时间信息，如星期六 十月 27 14:21:20 CST 2007</li>
 * </ul>
 */
public static String getFriendlyTimeSpanByNow(final long millis) {
    long now = System.currentTimeMillis();
    long span = now - millis;
    if (span < 0)
        return String.format("%tc", millis);// U can read http://www.apihome.cn/api/java/Formatter.html to understand it.
    if (span < 1000) {
        return "刚刚";
    } else if (span < TimeConstants.MIN) {
        return String.format(Locale.getDefault(), "%d秒前", span / TimeConstants.SEC);
    } else if (span < TimeConstants.HOUR) {
        return String.format(Locale.getDefault(), "%d分钟前", span / TimeConstants.MIN);
    }
    // 获取当天00:00
    long wee = getWeeOfToday();
    if (millis >= wee) {
        return String.format("今天%tR", millis);
    } else if (millis >= wee - TimeConstants.DAY) {
        return String.format("昨天%tR", millis);
    } else {
        return String.format("%tF", millis);
    }
}

private static long getWeeOfToday() {
    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.HOUR_OF_DAY, 0);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.MILLISECOND, 0);
    return cal.getTimeInMillis();
}

/**
 * 获取与给定时间等于时间差的时间戳
 *
 * @param millis   给定时间
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间戳
 */
public static long getMillis(final long millis, final long timeSpan, @TimeConstants.Unit final int unit) {
    return millis + timeSpan2Millis(timeSpan, unit);
}

/**
 * 获取与给定时间等于时间差的时间戳
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time     给定时间
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间戳
 */
public static long getMillis(final String time, final long timeSpan, @TimeConstants.Unit final int unit) {
    return getMillis(time, DEFAULT_FORMAT, timeSpan, unit);
}

/**
 * 获取与给定时间等于时间差的时间戳
 * <p>time格式为format</p>
 *
 * @param time     给定时间
 * @param format   时间格式
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间戳
 */
public static long getMillis(final String time, final DateFormat format, final long timeSpan, @TimeConstants.Unit final int unit) {
    return string2Millis(time, format) + timeSpan2Millis(timeSpan, unit);
}

/**
 * 获取与给定时间等于时间差的时间戳
 *
 * @param date     给定时间
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间戳
 */
public static long getMillis(final Date date, final long timeSpan, @TimeConstants.Unit final int unit) {
    return date2Millis(date) + timeSpan2Millis(timeSpan, unit);
}

/**
 * 获取与给定时间等于时间差的时间字符串
 * <p>格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param millis   给定时间
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间字符串
 */
public static String getString(final long millis, final long timeSpan, @TimeConstants.Unit final int unit) {
    return getString(millis, DEFAULT_FORMAT, timeSpan, unit);
}

/**
 * 获取与给定时间等于时间差的时间字符串
 * <p>格式为format</p>
 *
 * @param millis   给定时间
 * @param format   时间格式
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间字符串
 */
public static String getString(final long millis, final DateFormat format, final long timeSpan, @TimeConstants.Unit final int unit) {
    return millis2String(millis + timeSpan2Millis(timeSpan, unit), format);
}

/**
 * 获取与给定时间等于时间差的时间字符串
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time     给定时间
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间字符串
 */
public static String getString(final String time, final long timeSpan, @TimeConstants.Unit final int unit) {
    return getString(time, DEFAULT_FORMAT, timeSpan, unit);
}

/**
 * 获取与给定时间等于时间差的时间字符串
 * <p>格式为format</p>
 *
 * @param time     给定时间
 * @param format   时间格式
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间字符串
 */
public static String getString(final String time, final DateFormat format, final long timeSpan, @TimeConstants.Unit final int unit) {
    return millis2String(string2Millis(time, format) + timeSpan2Millis(timeSpan, unit), format);
}

/**
 * 获取与给定时间等于时间差的时间字符串
 * <p>格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param date     给定时间
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间字符串
 */
public static String getString(final Date date, final long timeSpan, @TimeConstants.Unit final int unit) {
    return getString(date, DEFAULT_FORMAT, timeSpan, unit);
}

/**
 * 获取与给定时间等于时间差的时间字符串
 * <p>格式为format</p>
 *
 * @param date     给定时间
 * @param format   时间格式
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的时间字符串
 */
public static String getString(final Date date, final DateFormat format, final long timeSpan, @TimeConstants.Unit final int unit) {
    return millis2String(date2Millis(date) + timeSpan2Millis(timeSpan, unit), format);
}

/**
 * 获取与给定时间等于时间差的Date
 *
 * @param millis   给定时间
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的Date
 */
public static Date getDate(final long millis, final long timeSpan, @TimeConstants.Unit final int unit) {
    return millis2Date(millis + timeSpan2Millis(timeSpan, unit));
}

/**
 * 获取与给定时间等于时间差的Date
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time     给定时间
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的Date
 */
public static Date getDate(final String time, final long timeSpan, @TimeConstants.Unit final int unit) {
    return getDate(time, DEFAULT_FORMAT, timeSpan, unit);
}

/**
 * 获取与给定时间等于时间差的Date
 * <p>格式为format</p>
 *
 * @param time     给定时间
 * @param format   时间格式
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的Date
 */
public static Date getDate(final String time, final DateFormat format, final long timeSpan, @TimeConstants.Unit final int unit) {
    return millis2Date(string2Millis(time, format) + timeSpan2Millis(timeSpan, unit));
}

/**
 * 获取与给定时间等于时间差的Date
 *
 * @param date     给定时间
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与给定时间等于时间差的Date
 */
public static Date getDate(final Date date, final long timeSpan, @TimeConstants.Unit final int unit) {
    return millis2Date(date2Millis(date) + timeSpan2Millis(timeSpan, unit));
}

/**
 * 获取与当前时间等于时间差的时间戳
 *
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与当前时间等于时间差的时间戳
 */
public static long getMillisByNow(final long timeSpan, @TimeConstants.Unit final int unit) {
    return getMillis(getNowMills(), timeSpan, unit);
}

/**
 * 获取与当前时间等于时间差的时间字符串
 * <p>格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与当前时间等于时间差的时间字符串
 */
public static String getStringByNow(final long timeSpan, @TimeConstants.Unit final int unit) {
    return getStringByNow(timeSpan, DEFAULT_FORMAT, unit);
}

/**
 * 获取与当前时间等于时间差的时间字符串
 * <p>格式为format</p>
 *
 * @param timeSpan 时间差的毫秒时间戳
 * @param format   时间格式
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与当前时间等于时间差的时间字符串
 */
public static String getStringByNow(final long timeSpan, final DateFormat format, @TimeConstants.Unit final int unit) {
    return getString(getNowMills(), format, timeSpan, unit);
}

/**
 * 获取与当前时间等于时间差的Date
 *
 * @param timeSpan 时间差的毫秒时间戳
 * @param unit     单位类型
 *                 <ul>
 *                 <li>{@link TimeConstants#MSEC}: 毫秒</li>
 *                 <li>{@link TimeConstants#SEC }: 秒</li>
 *                 <li>{@link TimeConstants#MIN }: 分</li>
 *                 <li>{@link TimeConstants#HOUR}: 小时</li>
 *                 <li>{@link TimeConstants#DAY }: 天</li>
 *                 </ul>
 * @return 与当前时间等于时间差的Date
 */
public static Date getDateByNow(final long timeSpan, @TimeConstants.Unit final int unit) {
    return getDate(getNowMills(), timeSpan, unit);
}

/**
 * 判断是否今天
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return {@code true}: 是<br>{@code false}: 否
 */
public static boolean isToday(final String time) {
    return isToday(string2Millis(time, DEFAULT_FORMAT));
}

/**
 * 判断是否今天
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return {@code true}: 是<br>{@code false}: 否
 */
public static boolean isToday(final String time, final DateFormat format) {
    return isToday(string2Millis(time, format));
}

/**
 * 判断是否今天
 *
 * @param date Date类型时间
 * @return {@code true}: 是<br>{@code false}: 否
 */
public static boolean isToday(final Date date) {
    return isToday(date.getTime());
}

/**
 * 判断是否今天
 *
 * @param millis 毫秒时间戳
 * @return {@code true}: 是<br>{@code false}: 否
 */
public static boolean isToday(final long millis) {
    long wee = getWeeOfToday();
    return millis >= wee && millis < wee + TimeConstants.DAY;
}

/**
 * 判断是否闰年
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return {@code true}: 闰年<br>{@code false}: 平年
 */
public static boolean isLeapYear(final String time) {
    return isLeapYear(string2Date(time, DEFAULT_FORMAT));
}

/**
 * 判断是否闰年
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return {@code true}: 闰年<br>{@code false}: 平年
 */
public static boolean isLeapYear(final String time, final DateFormat format) {
    return isLeapYear(string2Date(time, format));
}

/**
 * 判断是否闰年
 *
 * @param date Date类型时间
 * @return {@code true}: 闰年<br>{@code false}: 平年
 */
public static boolean isLeapYear(final Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    int year = cal.get(Calendar.YEAR);
    return isLeapYear(year);
}

/**
 * 判断是否闰年
 *
 * @param millis 毫秒时间戳
 * @return {@code true}: 闰年<br>{@code false}: 平年
 */
public static boolean isLeapYear(final long millis) {
    return isLeapYear(millis2Date(millis));
}

/**
 * 判断是否闰年
 *
 * @param year 年份
 * @return {@code true}: 闰年<br>{@code false}: 平年
 */
public static boolean isLeapYear(final int year) {
    return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}

/**
 * 获取中式星期
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return 中式星期
 */
public static String getChineseWeek(final String time) {
    return getChineseWeek(string2Date(time, DEFAULT_FORMAT));
}

/**
 * 获取当前中式时间
 *
 * @return
 */
public static String getChineseNowWeek() {
    return getChineseWeek(string2Date(getNowString(""), DEFAULT_FORMAT));
}

/**
 * 获取中式星期
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return 中式星期
 */
public static String getChineseWeek(final String time, final DateFormat format) {
    return getChineseWeek(string2Date(time, format));
}

/**
 * 获取中式星期
 *
 * @param date Date类型时间
 * @return 中式星期
 */
public static String getChineseWeek(final Date date) {
    return new SimpleDateFormat("E", Locale.CHINA).format(date);
}

/**
 * 获取中式星期
 *
 * @param millis 毫秒时间戳
 * @return 中式星期
 */
public static String getChineseWeek(final long millis) {
    return getChineseWeek(new Date(millis));
}

/**
 * 获取美式星期
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return 美式星期
 */
public static String getUSWeek(final String time) {
    return getUSWeek(string2Date(time, DEFAULT_FORMAT));
}

/**
 * 获取美式星期
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return 美式星期
 */
public static String getUSWeek(final String time, final DateFormat format) {
    return getUSWeek(string2Date(time, format));
}

/**
 * 获取美式星期
 *
 * @param date Date类型时间
 * @return 美式星期
 */
public static String getUSWeek(final Date date) {
    return new SimpleDateFormat("EEEE", Locale.US).format(date);
}

/**
 * 获取美式星期
 *
 * @param millis 毫秒时间戳
 * @return 美式星期
 */
public static String getUSWeek(final long millis) {
    return getUSWeek(new Date(millis));
}

/**
 * 获取星期索引
 * <p>注意：周日的Index才是1，周六为7</p>
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return 1...7
 * @see Calendar#SUNDAY
 * @see Calendar#MONDAY
 * @see Calendar#TUESDAY
 * @see Calendar#WEDNESDAY
 * @see Calendar#THURSDAY
 * @see Calendar#FRIDAY
 * @see Calendar#SATURDAY
 */
public static int getWeekIndex(final String time) {
    return getWeekIndex(string2Date(time, DEFAULT_FORMAT));
}

/**
 * 获取星期索引
 * <p>注意：周日的Index才是1，周六为7</p>
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return 1...7
 * @see Calendar#SUNDAY
 * @see Calendar#MONDAY
 * @see Calendar#TUESDAY
 * @see Calendar#WEDNESDAY
 * @see Calendar#THURSDAY
 * @see Calendar#FRIDAY
 * @see Calendar#SATURDAY
 */
public static int getWeekIndex(final String time, final DateFormat format) {
    return getWeekIndex(string2Date(time, format));
}

/**
 * 获取星期索引
 * <p>注意：周日的Index才是1，周六为7</p>
 *
 * @param date Date类型时间
 * @return 1...7
 * @see Calendar#SUNDAY
 * @see Calendar#MONDAY
 * @see Calendar#TUESDAY
 * @see Calendar#WEDNESDAY
 * @see Calendar#THURSDAY
 * @see Calendar#FRIDAY
 * @see Calendar#SATURDAY
 */
public static int getWeekIndex(final Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    return cal.get(Calendar.DAY_OF_WEEK);
}

/**
 * 获取星期索引
 * <p>注意：周日的Index才是1，周六为7</p>
 *
 * @param millis 毫秒时间戳
 * @return 1...7
 * @see Calendar#SUNDAY
 * @see Calendar#MONDAY
 * @see Calendar#TUESDAY
 * @see Calendar#WEDNESDAY
 * @see Calendar#THURSDAY
 * @see Calendar#FRIDAY
 * @see Calendar#SATURDAY
 */
public static int getWeekIndex(final long millis) {
    return getWeekIndex(millis2Date(millis));
}

/**
 * 获取月份中的第几周
 * <p>注意：国外周日才是新的一周的开始</p>
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return 1...5
 */
public static int getWeekOfMonth(final String time) {
    return getWeekOfMonth(string2Date(time, DEFAULT_FORMAT));
}

/**
 * 获取月份中的第几周
 * <p>注意：国外周日才是新的一周的开始</p>
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return 1...5
 */
public static int getWeekOfMonth(final String time, final DateFormat format) {
    return getWeekOfMonth(string2Date(time, format));
}

/**
 * 获取月份中的第几周
 * <p>注意：国外周日才是新的一周的开始</p>
 *
 * @param date Date类型时间
 * @return 1...5
 */
public static int getWeekOfMonth(final Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    return cal.get(Calendar.WEEK_OF_MONTH);
}

/**
 * 获取月份中的第几周
 * <p>注意：国外周日才是新的一周的开始</p>
 *
 * @param millis 毫秒时间戳
 * @return 1...5
 */
public static int getWeekOfMonth(final long millis) {
    return getWeekOfMonth(millis2Date(millis));
}

/**
 * 获取年份中的第几周
 * <p>注意：国外周日才是新的一周的开始</p>
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return 1...54
 */
public static int getWeekOfYear(final String time) {
    return getWeekOfYear(string2Date(time, DEFAULT_FORMAT));
}

/**
 * 获取年份中的第几周
 * <p>注意：国外周日才是新的一周的开始</p>
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return 1...54
 */
public static int getWeekOfYear(final String time, final DateFormat format) {
    return getWeekOfYear(string2Date(time, format));
}

/**
 * 获取年份中的第几周
 * <p>注意：国外周日才是新的一周的开始</p>
 *
 * @param date Date类型时间
 * @return 1...54
 */
public static int getWeekOfYear(final Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    return cal.get(Calendar.WEEK_OF_YEAR);
}

/**
 * 获取年份中的第几周
 * <p>注意：国外周日才是新的一周的开始</p>
 *
 * @param millis 毫秒时间戳
 * @return 1...54
 */
public static int getWeekOfYear(final long millis) {
    return getWeekOfYear(millis2Date(millis));
}

private static final String[] CHINESE_ZODIAC = {"猴", "鸡", "狗", "猪", "鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊"};

/**
 * 获取生肖
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return 生肖
 */
public static String getChineseZodiac(final String time) {
    return getChineseZodiac(string2Date(time, DEFAULT_FORMAT));
}

/**
 * 获取生肖
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return 生肖
 */
public static String getChineseZodiac(final String time, final DateFormat format) {
    return getChineseZodiac(string2Date(time, format));
}

/**
 * 获取生肖
 *
 * @param date Date类型时间
 * @return 生肖
 */
public static String getChineseZodiac(final Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    return CHINESE_ZODIAC[cal.get(Calendar.YEAR) % 12];
}

/**
 * 获取生肖
 *
 * @param millis 毫秒时间戳
 * @return 生肖
 */
public static String getChineseZodiac(final long millis) {
    return getChineseZodiac(millis2Date(millis));
}

/**
 * 获取生肖
 *
 * @param year 年
 * @return 生肖
 */
public static String getChineseZodiac(final int year) {
    return CHINESE_ZODIAC[year % 12];
}

private static final String[] ZODIAC = {"水瓶座", "双鱼座", "白羊座", "金牛座", "双子座", "巨蟹座", "狮子座", "处女座", "天秤座", "天蝎座", "射手座", "魔羯座"};
private static final int[] ZODIAC_FLAGS = {20, 19, 21, 21, 21, 22, 23, 23, 23, 24, 23, 22};

/**
 * 获取星座
 * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
 *
 * @param time 时间字符串
 * @return 生肖
 */
public static String getZodiac(final String time) {
    return getZodiac(string2Date(time, DEFAULT_FORMAT));
}

/**
 * 获取星座
 * <p>time格式为format</p>
 *
 * @param time   时间字符串
 * @param format 时间格式
 * @return 生肖
 */
public static String getZodiac(final String time, final DateFormat format) {
    return getZodiac(string2Date(time, format));
}

/**
 * 获取星座
 *
 * @param date Date类型时间
 * @return 星座
 */
public static String getZodiac(final Date date) {
    Calendar cal = Calendar.getInstance();
    cal.setTime(date);
    int month = cal.get(Calendar.MONTH) + 1;
    int day = cal.get(Calendar.DAY_OF_MONTH);
    return getZodiac(month, day);
}

/**
 * 获取星座
 *
 * @param millis 毫秒时间戳
 * @return 星座
 */
public static String getZodiac(final long millis) {
    return getZodiac(millis2Date(millis));
}

/**
 * 获取星座
 *
 * @param month 月
 * @param day   日
 * @return 星座
 */
public static String getZodiac(final int month, final int day) {
    return ZODIAC[day >= ZODIAC_FLAGS[month - 1]
            ? month - 1
            : (month + 10) % 12];
}

private static long timeSpan2Millis(final long timeSpan, @TimeConstants.Unit final int unit) {
    return timeSpan * unit;
}

private static long millis2TimeSpan(final long millis, @TimeConstants.Unit final int unit) {
    return millis / unit;
}

private static String millis2FitTimeSpan(long millis, int precision) {
    if (millis < 0 || precision <= 0) return null;
    precision = Math.min(precision, 5);
    String[] units = {"天", "小时", "分钟", "秒", "毫秒"};
    if (millis == 0) return 0 + units[precision - 1];
    StringBuilder sb = new StringBuilder();
    int[] unitLen = {86400000, 3600000, 60000, 1000, 1};
    for (int i = 0; i < precision; i++) {
        if (millis >= unitLen[i]) {
            long mode = millis / unitLen[i];
            millis -= mode * unitLen[i];
            sb.append(mode).append(units[i]);
        }
    }
    return sb.toString();
}


/**
 * 比较时间大小
 *
 * @param nowDate
 * @param compareDate
 * @return
 */
public static boolean compareDate(String nowDate, String compareDate) {
    DateFormat df = DEFAULT_FORMAT;
    try {
        Date now = df.parse(nowDate);
        Date compare = df.parse(compareDate);
        if (now.after(compare)) {
            return true;
        } else {
            return false;
        }
    } catch (ParseException e) {
        e.printStackTrace();
        return false;
    }
}

}

文章标签：
Java
UED
索引
API
john散漫
目录
相关文章
香吧香
|
5月前
|
Java 程序员
国际化常用时间格式并进行格式转换
国际化常用时间格式并进行格式转换
香吧香
165 0
朝阳39
|
5月前
uniapp【组件封装】时间戳格式化为星期
uniapp【组件封装】时间戳格式化为星期
朝阳39
89 0
尝尽人生百味，方知人间冷暖
格式化
4.3 格式化工作表 4.3.1 格式化数据 单元格及单元格区域的格式化主要包括六部分:数字、对齐、字体、边框、填充和保护。单元格或单元格区域的格式化操作必须先选择要进行格式化的单元格或单元格区域，然后通过“设置单元格格式”对话框，浮动工具栏，“开始”选项卡中“字体”组、“数字”组、“对齐方式”组、“样式”组中的相关命令或格式刷复制等几种方法来实现。 4.3.2 设置单元格的行高和列宽 1)通过拖动鼠标实现行、列 2)双击分隔线 3)通过对话框实现:"开始”选项卡，“单元格”组，单击“格式”按钮，选择“行高”或“列宽”命令 注意:可以通过选择性粘贴复制列宽，不能复制行高。 在word中双
尝尽人生百味，方知人间冷暖
126 0
翎野君
|
7月前
Excel中时间戳与标准日期格式的互相转换
Excel中时间戳与标准日期格式的互相转换
翎野君
203 0
Excel中时间戳与标准日期格式的互相转换
夏木~
|
Java
Hutool实现日期时间获取、转换、格式化
Hutool实现日期时间获取、转换、格式化
夏木~
2015 0
前端歌谣
|
前端开发
前端工作小结43-时间戳格式化
前端工作小结43-时间戳格式化
前端歌谣
83 0
奔跑的码仔
|
程序员 C语言
你真的懂C的格式化I/O吗？(上)
说起C语言I/O操作，学过C的人第一反应想到的肯定是printf/scanf之类的函数，那可是C语言的基础，程序调试的必备技能 :)。不错，作为一名C程序猿，printf确实是使用最为高频的函数了。但是如果我要问，如何格式化输入/输出我们想要的内容，大家可能就有点心虚了。为了修补上这个bug，今天我就和大家一起学习一下C的格式化I/O。
奔跑的码仔
186 0
奔跑的码仔
|
程序员 C语言
你真的懂C的格式化I/O吗？(下)
上一篇文章主要是总结了C语言下格式化输出相关的内容，这一节来总结一些格式化输入相关的内容。
奔跑的码仔
117 0
小蓝枣
|
Python
Python 技术篇-按任意格式灵活获取日期、时间、年月日、时分秒。日期格式化。
Python 技术篇-按任意格式灵活获取日期、时间、年月日、时分秒。日期格式化。
小蓝枣
805 0
john散漫
|
安全 Java API
格式化各种类型时间格式
格式化各种时间格式，功能齐全，使用方便
john散漫
309 0