java常见的时间工具类-DateUtils

package com.app.common.util;
import java.text.decimalformat;
import java.text.parseexception;
import java.text.simpledateformat;
import java.util.calendar;
import java.util.date;
import org.apache.commons.lang3.time.dateformatutils;

public class dateutils {
    
   /**
    * 仅显示年月日，例如 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";

   /**
    * 每天的毫秒数 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;

   /**
    * 常用的时间格式.
    */
   private static string[] parsepatterns = { "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" };

   /**
    * 得到当前日期字符串.
    * @return string 日期字符串，例如2015-08-11
    * @since 1.0
    */
   public static string getdate() {
      return getdate(dateutils.date_format);
   }

   /**
    * 得到当前时间字符串.
    * @return string 时间字符串，例如 09:51:53
    * @since 1.0
    */
   public static string gettime() {
      return formatdate(new date(), dateutils.time_format);
   }

   /**
    * 得到当前日期和时间字符串.
    * @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");
   }

   /**
    * 将日期型字符串转换为日期格式.
    * 支持的日期字符串格式包括"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 str
    * @return date
    * @since 1.0
    */
   public static date parsedate(object str) {
      if (str == null) {
         return null;
      }
      try {
         return org.apache.commons.lang3.time.dateutils.parsedate(str.tostring(), parsepatterns);
      } catch (parseexception e) {
         return null;
      }
   }

   /**
    * 获取当前日期与指定日期相隔的天数.
    * @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 ;
    }
}