时间工具类

 /**
     * 仅显示年月日，例如 2015-08-11.
     */
    public static final String DATE_FORMAT = "yyyy-MM-dd";
    /**
     * 显示年月日时分秒，例如 2015-08-11 09:51:53.
     */
    public static final String DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
 
    /**
     * 仅显示时分秒，例如 09:51:53.
     */
    public static final String TIME_FORMAT = "HH:mm:ss";
 
 
    public static String YYYY = "yyyy";
 
    public static String YYYY_MM = "yyyy-MM";
 
    public static String YYYY_MM_DD = "yyyy-MM-dd";
 
    public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
 
    public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
 
    private static String[] parsePatterns = {
            "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
            "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
            "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};
 
    /**
     * 每天的毫秒数 8640000.
     */
    public static final long MILLISECONDS_PER_DAY = 86400000L;
 
    /**
     * 每周的天数.
     */
    public static final long DAYS_PER_WEEK = 7L;
 
    /**
     * 每小时毫秒数.
     */
    public static final long MILLISECONDS_PER_HOUR = 3600000L;
 
    /**
     * 每分钟秒数.
     */
    public static final long SECONDS_PER_MINUTE = 60L;
 
    /**
     * 每小时秒数.
     */
    public static final long SECONDS_PER_HOUR = 3600L;
 
    /**
     * 每天秒数.
     */
    public static final long SECONDS_PER_DAY = 86400L;
 
    /**
     * 每个月秒数，默认每月30天.
     */
    public static final long SECONDS_PER_MONTH = 2592000L;
 
    /**
     * 每年秒数，默认每年365天.
     */
    public static final long SECONDS_PER_YEAR = 31536000L;
 
    /**
     * 获取当前Date型日期
     *
     * @return Date() 当前日期
     */
    public static Date getNowDate()
    {
        return new Date();
    }
 
    /**
     * 获取当前日期, 默认格式为yyyy-MM-dd
     *
     * @return String
     */
    public static String getDate()
    {
        return dateTimeNow(YYYY_MM_DD);
    }
 
    public static final String getTime()
    {
        return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
    }
    public static final String getTimeOrder()
    {
        return parseDateToStr("YYYYMMDDHHMMSS", new Date());
    }
 
    /**
     * 返回字符串类型的现在时间
     * @return
     */
    public static final String getStringDate()
    {
        return parseDateToStr("yyyy-MM-dd HH:mm:ss", new Date());
    }
    public static final String getDateToString(Date date)
    {
        return parseDateToStr("yyyy-MM-dd HH:mm:ss", date);
    }
 
    public static final String dateTimeNow()
    {
        return dateTimeNow(YYYYMMDDHHMMSS);
    }
 
 
    public static final String sjdateTimeNow()
    {
        String s = dateTimeNow(YYYYMMDDHHMMSS);
        java.util.Random random=new java.util.Random();
        // 返回0 to x的一个随机数但不会取到x，即返回[0,x)闭开区间的值。
        int rn=random.nextInt(100);
        String s1 = String.valueOf(rn);
        return s+s1;
    }
 
    public static final String getDDHH()
    {
        return parseDateToStr("DDHH", new Date());
    }
 
    public static final String dateTimeNow(final String format)
    {
        return parseDateToStr(format, new Date());
    }
 
    public static final String dateTime(final Date date)
    {
        return parseDateToStr(YYYY_MM_DD, date);
    }
 
    public static final String parseDateToStr(final String format, final Date date)
    {
        return new SimpleDateFormat(format).format(date);
    }
 
    public static final Date dateTime(final String format, final String ts)
    {
        try
        {
            return new SimpleDateFormat(format).parse(ts);
        }
        catch (ParseException e)
        {
            throw new RuntimeException(e);
        }
    }
 
    /**
     * 日期路径 即年/月/日 如2018/08/08
     */
    public static final String datePath()
    {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyy/MM/dd");
    }
 
    /**
     * 日期路径 即年/月/日 如20180808
     */
    public static final String dateTime()
    {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyyMMdd");
    }
 
    /**
     * 日期路径 即时:分:秒 如10:10:10
     */
    public static final String dateHHmmss()
    {
        Date now = new Date();
        return DateFormatUtils.format(now, "HH:mm:ss");
    }
 
    /**
     * 日期型字符串转化为日期 格式
     */
    public static Date parseDate(Object str)
    {
        if (str == null)
        {
            return null;
        }
        try
        {
            return parseDate(str.toString(), parsePatterns);
        }
        catch (ParseException e)
        {
            return null;
        }
    }
 
 
    /**
     * 日期型字符串转化为日期 格式
     */
    public static String parseString(Date str)
    {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = formatter.format(str);
        return format;
 
    }
 
    public static String getYYYYMMDD(Date str)
    {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        String format = formatter.format(str);
        return format;
 
    }
 
    /**
     * 获取服务器启动时间
     */
    public static Date getServerStartDate()
    {
        long time = ManagementFactory.getRuntimeMXBean().getStartTime();
        return new Date(time);
    }
 
    /**
     * 计算两个时间差
     */
    public static String getDatePoor(Date endDate, Date nowDate)
    {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时" + min + "分钟";
    }
    /**
     * 计算两个时间差小时
     */
    public static double getdatehour(String startDate, String endDate) throws ParseException {
        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm");
        Date fromDate2 = simpleFormat.parse(startDate);
        Date toDate2 = simpleFormat.parse(endDate);
        long from2 = fromDate2.getTime();
        long to2 = toDate2.getTime();
        int hours = (int) ((to2 - from2) / (1000 * 60 * 60));
        return hours;
    }
    /**
     * 计算两个时间差分钟
     */
    public static int getdateminutes( String startDate,String endDate) throws ParseException {
        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm");
        Date fromDate3 = simpleFormat.parse(startDate);
        Date toDate3 = simpleFormat.parse(endDate);
        long from3 = fromDate3.getTime();
        long to3 = toDate3.getTime();
        int minutes = (int) ((to3 - from3) / (1000 * 60));
        return minutes;
    }
    /**
     * 计算两个时间差天数
     */
    public static int getdateday( String startDate,String endDate) throws ParseException {
        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        /*天数差*/
        Date fromDate1 = simpleFormat.parse(startDate);
        Date toDate1 = simpleFormat.parse(endDate);
        long from1 = fromDate1.getTime();
        long to1 = toDate1.getTime();
        int days = (int) ((to1 - from1) / (1000 * 60 * 60 * 24));
        return days;
    }
 
 
 
    /**
     * 时间戳
     * @return
     */
    public static String getTimestamp(){
        Date date = new Date();
        String timestamp = String.valueOf(date.getTime()); ;
        return timestamp;
    }
 
    public static int getCurrentMonthLastDay()
    {
        Calendar a = Calendar.getInstance();
        a.set(Calendar.DATE, 1);//把日期设置为当月第一天
        a.roll(Calendar.DATE, -1);//日期回滚一天，也就是最后一天
        int maxDate = a.get(Calendar.DATE);
        return maxDate;
    }
 
    /**
     * 当天时间的前一天
     * @return
     */
    public static String getStringDateADD(String dates,Integer num)
    {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = new Date();
 
        String stringDate = sdf.format(date);
 
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
 
        if ("YEAR".equals(dates)) {
            //把日期往后增加一年，负数减一年
            calendar.add(Calendar.YEAR, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("MONTH".equals(dates)) {
            //把日期往后增加一个月，负数减一个月
            calendar.add(Calendar.MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("MONTH".equals(dates)) {
            //把日期往后增加一周，负数减一周
            calendar.add(Calendar.WEEK_OF_MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("DAY".equals(dates)) {
            //把日期往后增加一天，负数减一天
            calendar.add(Calendar.DAY_OF_MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }
        return stringDate;
    }
 
    /**
     * 当天时间的前一天
     * @return
     */
    public static String getStringDateymdhfADD(String dates,Integer num)
    {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = new Date();
 
        String stringDate = sdf.format(date);
 
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
 
        if ("YEAR".equals(dates)) {
            //把日期往后增加一年，负数减一年
            calendar.add(Calendar.YEAR, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("MONTH".equals(dates)) {
            //把日期往后增加一个月，负数减一个月
            calendar.add(Calendar.MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("MONTH".equals(dates)) {
            //把日期往后增加一周，负数减一周
            calendar.add(Calendar.WEEK_OF_MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("DAY".equals(dates)) {
            //把日期往后增加一天，负数减一天
            calendar.add(Calendar.DAY_OF_MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }
        return stringDate;
    }
 
 
    /**
     * 当天时间的前一天
     * @return
     */
    public static Date getDateADD(String dates,Integer num)
    {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = new Date();
 
        String stringDate = sdf.format(date);
 
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
 
        if ("YEAR".equals(dates)) {
            //把日期往后增加一年，负数减一年
            calendar.add(Calendar.YEAR, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("MONTH".equals(dates)) {
            //把日期往后增加一个月，负数减一个月
            calendar.add(Calendar.MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("MONTH".equals(dates)) {
            //把日期往后增加一周，负数减一周
            calendar.add(Calendar.WEEK_OF_MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("DAY".equals(dates)) {
            //把日期往后增加一天，负数减一天
            calendar.add(Calendar.DAY_OF_MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }
        Date date1 = parseDate(stringDate);
        return date1;
    }
 
 
 
    /**
     * 当天时间的前一天
     * @return
     */
    public static Date getDateADaaaD(String dates,Integer num,Date date)
    {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 
        String stringDate = sdf.format(date);
 
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
 
        if ("YEAR".equals(dates)) {
            //把日期往后增加一年，负数减一年
            calendar.add(Calendar.YEAR, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("MONTH".equals(dates)) {
            //把日期往后增加一个月，负数减一个月
            calendar.add(Calendar.MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("MONTH".equals(dates)) {
            //把日期往后增加一周，负数减一周
            calendar.add(Calendar.WEEK_OF_MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }else if ("DAY".equals(dates)) {
            //把日期往后增加一天，负数减一天
            calendar.add(Calendar.DAY_OF_MONTH, num);
            date = calendar.getTime();
            stringDate = sdf.format(date);
        }
        Date date1 = parseDate(stringDate);
        return date1;
    }
 
 
    /**
     * 时间时分秒比大小
     * @param t1
     * @param t2
     * @return
     */
    public static int timeCompare(String t1,String t2){
        SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
        Calendar c1=Calendar.getInstance();
        Calendar c2=Calendar.getInstance();
        try {
            c1.setTime(formatter.parse(t1));
            c2.setTime(formatter.parse(t2));
 
        } catch (ParseException e) {
            e.printStackTrace();
        }
        int result=c1.compareTo(c2);
        return result;
    }
 /**
     * 时间时分秒比大小
     * @param t1
     * @param t2
     * @return
     */
    public static int timeCompare(Date t1,Date t2){
        SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
 
            String format1 = formatter.format(t1);
            String format = formatter.format(t2);
        int result=format1.compareTo(format);
        return result;
    }
 
    /**
     * 随机返回时间
     * @return
     */
    public static String getDatetime(){
        String datetime = null;
        Random rd = new Random();
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        long ts = new Date().getTime()+6000*rd.nextInt(60)+600000*rd.nextInt(35);
        return datetime = df.format(ts);
    }
 
    /**
     * 随机返回下面的字符串
     * @return
     */
    public static String getCarBrand(){
        String brand="";
        Random rd = new Random();
        String[] strs = {"大众","别克","丰田","吉利","宝马","丰田","丰田","标志"};
        int num = rd.nextInt(strs.length);
        brand = strs[num];
        return brand;
    }
 
 
    /**
     * 得到当前日期和时间字符串.
     * @return String 日期和时间字符串，例如 2015-08-11 09:51:53
     * @since 1.0
     */
    public static String getDateTime() {
        return formatDate(new Date(), DateUtils.DATETIME_FORMAT);
    }
 
    /**
     * 获取当前时间指定格式下的字符串.
     * @param pattern
     *            转化后时间展示的格式，例如"yyyy-MM-dd"，"yyyy-MM-dd HH:mm:ss"等
     * @return String 格式转换之后的时间字符串.
     * @since 1.0
     */
    public static String getDate(String pattern) {
        return DateFormatUtils.format(new Date(), pattern);
    }
 
    /**
     * 获取指定日期的字符串格式.
     * @param date  需要格式化的时间，不能为空
     * @param pattern 时间格式，例如"yyyy-MM-dd"，"yyyy-MM-dd HH:mm:ss"等
     * @return String 格式转换之后的时间字符串.
     * @since 1.0
     */
    public static String getDate(Date date, String pattern) {
        return DateFormatUtils.format(date, pattern);
    }
 
    /**
     * 获取日期时间字符串，默认格式为（yyyy-MM-dd）.
     * @param date 需要转化的日期时间
     * @param pattern 时间格式，例如"yyyy-MM-dd" "HH:mm:ss" "E"等
     * @return String 格式转换后的时间字符串
     * @since 1.0
     */
    public static String formatDate(Date date, Object... pattern) {
        String formatDate = null;
        if (pattern != null && pattern.length > 0) {
            formatDate = DateFormatUtils.format(date, pattern[0].toString());
        } else {
            formatDate = DateFormatUtils.format(date, DateUtils.DATE_FORMAT);
        }
        return formatDate;
    }
 
    /**
     * 获取当前年份字符串.
     * @return String 当前年份字符串，例如 2015
     * @since 1.0
     */
    public static String getYear() {
        return formatDate(new Date(), "yyyy");
    }
 
    /**
     * 获取当前月份字符串.
     * @return String 当前月份字符串，例如 08
     * @since 1.0
     */
    public static String getMonth() {
        return formatDate(new Date(), "MM");
    }
 
    /**
     * 获取当前天数字符串.
     * @return String 当前天数字符串，例如 11
     * @since 1.0
     */
    public static String getDay() {
        return formatDate(new Date(), "dd");
    }
 
    /**
     * 获取当前星期字符串.
     * @return String 当前星期字符串，例如星期二
     * @since 1.0
     */
    public static String getWeek() {
        return formatDate(new Date(), "E");
    }
 
 
    /**
     * 获取当前日期与指定日期相隔的天数.
     * @param date 给定的日期
     * @return long 日期间隔天数，正数表示给定日期在当前日期之前，负数表示在当前日期之后
     * @since 1.0
     */
    public static long pastDays(Date date) {
        // 将指定日期转换为yyyy-MM-dd格式
        date = DateUtils.parseDate(DateUtils.formatDate(date, DateUtils.DATE_FORMAT));
        // 当前日期转换为yyyy-MM-dd格式
        Date currentDate = DateUtils.parseDate(DateUtils.formatDate(new Date(), DateUtils.DATE_FORMAT));
        long t=0;
        if(date!=null&&currentDate!=null){
            t = (currentDate.getTime() - date.getTime()) / DateUtils.MILLISECONDS_PER_DAY;
        }
        return t;
    }
 
    /**
     * 获取当前日期指定天数之后的日期.
     * @param num   相隔天数
     * @return Date 日期
     * @since 1.0
     */
    public static Date nextDay(int num) {
        Calendar curr = Calendar.getInstance();
        curr.set(Calendar.DAY_OF_MONTH, curr.get(Calendar.DAY_OF_MONTH) + num);
        return curr.getTime();
    }
 
    /**
     * 获取当前日期指定月数之后的日期.
     * @param num   间隔月数
     * @return Date 日期
     * @since 1.0
     */
    public static Date nextMonth(int num) {
        Calendar curr = Calendar.getInstance();
        curr.set(Calendar.MONTH, curr.get(Calendar.MONTH) + num);
        return curr.getTime();
    }
 
    /**
     * 获取当前日期指定年数之后的日期.
     * @param num    间隔年数
     * @return Date 日期
     * @since 1.0
     */
    public static Date nextYear(int num) {
        Calendar curr = Calendar.getInstance();
        curr.set(Calendar.YEAR, curr.get(Calendar.YEAR) + num);
        return curr.getTime();
    }
 
    /**
     * 将 Date 日期转化为 Calendar 类型日期.
     * @param date   给定的时间，若为null，则默认为当前时间
     * @return Calendar Calendar对象
     * @since 1.0
     */
    public static Calendar getCalendar(Date date) {
        Calendar calendar = Calendar.getInstance();
        // calendar.setFirstDayOfWeek(Calendar.SUNDAY);//每周从周日开始
        // calendar.setMinimalDaysInFirstWeek(1); // 设置每周最少为1天
        if (date != null) {
            calendar.setTime(date);
        }
        return calendar;
    }
 
    /**
     * 计算两个日期之间相差天数.
     * @param start     计算开始日期
     * @param end       计算结束日期
     * @return long 相隔天数
     * @since 1.0
     */
    public static long getDaysBetween(Date start, Date end) {
        // 将指定日期转换为yyyy-MM-dd格式
        start = DateUtils.parseDate(DateUtils.formatDate(start, DateUtils.DATE_FORMAT));
        // 当前日期转换为yyyy-MM-dd格式
        end = DateUtils.parseDate(DateUtils.formatDate(end, DateUtils.DATE_FORMAT));
 
        long diff=0;
        if(start!=null&&end!=null) {
            diff = (end.getTime() - start.getTime()) / DateUtils.MILLISECONDS_PER_DAY;
        }
        return diff;
    }
 
    /**
     * 计算两个日期之前相隔多少周.
     * @param start      计算开始时间
     * @param end    计算结束时间
     * @return long 相隔周数，向下取整
     * @since 1.0
     */
    public static long getWeeksBetween(Date start, Date end) {
        return getDaysBetween(start, end) / DateUtils.DAYS_PER_WEEK;
    }
 
    /**
     * 获取与指定日期间隔给定天数的日期.
     * @param specifiedDay    给定的字符串格式日期，支持的日期字符串格式包括"yyyy-MM-dd","yyyy-MM-dd HH:mm:ss",
     *            "yyyy-MM-dd HH:mm", "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss",
     *            "yyyy/MM/dd HH:mm"
     * @param num   间隔天数
     * @return String 间隔指定天数之后的日期
     * @since 1.0
     */
    public static String getSpecifiedDayAfter(String specifiedDay, int num) {
        Date specifiedDate = parseDate(specifiedDay);
        Calendar c = Calendar.getInstance();
        c.setTime(specifiedDate);
        int day = c.get(Calendar.DATE);
        c.set(Calendar.DATE, day + num);
        String dayAfter = formatDate(c.getTime(), DateUtils.DATE_FORMAT);
        return dayAfter;
    }
 
    /**
     * 计算两个日期之前间隔的小时数.
     *
     * @param date1
     *            结束时间
     * @param date2
     *            开始时间
     * @return String 相差的小时数，保留一位小数
     * @since 1.0
     */
    public static String dateMinus(Date date1, Date date2) {
        if (date1 == null || date2 == null) {
            return "0";
        }
        Long r = date1.getTime() - date2.getTime();
        DecimalFormat df = new DecimalFormat("#.0");
        double result = r * 1.0 / DateUtils.MILLISECONDS_PER_HOUR;
        return df.format(result);
    }
 
    /**
     * 获取当前季度 .
     *
     * @return Integer 当前季度数
     * @since 1.0
     */
    public static Integer getCurrentSeason() {
        Calendar calendar = Calendar.getInstance();
        Integer month = calendar.get(Calendar.MONTH) + 1;
        int season = 0;
        if (month >= 1 && month <= 3) {
            season = 1;
        } else if (month >= 4 && month <= 6) {
            season = 2;
        } else if (month >= 7 && month <= 9) {
            season = 3;
        } else if (month >= 10 && month <= 12) {
            season = 4;
        }
        return season;
    }
 
    /**
     * 将以秒为单位的时间转换为其他单位.
     *
     * @param seconds
     *            秒数
     * @return String 例如 16分钟前、2小时前、3天前、4月前、5年前等
     * @since 1.0
     */
    public static String getIntervalBySeconds(long seconds) {
        StringBuffer buffer = new StringBuffer();
        if (seconds < SECONDS_PER_MINUTE) {
            buffer.append(seconds).append("秒前");
        } else if (seconds < SECONDS_PER_HOUR) {
            buffer.append(seconds / SECONDS_PER_MINUTE).append("分钟前");
        } else if (seconds < SECONDS_PER_DAY) {
            buffer.append(seconds / SECONDS_PER_HOUR).append("小时前");
        } else if (seconds < SECONDS_PER_MONTH) {
            buffer.append(seconds / SECONDS_PER_DAY).append("天前");
        } else if (seconds < SECONDS_PER_YEAR) {
            buffer.append(seconds / SECONDS_PER_MONTH).append("月前");
        } else {
            buffer.append(seconds / DateUtils.SECONDS_PER_YEAR).append("年前");
        }
        return buffer.toString();
    }
 
    /**
     *
     * getNowTimeBefore(记录时间相当于目前多久之前)
     *
     * @param seconds
     *            秒
     * @return
     * @exception @since
     *                1.0
     * @author rlliu
     */
    public static String getNowTimeBefore(long seconds) {
        StringBuffer buffer = new StringBuffer();
        buffer.append("上传于");
        if (seconds < 3600) {
            buffer.append((long) Math.floor(seconds / 60.0)).append("分钟前");
        } else if (seconds < 86400) {
            buffer.append((long) Math.floor(seconds / 3600.0)).append("小时前");
        } else if (seconds < 604800) {
            buffer.append((long) Math.floor(seconds / 86400.0)).append("天前");
        } else if (seconds < 2592000) {
            buffer.append((long) Math.floor(seconds / 604800.0)).append("周前");
        } else if (seconds < 31104000) {
            buffer.append((long) Math.floor(seconds / 2592000.0)).append("月前");
        } else {
            buffer.append((long) Math.floor(seconds / 31104000.0)).append("年前");
        }
        return buffer.toString();
    }
 
    /**
     *
     * getMonthsBetween(查询两个日期相隔的月份)
     *
     * @param startDate 开始日期1 (格式yyyy-MM-dd)
     * @param endDate   截止日期2 (格式yyyy-MM-dd)
     * @return
     */
    public static int getMonthsBetween(String startDate, String endDate) {
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        c1.setTime(DateUtils.parseDate(startDate));
        c2.setTime(DateUtils.parseDate(endDate));
        int year = c2.get(Calendar.YEAR) - c1.get(Calendar.YEAR);
        int month = c2.get(Calendar.MONTH) - c1.get(Calendar.MONTH);
        return Math.abs(year * 12 + month);
    }
 
    /**
     *
     * getDayOfWeek(获取当前日期是星期几)
     *
     * @param dateStr 日期
     * @return 星期几
     */
    public static String getDayOfWeek(String dateStr) {
        String[] weekOfDays = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
        Date date = parseDate(dateStr);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int num = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        return weekOfDays[num];
    }
 
    /**
     * sns 格式 如几秒前，几分钟前，几小时前，几天前，几个月前，几年后， ... 精细，类如某个明星几秒钟之前发表了一篇微博
     *
     * @param createTime
     * @return
     */
    public static String snsFormat(long createTime) {
        long now = System.currentTimeMillis() / 1000;
        long differ = now - createTime / 1000;
        String dateStr = "";
        if (differ <= 60) {
            dateStr = "刚刚";
        } else if (differ <= 3600) {
            dateStr = (differ / 60) + "分钟前";
        } else if (differ <= 3600 * 24) {
            dateStr = (differ / 3600) + "小时前";
        } else if (differ <= 3600 * 24 * 30) {
            dateStr = (differ / (3600 * 24)) + "天前";
        } else {
            Date date = new Date(createTime);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            dateStr = sdf.format(date);
        }
        return dateStr;
    }
 
    /**
     * 得到UTC时间，类型为字符串，格式为"yyyy-MM-dd HH:mm"
     * 如果获取失败，返回null
     * @return
     */
    public static String getUTCTimeStr() {
        StringBuffer UTCTimeBuffer = new StringBuffer();
        // 1、取得本地时间：
        Calendar cal = Calendar.getInstance() ;
        // 2、取得时间偏移量：
        int zoneOffset = cal.get(java.util.Calendar.ZONE_OFFSET);
        // 3、取得夏令时差：
        int dstOffset = cal.get(java.util.Calendar.DST_OFFSET);
        // 4、从本地时间里扣除这些差量，即可以取得UTC时间：
        cal.add(java.util.Calendar.MILLISECOND, -(zoneOffset + dstOffset));
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH)+1;
        int day = cal.get(Calendar.DAY_OF_MONTH);
        int hour = cal.get(Calendar.HOUR_OF_DAY);
        int minute = cal.get(Calendar.MINUTE);
        UTCTimeBuffer.append(year).append("-").append(month).append("-").append(day) ;
        UTCTimeBuffer.append(" ").append(hour).append(":").append(minute) ;
        try{
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            sdf.parse(UTCTimeBuffer.toString()) ;
            return UTCTimeBuffer.toString() ;
        }catch(ParseException e)
        {
            e.printStackTrace() ;
        }
        return null ;
    }
 
 
    /**
     * 生成随机时间
     *
     * @param beginDate
     * @param endDate
     * @return
     */
    public static Date randomDate(String beginDate, String endDate) {
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date start = format.parse(beginDate);// 构造开始日期
            Date end = format.parse(endDate);// 构造结束日期
            // getTime()表示返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
            if (start.getTime() >= end.getTime()) {
                return null;
            }
            long date = random(start.getTime(), end.getTime());
            return new Date(date);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    public static long random(long begin, long end) {
        long rtn = begin + (long) (Math.random() * (end - begin));
        // 如果返回的是开始时间和结束时间，则递归调用本函数查找随机值
        if (rtn == begin || rtn == end) {
            return random(begin, end);
        }
        return rtn;
    }
    /**
     * 取当前时间的年月
     * @return
     */
    public static String getYYMM(){
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(YYYY_MM);
        String format = simpleDateFormat.format(date);
        return format;
    }
 
    /**
     * 取传入时间的年月
     * @param date
     * @return
     */
    public static String getYYMM(Date date){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(YYYY_MM);
        String format = simpleDateFormat.format(date);
        return format;
    }
    /**
     * 取传入时间的年月日
     * @param date
     * @return
     */
    public static Date StringToDate(String date) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(YYYY_MM_DD);
        Date format = simpleDateFormat.parse(date);
        return format;
    }
 
    /**
     * 取传入时间的时分秒
     * @param date
     * @return
     */
    public static String getHHMMSS(Date date){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(TIME_FORMAT);
        String format = simpleDateFormat.format(date);
        return format;
    }
 
    /**
     * 取插入date类型的时间的上个月
     * @param date
     * @return
     */
    public static String getLastMonth(Date date) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date); // 设置为当前时间
        calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1); // 设置为上一个月
        date = calendar.getTime();
        String accDate = format.format(date);
        return accDate;
    }
 
    /**
     * 取date类型的两个时间的相差小时数
     * @param startDate
     * @param endDate
     * @return
     * @throws ParseException
     */
    public static double getdatehour1(Date startDate, Date endDate) throws ParseException {
        long from2 = startDate.getTime();
        long to2 = endDate.getTime();
        int hours = (int) ((to2 - from2) / (1000 * 60 * 60));
        return hours;
    }
 
    /**
     * 取date类型的两个时间的相差分钟数
     * @param startDate
     * @param endDate
     * @return
     * @throws ParseException
     */
    public static int getdateminutess( Date startDate,Date endDate) throws ParseException {
        long from3 = startDate.getTime();
        long to3 = endDate.getTime();
        int minutes = (int) ((to3 - from3) / (1000 * 60));
        return minutes;
    }
    /**
     * 取String类型的两个时间的相差分钟数
     * @param startDate
     * @param endDate
     * @return
     * @throws ParseException
     */
    public static int getdateminutea( String startDate,String endDate) throws ParseException {
        SimpleDateFormat simpleFormat = new SimpleDateFormat("hh:mm:ss");
        Date fromDate3 = simpleFormat.parse(startDate);
        Date toDate3 = simpleFormat.parse(endDate);
        long from3 = fromDate3.getTime();
        long to3 = toDate3.getTime();
        int minutes = (int) ((to3 - from3) / (1000 * 60));
        return minutes;
    }
 
    /**
     * 获取当前月份字符串.
     * @return String 当前月份字符串，例如 08
     * @since 1.0
     */
    public static String getMonthMY(Date date) {
        return formatDate(date, "HH");
    }
/**
 *合同更换计算剩余时间
 * @param StarTime
 * @param EndTime
 * @return
 */
public static int between(Date StarTime,Date EndTime){
    //相差几个月
    Calendar instance = Calendar.getInstance();
    Calendar instance2 = Calendar.getInstance();
    instance.setTime(EndTime);
    //当前年
    int YEAR = instance.get(Calendar.YEAR);
    //当前月
    int MONTH = instance.get(Calendar.MONTH) + 1;
    //当前日
    int DATE = instance.get(Calendar.DAY_OF_MONTH);
    instance2.setTime(StarTime);
    //合同开始年
    int StarYear = instance2.get(Calendar.YEAR);
    //合同开始月
    int StarMONTH= instance2.get(Calendar.MONTH) + 1;
    //合同开始日
    int StarDAY = instance2.get(Calendar.DAY_OF_MONTH);
    String between = DateUtils.DateDifference(StarYear, StarMONTH, StarDAY, YEAR, MONTH, DATE);
    String[] split = between.split(",");
    String s1 = split[0];
    String s2 = split[1];
    String s3 = split[2];
    int betweenYear = Integer.parseInt(s1);
    int betweenMONTH = Integer.parseInt(s2);
    int betweenDATE = Integer.parseInt(s3);
 
    int newMONTH=betweenMONTH;
    int a=0;
    if(betweenYear>0){
        a=betweenYear*12;
        newMONTH=newMONTH+a;
    }if(betweenDATE>0){
        newMONTH= newMONTH+1;
    }
    System.out.println(newMONTH+"===================================");
    return newMONTH;
}
public static String DateDifference(int StarYear, int StarMonth, int StarDayOfMonth,int endYear,int endMonth, int endDayOfMonth) {
    LocalDate oldDate = LocalDate.of(endYear,endMonth,endDayOfMonth);
    System.out.println("oldDate：" + oldDate);
    LocalDate today = LocalDate.of(StarYear, StarMonth, StarDayOfMonth);
    System.out.println("today：" + today);
 
    Period p = Period.between(today,oldDate);
    int months = p.getMonths();
    int days = p.getDays();
    String newYears=null;
    String newMonths=null;
    String newDays=null;
    if(months<10){
        newMonths="0"+months;
    }else {
        newMonths= String.valueOf(months);
    }
    if(days<10){
        newDays ="0"+days;
    }else {
        newDays= String.valueOf(months);
    }