几个日期时间工具类

港控/mmm° 2023-10-05 15:58 125阅读 0赞

参考:

https://www.jianshu.com/p/b79f52c1aab2

https://www.jianshu.com/p/ffd5f3541f21

  1. package com.wanggs.utils;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Calendar;
  5. import java.util.Date;
  7. public class DateUtil {
  9.     /**
  10.      * 获取两个时间之间的天数
  11.      * @param maxDate 大的日期
  12.      * @param minDate 小的日期
  13.      * @return
  14.      * @throws Exception
  15.      */
  16.     public static int getDay(Date maxDate,Date minDate) throws Exception {
  17.         int day = 0;
  18.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");  
  19.         minDate=sdf.parse(sdf.format(minDate));  
  20.         maxDate=sdf.parse(sdf.format(maxDate));  
  21.         Calendar cal = Calendar.getInstance();    
  22.         cal.setTime(minDate);    
  23.         long time1 = cal.getTimeInMillis();                 
  24.         cal.setTime(maxDate);    
  25.         long time2 = cal.getTimeInMillis();         
  26.         long between_days=(time2-time1)/(1000*3600*24); 
  27.         if (between_days>0) {
  28.             day = Integer.parseInt(String.valueOf(between_days));
  29.         }
  30.         return day;
  31.     }
  33.     /**
  34.      * 由出生日期获得年龄
  35.      * 
  36.      * @param birthDay
  37.      * @return
  38.      * @throws Exception
  39.      */
  40.     public static int getAge(Date birthDay) throws Exception {
  41.         Calendar cal = Calendar.getInstance();
  42.         if (cal.before(birthDay)) {
  43.             throw new IllegalArgumentException("The birthDay is before Now.It's unbelievable!");
  44.         }
  45.         //获取当前年
  46.         int yearNow = cal.get(Calendar.YEAR);
  47.         //获取当前月
  48.         int monthNow = cal.get(Calendar.MONTH);
  49.         //获取当日
  50.         int dayOfMonthNow = cal.get(Calendar.DAY_OF_MONTH);
  51.         cal.setTime(birthDay);
  52.         //获取出生那年
  53.         int yearBirth = cal.get(Calendar.YEAR);
  54.         //获取出生月
  55.         int monthBirth = cal.get(Calendar.MONTH);
  56.         //获取出生日
  57.         int dayOfMonthBirth = cal.get(Calendar.DAY_OF_MONTH);
  58.         //年纪
  59.         int age = yearNow - yearBirth;
  60.         //如果现在的月份小于生日的月份,年龄-1,如果等于出生的月份,日前小于生日日期,年龄-1
  61.         if (monthNow <= monthBirth) {
  62.             if (monthNow == monthBirth) {
  63.                 if (dayOfMonthNow < dayOfMonthBirth)
  64.                     age--;
  65.             } else {
  66.                 age--;
  67.             }
  68.         }
  69.         return age;
  70.     }
  71. }
  73. package com.wanggs.utils;
  75. import java.text.DateFormat;
  76. import java.text.ParseException;
  77. import java.text.SimpleDateFormat;
  78. import java.util.Calendar;
  79. import java.util.Date;
  80. import java.util.Hashtable;
  81. import java.util.Map;
  83. /**
  84.  * 日期处理工具,线程安全
  85.  */
  86. public class DateUtils {
  87.     private static Map<String, ThreadLocal<DateFormat>> thredlocalmap = new Hashtable<String, ThreadLocal<DateFormat>>();
  89.     public static final String yyyyMMddHHmmss = "yyyy-MM-dd HH:mm:ss";
  90.     public static final String yyyyMMdd = "yyyy-MM-dd";
  91.     public static final String yyyyMM = "yyyy-MM";
  92.     public static final String yyyy = "yyyy";
  93.     public static final String HHmmss = "HH:mm:ss";
  94.     public static final String MM = "MM";
  95.     public static final String week = "E";
  97.     static {
  98.         thredlocalmap.put(yyyyMMddHHmmss,  new ThreadLocal<DateFormat>());
  99.         thredlocalmap.put(yyyyMMdd,  new ThreadLocal<DateFormat>());
  100.         thredlocalmap.put(yyyyMM,  new ThreadLocal<DateFormat>());
  101.         thredlocalmap.put(yyyy,  new ThreadLocal<DateFormat>());
  102.         thredlocalmap.put(HHmmss,  new ThreadLocal<DateFormat>());
  103.         thredlocalmap.put(MM,  new ThreadLocal<DateFormat>());
  104.         thredlocalmap.put(week,  new ThreadLocal<DateFormat>());
  105.     }
  107.     /**
  108.      * 通过格式获取格式化对象,线程安全
  109.      *
  110.      * @param datePattern
  111.      * @return
  112.      */
  113.     public static DateFormat getDateFormat(String datePattern) {
  114.         ThreadLocal<DateFormat> threadlocal = getThreadLocal(datePattern);
  115.         DateFormat fmt = threadlocal.get();
  116.         if (fmt == null) {
  117.             fmt = new SimpleDateFormat(datePattern);
  118.             threadlocal.set(fmt);
  119.         }
  120.         return fmt;
  121.     }
  123.     private static ThreadLocal<DateFormat> getThreadLocal(String datePattern) {
  124.         ThreadLocal<DateFormat> theadlocal = thredlocalmap.get(datePattern);
  125.         if(theadlocal == null) {
  126.             theadlocal = new ThreadLocal<DateFormat>();
  127.             thredlocalmap.put(datePattern, theadlocal);
  128.         }
  129.         return theadlocal;
  130.     }
  132.     /**
  133.      * 将字符串日期转换成Date对象
  134.      *
  135.      * @param dateStr 日期字符串
  136.      * @param datePattern 日期格式
  137.      * @return
  138.      */
  139.     public static Date parse(String dateStr, String datePattern) {
  140.         try {
  141.             return getDateFormat(datePattern).parse(dateStr);
  142.         } catch (ParseException e) {
  143.             e.printStackTrace();
  144.             return null;
  145.         }
  146.     }
  148.     /**
  149.      * 将Date对象转换成字符串日期
  150.      *
  151.      * @param date 日期对象
  152.      * @param datePattern 日期格式
  153.      * @return
  154.      */
  155.     public static String format(Date date, String datePattern) {
  156.         return getDateFormat(datePattern).format(date);
  157.     }
  159.     /**
  160.      * 取得特定时间对应的字符串,格式化为yyyy-MM-dd HH:mm:ss
  161.      *
  162.      * @param date 日期对象
  163.      * @return
  164.      */
  165.     public static String ymdhmsFormat(Date date) {
  166.         return format(date, yyyyMMddHHmmss);
  167.     }
  169.     /**
  170.      * 取得特定时间对应的字符串,格式化为yyyy-MM-dd
  171.      *
  172.      * @param date
  173.      * @return
  174.      */
  175.     public static String ymdFormat(Date date) {
  176.         return format(date, yyyyMMdd);
  177.     }
  179.     /**
  180.      * 根据当前日期,得到当前年月
  181.      *
  182.      * @param date
  183.      * @return str
  184.      */
  185.     public static final String ymFormat(Date date) {
  186.         if (date == null)
  187.             return "";
  188.         return format(date, yyyyMM);
  189.     }
  191.     /**
  192.      * 根据当前日期,得到当前年份
  193.      *
  194.      * @param date
  195.      * @return str
  196.      */
  197.     public static final String yFormat(Date date) {
  198.         if (date == null)
  199.             return "";
  200.         return format(date, yyyy);
  201.     }
  203.     /**
  204.      * 根据当前日期,得到当前月份
  205.      *
  206.      * @param date
  207.      * @return str
  208.      */
  209.     public static final String mFormat(Date date) {
  210.         if (date == null)
  211.             return "";
  212.         return format(date, MM);
  213.     }
  215.     /**
  216.      * 返回当前的时间，格式为H:mm:ss
  217.      *
  218.      * @return 时间字符串
  219.      */
  220.     public static final String getTimeNow() {
  221.         return format(new Date(), HHmmss);
  222.     }
  224.     /**
  225.      * 把字符串形式转换成日期形式，字符串的格式必须为yyyy-MM-dd
  226.      *
  227.      * @param ymdStringDate
  228.      * @return date
  229.      */
  230.     public static final Date ymdString2Date(String ymdStringDate) {
  231.         if (ymdStringDate == null)
  232.             return null;
  233.         return parse(ymdStringDate, yyyyMMdd);
  234.     }
  236.     /**
  237.      * 把字符串形式转换成日期形式，字符串的格式必须为yyyy-MM-dd HH:mm:ss
  238.      *
  239.      * @param ymdhmsStringDate
  240.      * @return date
  241.      */
  242.     public static final Date ymdhmsString2Date(String ymdhmsStringDate) {
  243.         if (ymdhmsStringDate == null)
  244.             return null;
  245.         return parse(ymdhmsStringDate, yyyyMMddHHmmss);
  246.     }
  248.     /**
  249.      *
  250.      * 得到当前时间,把日期后的时间归0 变成(yyyy-MM-dd 00:00:00:000)
  251.      *
  252.      * @return date
  253.      */
  254.     public static Date getCurrentDate() {
  255.         Date date = new Date();
  256.         return zerolizedTime(date);
  257.     }
  259.     /**
  260.      * 把日期后的时间归0 变成(yyyy-MM-dd 00:00:00:000)
  261.      *
  262.      * @param fullDate
  263.      * @return Date
  264.      */
  265.     public static final Date zerolizedTime(Date fullDate) {
  266.         Calendar cal = Calendar.getInstance();
  267.         cal.setTime(fullDate);
  268.         cal.set(Calendar.HOUR_OF_DAY, 0);
  269.         cal.set(Calendar.MINUTE, 0);
  270.         cal.set(Calendar.SECOND, 0);
  271.         cal.set(Calendar.MILLISECOND, 0);
  272.         return cal.getTime();
  273.     }
  275.     /**
  276.      * 得到两个时间的间隔
  277.      *
  278.      * @param bDate
  279.      * @param eDate
  280.      * @return
  281.      */
  282.     static public long dateDiffByDay(Date bDate, Date eDate) {
  283.         if (bDate == null || eDate == null)
  284.             return 0L;
  285.         return (bDate.getTime() - eDate.getTime()) / (1000 * 3600 * 24);
  286.     }
  289.     /**
  290.      * 取得指定日期的星期数
  291.      *
  292.      * @return String
  293.      */
  294.     public static final String getWeek(Date date) {
  295.         if (date == null)
  296.             return null;
  297.         return format(date, week);
  298.     }
  300.     /**
  301.      * 判断两个日期字符串是否相等,格式必需为yyyy-MM-dd
  302.      *
  303.      * @param one
  304.      *            第一个日期字符串
  305.      * @param two
  306.      *            第二个日期字符串
  307.      * @return Boolean
  308.      */
  309.     public static final boolean  isEqual(String one, String two) {
  310.         return ymdString2Date(one).equals(ymdString2Date(two));
  311.     }
  313.     /**
  314.      * 判断两个日期字符串是否相等
  315.      *
  316.      * @param one
  317.      *            第一个日期字符串
  318.      * @param two
  319.      *            第二个日期字符串
  320.      * @param datePattern
  321.      *            包含日期格式的字符串
  322.      * @return Boolean
  323.      */
  324.     public static final boolean  isEqual(String one, String two, String datePattern) {
  326.         return isEqual(one, two, datePattern, datePattern);
  327.     }
  329.     /**
  330.      * 判断两个日期字符串是否相等
  331.      *
  332.      * @param one
  333.      *            第一个日期字符串
  334.      * @param two
  335.      *            第二个日期字符串
  336.      * @param datePatternOne
  337.      *            对应第一个日期字符串的包含日期格式的字符串
  338.      * @param datePatternTwo
  339.      *            对应第二个日期字符串的包含日期格式的字符串
  340.      * @return Boolean
  341.      */
  342.     public static final Boolean isEqual(String one, String two,
  343.                                         String datePatternOne, String datePatternTwo) {
  345.         return parse(one, datePatternOne).equals(parse(two, datePatternTwo));
  346.     }
  348.     /**
  349.      * 返回两时间的时间间隔（以分计算）
  350.      *
  351.      * @param date1
  352.      * @param date2
  353.      * @return
  354.      */
  355.     static public long spaceMinute(Date date1, Date date2) {
  356.         Long num1 = date1.getTime();
  357.         Long num2 = date2.getTime();
  358.         Long space = (num2 - num1) / (1000 * 60);
  359.         return space;
  360.     }
  362.     /**
  363.      * 返回两时间的时间间隔（以天计算）
  364.      *
  365.      * @paramtime1
  366.      * @paramtime2
  367.      * @return
  368.      */
  369.     static public Long spaceDay(Date date1, Date date2) {
  370.         Long num1 = date1.getTime();
  371.         Long num2 = date2.getTime();
  372.         Long space = (num2 - num1) / (1000 * 3600 * 24);
  373.         return space;
  374.     }
  376.     static public Date getDateAfterDay(Date somedate, int day) {
  377.         if (somedate == null)
  378.             return null;
  379.         Calendar cal = Calendar.getInstance();
  380.         cal.setTime(somedate);
  381.         cal.add(Calendar.DAY_OF_MONTH, day);
  382.         return new Date(cal.getTime().getTime());
  383.     }
  385.     static public Date getDateAfterDay(int day) {
  386.         Calendar cal = Calendar.getInstance();
  387.         cal.setTime(new Date());
  388.         cal.add(Calendar.DAY_OF_MONTH, day);
  389.         return cal.getTime();
  390.     }
  392.     static public Date getTSAfterDay(Date somedate, int day) {
  393.         Calendar cal = Calendar.getInstance();
  394.         cal.setTime(somedate);
  395.         cal.add(Calendar.DAY_OF_MONTH, day);
  396.         return cal.getTime();
  397.     }
  399.     // 取得本月第一天时间
  400.     static public Date getFirstDayOfMonth(Date date) {
  401.         Calendar cal = Calendar.getInstance();
  402.         cal.setTime(date);
  403.         cal.set(Calendar.DAY_OF_MONTH, 1);
  404.         return cal.getTime();
  405.     }
  407. }
  409. package com.toltech.springboot.util;
  411. import org.apache.commons.lang3.StringUtils;
  412. import org.slf4j.Logger;
  413. import org.slf4j.LoggerFactory;
  415. import java.math.BigDecimal;
  416. import java.text.ParseException;
  417. import java.text.SimpleDateFormat;
  418. import java.util.Calendar;
  419. import java.util.Date;
  420. import java.util.GregorianCalendar;
  423. /**
  424.  * 日期工具类,提供时间转换、比较、格式化等各种常用方法
  425.  * @modificationHistory.  
  426.  * <ul>
  427.  * <li>gaozhanglei 2010-8-27下午04:06:10 TODO</li>
  428.  * <li>
  429.  * sunju 2012-7-31 下午03:06:05 新增getDate方法，
  430.  * 修改getNowDate方法以及其它几个使用了toLocaleString()的方法，解决Linux下时间错误问题
  431.  * </li>
  432.  * </ul>
  433.  */
  435. public class DateUtil {
  436.     private static Logger LOG = LoggerFactory.getLogger(DateUtil.class);
  437.     /**
  438.      * 时间间隔：日
  439.      */
  440.     public final static int DATE_INTERVAL_DAY = 1;
  441.     /**
  442.      * 时间间隔：周
  443.      */
  444.     public final static int DATE_INTERVAL_WEEK = 2;
  445.     /**
  446.      * 时间间隔：月
  447.      */
  448.     public final static int DATE_INTERVAL_MONTH = 3;
  449.     /**
  450.      * 时间间隔：年
  451.      */
  452.     public final static int DATE_INTERVAL_YEAR = 4;
  453.     /**
  454.      * 时间间隔：小时
  455.      */
  456.     public final static int DATE_INTERVAL_HOUR = 5;
  457.     /**
  458.      * 时间间隔：分钟
  459.      */
  460.     public final static int DATE_INTERVAL_MINUTE = 6;
  461.     /**
  462.      * 时间间隔：秒
  463.      */
  464.     public final static int DATE_INTERVAL_SECOND = 7;
  465.     /**
  466.      * 时间格式：年月日
  467.      */
  468.     public final static String DATE_FORMAT_MDY = "MM/dd/yyyy";
  469.     public final static String DATE_FORMAT_YMD = "yyyy-MM-dd";
  470.     public final static String DATE_FORMAT_YMD_ZH = "yyyy年MM月 ";
  471.     public final static String DATE_FORMAT_YMDHMS_ZH = "yyyy年MM月dd日 ";
  472.     public final static String DATE_FORMATE_YM="yyyyMM";
  473.     public final static String DATE_FORMATE_LC="yy年MM月";
  474.     public final static String DATE_FORMAT_MD="MM-dd";
  475.     public final static String DATE_FORMAT_YMD_NL="yyyyMMdd";
  476.     /**
  477.      * 时间格式：年月日时分秒
  478.      */
  479.     public final static String DATE_FORMAT_YMDHMS = "yyyy-MM-dd HH:mm:ss";
  480.     public final static String DATE_FORMATE_LX_YMDHMS = "yyyyMMddHHmmss";
  481.     public static final String DATE_FORMATE_LX_YMDHMSS = "mmss";
  483.     /**
  484.      * 获得时间
  485.      * @author sunju
  486.      * @creationDate. 2012-7-31 下午03:06:05 
  487.      * @param date 时间
  488.      * @param dateFormat 时间格式
  489.      * @return 时间
  490.      */
  491.     public static Date getDate(Date date, String dateFormat) {
  492.         return parseDate(dateFormat(date, dateFormat), dateFormat);
  493.     }
  494.     /**
  495.      * 获得当前日期(年月日)
  496.      * @author sunju
  497.      * @creationDate. 2010-8-27 下午05:11:23
  498.      * @return 当前时间（yyyy-MM-dd）
  499.      */
  500.     public static Date getNowDate() {
  501.         return parseDate(dateFormat(new Date(), DATE_FORMAT_YMD), DATE_FORMAT_YMD);
  502.     }
  503.     /**
  504.      * 获取当前时间字符串(年月日)
  505.      * @author sunju
  506.      * @creationDate. 2011-5-4 下午08:22:34 
  507.      * @return 时间字符串
  508.      */
  509.     public static String getNowStringDate() {
  510.         return dateFormat(new Date(), DATE_FORMAT_YMD);
  511.     }
  512.     /**
  513.      * 获得当前时间(年月日时分秒)
  514.      * @author sunju
  515.      * @creationDate. 2010-8-27 下午05:12:57
  516.      * @return 当前时间（yyyy-MM-dd HH:mm:ss）
  517.      */
  518.     public static Date getNowTime() {
  519.         return parseDate(dateFormat(new Date(), DATE_FORMAT_YMDHMS), DATE_FORMAT_YMDHMS);
  520.     }
  521.     /**
  522.      * 获取当前时间字符串(年月日时分秒)
  523.      * @author sunju
  524.      * @creationDate. 2014-3-10 下午03:16:42 
  525.      * @return 时间字符串
  526.      */
  527.     public static String getNowStringTime() {
  528.          return dateFormat(new Date(), DATE_FORMAT_YMDHMS);
  529.     }
  530.     /**
  531.      * 获得明天的日期字符串(格式年月日)
  532.      * @author sunju
  533.      * @creationDate. 2011-5-4 下午08:19:28 
  534.      * @return 明天的日期
  535.      */
  536.     public static String getTomorrowStringDate() {
  537.         return dateFormat(getTomorrowTime(), DATE_FORMAT_YMD);
  538.     }
  539.     /**
  540.      * 获得明天的日期(年月日)
  541.      * @author sunju
  542.      * @creationDate. 2011-5-4 下午08:19:57 
  543.      * @return 明天的日期
  544.      */
  545.     public static Date getTomorrowDate() {
  546.         return dateAdd(DATE_INTERVAL_DAY, getNowDate(), 1);
  547.     }
  548.     /**
  549.      * 获得明天的时间(年月日时分秒)
  550.      * @author sunju
  551.      * @creationDate. 2011-5-4 下午08:20:19 
  552.      * @return 明天的时间
  553.      */
  554.     public static Date getTomorrowTime() {
  555.         return dateAdd(DATE_INTERVAL_DAY, getNowTime(), 1);
  556.     }
  557.     /**
  558.      * 获得昨天的日期
  559.      * @author sunju
  560.      * @creationDate. 2013-10-22 下午03:54:48 
  561.      * @return 昨天的日期
  562.      */
  563.     public static Date getYesterdayDate() {
  564.         return dateAdd(DATE_INTERVAL_DAY, getNowDate(), -1);
  565.     }
  566.     /**
  567.      * 获得昨天的时间(年月日时分秒)
  568.      * @author sunju
  569.      * @creationDate. 2013-10-22 下午03:54:48 
  570.      * @return 昨天的日期
  571.      */
  572.     public static Date getYseterdayTime(){
  573.         return dateAdd(DATE_INTERVAL_DAY, getNowTime(), -1);
  574.     }
  575.     /**
  576.      * 获取当月第一天   
  577.      * @author sunju
  578.      * @creationDate. 2013-10-22 下午03:45:53 
  579.      * @return 日期
  580.      */
  581.     public static Date getMonthFirst() {
  582.         Calendar lastDate = Calendar.getInstance();
  583.         lastDate.set(Calendar.DATE, 1); // 设为当前月的1号
  584.         return getDate(lastDate.getTime(), DATE_FORMAT_YMD);
  585.     }
  586.     /**
  587.      * 获得下个月第一天的日期
  588.      * @author sunju
  589.      * @creationDate. 2013-10-22 下午03:52:38 
  590.      * @return 日期
  591.      */
  592.     public static Date getNextMonthFirst() {
  593.         Calendar lastDate = Calendar.getInstance();
  594.         lastDate.add(Calendar.MONTH, 1); // 加一个月
  595.         lastDate.set(Calendar.DATE, 1);  // 把日期设置为当月第一天
  596.         return getDate(lastDate.getTime(), DATE_FORMAT_YMD);
  597.     }
  599.     public static Date getMonthStartTime(Date date, int monthDiff){
  600.         Calendar calendar = GregorianCalendar.getInstance();
  601.         if(date != null){
  602.             calendar.setTime(date);
  603.         }else{
  604.             calendar.setTimeInMillis(System.currentTimeMillis());
  605.         }
  606.         if(monthDiff != 0){
  607.             calendar.add(Calendar.MONTH, monthDiff);
  608.         }
  609.         calendar.set(Calendar.DAY_OF_MONTH, 1);
  610.         calendar.set(Calendar.HOUR_OF_DAY, 0);
  611.         calendar.set(Calendar.MINUTE, 0);
  612.         calendar.set(Calendar.SECOND, 0);
  613.         calendar.set(Calendar.MILLISECOND, 0);
  614.         Date resultDate = calendar.getTime();
  615.         return resultDate;
  616.     }
  618.     public static Date getMonthEndTime(Date date, int monthDiff){
  619.         Calendar calendar = GregorianCalendar.getInstance();
  620.         if(date != null){
  621.             calendar.setTime(date);
  622.         }else{
  623.             calendar.setTimeInMillis(System.currentTimeMillis());
  624.         }
  625.         if(monthDiff != 0){
  626.             calendar.add(Calendar.MONTH, monthDiff);
  627.         }
  628.         calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
  629.         calendar.set(Calendar.HOUR_OF_DAY, 23);
  630.         calendar.set(Calendar.MINUTE, 59);
  631.         calendar.set(Calendar.SECOND, 59);
  632.         calendar.set(Calendar.MILLISECOND, 999);
  633.         Date resultDate = calendar.getTime();
  634.         return resultDate;
  635.     }
  637.     /**
  638.      * 取得当前星期几
  639.      * @author sunju
  640.      * @creationDate. 2010-9-20 下午05:34:36 
  641.      * @param date 时间
  642.      * @return 星期
  643.      */
  644.     public static String getWeekOfDate(Date date) {
  645.         if (date == null) {
  646.             return null;
  647.         }
  648.         String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"}; 
  649.         Calendar cal = Calendar.getInstance(); 
  650.         cal.setTime(date); 
  651.         int w = cal.get(Calendar.DAY_OF_WEEK) - 1; 
  652.         if (w < 0) {
  653.             w = 0;
  654.         }
  655.         return weekDays[w]; 
  656.     }
  657.     /**
  658.      * 时间类型转换返回字符串
  659.      * @author sunju
  660.      * @creationDate. 2010-8-27 下午05:18:37
  661.      * @param date 时间
  662.      * @param dateFormat 时间格式
  663.      * @return 转换后的时间字符串
  664.      */
  665.     public static String dateFormat(Date date, String dateFormat) {
  666.         if (date == null) {
  667.             return null;
  668.         }
  669.         SimpleDateFormat format = new SimpleDateFormat(dateFormat);
  670.         return format.format(date);
  671.     }
  672.     /**
  673.      * 字符串时间类型转换返回Date类型
  674.      * @author sunju
  675.      * @creationDate. 2010-8-27 下午05:23:35
  676.      * @param date 字符串时间
  677.      * @param dateFormat 时间格式
  678.      * @return 转换后的时间
  679.      */
  680.     public static Date parseDate(String date, String dateFormat) {
  681.         if (StringUtils.isEmpty(date)) {
  682.             return null;
  683.         }
  684.         SimpleDateFormat format = new SimpleDateFormat(dateFormat);
  685.         try {
  686.             return format.parse(date);
  687.         } catch (Exception e) {
  688.             LOG.error(e.getMessage());
  689.             return null;
  690.         }
  691.     }
  693.     public static Date getDateStartTime(Date date){
  694.         Calendar calendar = GregorianCalendar.getInstance();
  695.         if(date != null){
  696.             calendar.setTime(date);
  697.         }else{
  698.             calendar.setTimeInMillis(System.currentTimeMillis());
  699.         }
  700.         calendar.set(Calendar.HOUR_OF_DAY, 0);
  701.         calendar.set(Calendar.MINUTE, 0);
  702.         calendar.set(Calendar.SECOND, 0);
  703.         calendar.set(Calendar.MILLISECOND, 0);
  704.         Date resultDate = calendar.getTime();
  705.         return resultDate;
  706.     }
  708.     public static Date getDateEndTime(Date date){
  709.         Calendar calendar = GregorianCalendar.getInstance();
  710.         if(date != null){
  711.             calendar.setTime(date);
  712.         }else{
  713.             calendar.setTimeInMillis(System.currentTimeMillis());
  714.         }
  715.         calendar.set(Calendar.HOUR_OF_DAY, 23);
  716.         calendar.set(Calendar.MINUTE, 59);
  717.         calendar.set(Calendar.SECOND, 59);
  718.         calendar.set(Calendar.MILLISECOND, 999);
  719.         Date resultDate = calendar.getTime();
  720.         return resultDate;
  721.     }
  723.     /**
  724.      * 加时间
  725.      * @author sunju
  726.      * @creationDate. 2010-8-27 下午05:28:06
  727.      * @param interval 增加项，可以是天数、月份、年数、时间、分钟、秒
  728.      * @param date 时间
  729.      * @param num 加的数目
  730.      * @return 时间加后的时间
  731.      */
  732.     public static Date dateAdd(int interval, Date date, int num) {
  733.         if (date == null) {
  734.             return null;
  735.         }
  736.         Calendar calendar = Calendar.getInstance();  
  737.         calendar.setTime(date);
  738.         switch (interval) {
  739.         case DATE_INTERVAL_DAY:
  740.             calendar.add(Calendar.DATE, num);
  741.             break;
  742.         case DATE_INTERVAL_WEEK:
  743.             calendar.add(Calendar.WEEK_OF_MONTH, num);
  744.             break;
  745.         case DATE_INTERVAL_MONTH:
  746.             calendar.add(Calendar.MONTH, num);
  747.             break;
  748.         case DATE_INTERVAL_YEAR:
  749.             calendar.add(Calendar.YEAR, num);
  750.             break;
  751.         case DATE_INTERVAL_HOUR:
  752.             calendar.add(Calendar.HOUR, num);
  753.             break;
  754.         case DATE_INTERVAL_MINUTE:
  755.             calendar.add(Calendar.MINUTE, num);
  756.             break;
  757.         case DATE_INTERVAL_SECOND:
  758.             calendar.add(Calendar.SECOND, num);
  759.             break;
  760.         default:
  761.         }
  762.         return calendar.getTime();
  763.     }
  764.     /**
  765.      * 两个时间时间差[前面时间和比较时间比,小于比较时间返回负数]
  766.      * @author sunju
  767.      * @creationDate. 2010-8-27 下午05:26:13
  768.      * @param interval 比较项，可以是天数、月份、年数、时间、分钟、秒
  769.      * @param date 时间
  770.      * @param compare 比较的时间
  771.      * @return 时间差(保留两位小数点,小数点以后两位四舍五入)
  772.      */
  773.     public static double getDateDiff(int interval, Date date, Date compare) {
  774.         if (date == null || compare == null) {
  775.             return 0;
  776.         }
  777.         double result = 0;
  778.         double time = 0;
  779.         Calendar calendar = null;
  780.         switch (interval) {
  781.         case DATE_INTERVAL_DAY:
  782.             time = date.getTime() - compare.getTime();
  783.             result = time / 1000d / 60d / 60d / 24d;
  784.             break;
  785.         case DATE_INTERVAL_HOUR:
  786.             time = date.getTime() - compare.getTime();
  787.             result = time / 1000d / 60d / 60d;
  788.             break;
  789.         case DATE_INTERVAL_MINUTE:
  790.             time = date.getTime() / 1000d / 60d;
  791.             result = time - compare.getTime() / 1000d / 60d;
  792.             break;
  793.         case DATE_INTERVAL_MONTH:
  794.             calendar = Calendar.getInstance();
  795.             calendar.setTime(date);
  796.             time = calendar.get(Calendar.YEAR) * 12d;
  797.             calendar.setTime(compare);
  798.             time -= calendar.get(Calendar.YEAR) * 12d;
  799.             calendar.setTime(date);
  800.             time += calendar.get(Calendar.MONTH);
  801.             calendar.setTime(compare);
  802.             result = time - calendar.get(Calendar.MONTH);
  803.             break;
  804.         case DATE_INTERVAL_SECOND:
  805.             time = date.getTime() - compare.getTime();
  806.             result = time / 1000d;
  807.             break;
  808.         case DATE_INTERVAL_WEEK:
  809.             calendar = Calendar.getInstance();
  810.             calendar.setTime(date);
  811.             time = calendar.get(Calendar.YEAR) * 52d;
  812.             calendar.setTime(compare);
  813.             time -= calendar.get(Calendar.YEAR) * 52d;
  814.             calendar.setTime(date);
  815.             time += calendar.get(Calendar.WEEK_OF_YEAR);
  816.             calendar.setTime(compare);
  817.             result = time - calendar.get(Calendar.WEEK_OF_YEAR);
  818.             break;
  819.         case DATE_INTERVAL_YEAR:
  820.             calendar = Calendar.getInstance();
  821.             calendar.setTime(date);
  822.             time = calendar.get(Calendar.YEAR);
  823.             calendar.setTime(compare);
  824.             result = time - (double)calendar.get(Calendar.YEAR);
  825.             break;
  826.         default:
  827.             break;
  828.         }
  829.         return new BigDecimal(result).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
  830.     }
  831.     /**
  832.      * 获取时间差[前面时间和比较时间比,小于比较时间返回负数]
  833.      * @author sunju
  834.      * @creationDate. 2010-9-1 下午04:36:07 
  835.      * @param level 返回时间等级(1:返回天;2:返回天-小时;3:返回天-小时-分4:返回天-小时-分-秒;)
  836.      * @param date 时间
  837.      * @param compare 比较的时间
  838.      * @return 时间差(保留两位小数点,小数点以后两位四舍五入)
  839.      */
  840.     public static String getDateBetween(Integer level, Date date, Date compare) {
  841.         if (date == null || compare == null) {
  842.             return null;
  843.         }
  844.         long s = new BigDecimal(getDateDiff(DATE_INTERVAL_SECOND, date, compare)).setScale(2, BigDecimal.ROUND_HALF_UP).longValue();
  845.         int ss = 1;
  846.         int mi = ss * 60;
  847.         int hh = mi * 60;
  848.         int dd = hh * 24;
  850.         long day = s / dd;
  851.         long hour = (s - day * dd) / hh;
  852.         long minute = (s - day * dd - hour * hh) / mi;
  853.         long second = (s - day * dd - hour * hh - minute * mi) / ss;
  854.         String flag =(day < 0 || hour < 0 || minute < 0 || second < 0) ? "-" : "";
  855.         day = Math.abs(day);
  856.         hour = Math.abs(hour);
  857.         minute = Math.abs(minute);
  858.         second = Math.abs(second);
  859.         StringBuilder result = new StringBuilder(flag);
  860.         switch (level) {
  861.         case 1:
  862.             if (day != 0) {
  863.                 result.append(day).append("天");
  864.             }
  865.             break;
  866.         case 2:
  867.             if (day != 0) {
  868.                 result.append(day).append("天");
  869.             }
  870.             if (hour != 0) {
  871.                 result.append(hour).append("小时");
  872.             }
  873.             break;
  874.         case 3:
  875.             if (day != 0) {
  876.                 result.append(day).append("天");
  877.             }
  878.             if (hour != 0) {
  879.                 result.append(hour).append("小时");
  880.             }
  881.             if (minute != 0) {
  882.                 result.append(minute).append("分");
  883.             }
  884.             break;
  885.         case 4:
  886.             if (day != 0) {
  887.                 result.append(day).append("天");
  888.             }
  889.             if (hour != 0) {
  890.                 result.append(hour).append("小时");
  891.             }
  892.             if (minute != 0) {
  893.                 result.append(minute).append("分");
  894.             }
  895.             if (second != 0) {
  896.                 result.append(second).append("秒");
  897.             }
  898.             break;
  899.         default:
  900.             break; 
  901.         }
  902.         return result.toString();
  903.     }
  904.     /**
  905.      * 时间是否是今天
  906.      * @author sunju
  907.      * @creationDate. 2011-5-4 下午08:24:58 
  908.      * @param date 时间
  909.      * @return 布尔
  910.      */
  911.     public static boolean isToday(Date date) {
  912.         if (date == null) return false;
  913.         return getNowStringDate().equals(dateFormat(date, DATE_FORMAT_YMD));
  914.     }
  915.     /**
  916.      * 时间是否合法
  917.      * @author sunju
  918.      * @creationDate. 2012-6-19 下午01:07:59 
  919.      * @param date 时间
  920.      * @param dateFormat 时间格式
  921.      * @return
  922.      */
  923.     public static boolean isValidDate(String date, String dateFormat) {
  924.         try {
  925.             new SimpleDateFormat(dateFormat).parse(date);
  926.             return true;
  927.         } catch (Exception e) {
  928.             return false;
  929.         }
  930.     }
  932.     /**
  933.      * 
  934.      * 是否大于现在的时间  
  935.      * true 大于
  936.      * <ul>
  937.      * <li>
  938.      * <b>原因：<br/>
  939.      * <p>
  940.      * [2014-8-27]gaozhanglei<br/>
  941.      * @param date
  942.      * @param dateFormate
  943.      * @return
  944.      * TODO
  945.      * </p>
  946.      * </li>
  947.      * </ul>
  948.      */
  949.     public static boolean isgtnow(String date,String dateFormate) {
  950.           boolean flag=false;
  951.         try {
  952.             Date nowdt=new Date();
  953.             Date  compt=DateUtil.parseDate(date, dateFormate);
  954.             long nowtm=nowdt.getTime();
  955.             long comptm=compt.getTime();
  956.             if(comptm > nowtm) {
  957.                 flag=true;
  958.             }
  959.         }catch (Exception e) {
  960.             flag=false;
  961.         }
  963.         return flag;
  964.     }
  965.     /**   
  966.      * 得到本月的最后一天   
  967.      *    
  968.      * @return   
  969.      */    
  970.     public static String getMonthLastDay() {     
  971.         Calendar calendar = Calendar.getInstance();     
  972.         calendar.set(Calendar.DAY_OF_MONTH, calendar     
  973.                 .getActualMaximum(Calendar.DAY_OF_MONTH));     
  974.         return dateFormat(calendar.getTime(),DATE_FORMAT_YMD);     
  975.     }
  977.     /**
  978.      * 获取时间在当月的天数
  979.      * @param date
  980.      * @return
  981.      */
  982.     public static int getDayOfMonth(Date date){
  983.         Calendar calendar = Calendar.getInstance();
  984.         calendar.setTime(date);
  985.         return calendar.get(Calendar.DAY_OF_MONTH);
  986.     }
  988.     public static int getMaxDayOfMonth(Date date){
  989.         Calendar calendar = Calendar.getInstance();
  990.         calendar.setTime(date);
  991.         return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
  992.     }
  994.     //当前时间转时间戳
  995.     public static String timeStamp(){
  996.         SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT_YMDHMS);
  997.         String time="1970-01-06 11:45:55";  
  998.         String date =null;
  999.         try {
  1000.              date = format.parse(time).toString();
  1001.         } catch (ParseException e) {
  1002.         }  
  1003.         return date;
  1004.     }
  1006.     /**
  1007.      * 计算产品到期时间
  1008.      * @param productCycle   产品包周期值
  1009.      * @return   产品包到期时间
  1010.      */
  1011.     public static Date getDueTime(String productCycle){
  1012.         Date payTime = new Date(); //付费成功时间
  1013.         Calendar calendar = Calendar.getInstance();  
  1014.         calendar.setTime(payTime);
  1015.         switch (productCycle) {
  1016.         case "0":    // 包年
  1017.             calendar.add(Calendar.MONTH, 13);
  1018.             break;
  1019.         case "1":       //包半年
  1020.             calendar.add(Calendar.MONTH, 7);
  1021.             break;
  1022.         case "2":       //包季
  1023.             calendar.add(Calendar.MONTH, 4);
  1024.             break;
  1025.         case "3":       //包月
  1026.             calendar.add(Calendar.MONTH, 1);
  1027.             break;
  1028.         case "4":       //包天
  1029.             calendar.add(Calendar.DATE, 1);
  1030.             break;
  1031.         case "5":       //单点
  1032.             calendar.add(Calendar.MONTH, 1);
  1033.             break;
  1034.          default:   
  1035.             break;
  1036.         }
  1037.         return calendar.getTime();
  1038.     }
  1039.     /***
  1040.      * 用户产品包实际不可看时间（用于产品通知）
  1041.      * @param productCycle
  1042.      * @return
  1043.      */
  1044.     public static Date getActualDueTime(String productCycle){
  1045.         Date payTime = new Date(); //付费成功时间
  1046.         Calendar calendar = Calendar.getInstance();  
  1047.         calendar.setTime(payTime);
  1048.         switch (productCycle) {
  1049.         case "0":    // 包年
  1050.             calendar.add(Calendar.MONTH, 13);
  1051.             break;
  1052.         case "1":       //包半年
  1053.             calendar.add(Calendar.MONTH, 7);
  1054.             break;
  1055.         case "2":       //包季
  1056.             calendar.add(Calendar.MONTH, 4);
  1057.             break;
  1058.         case "3":       //包月
  1059.             calendar.add(Calendar.MONTH, 1);
  1060.             break;
  1061.         case "4":       //包天
  1062.             calendar.add(Calendar.DATE, 1);
  1063.             break;
  1064.         case "5":       //单点
  1065.             calendar.add(Calendar.MONTH, 1);
  1066.             break;
  1067.          default:   
  1068.             break;
  1069.         }
  1070.         return calendar.getTime();
  1071.     }
  1072. }
  1074. public class TimeUtil {
  1076.    /**
  1077.    *一些时间格式
  1078.    */
  1079.     public final static String FORMAT_TIME = "HH:mm";
  1080.     public final static String FORMAT_DATE_TIME = "yyyy-MM-dd HH:mm";
  1081.     public final static String FORMAT_DATE_TIME_SECOND = "yyyy-MM-dd HH:mm:ss";
  1082.     public final static String FORMAT_MONTH_DAY_TIME = "MM-dd HH:mm";
  1083.     public final static String FORMAT_DATE = "yyyy-MM-dd";
  1085.     public static String getFormatToday(String dateFormat) {
  1086.         Date currentTime = new Date();
  1087.         SimpleDateFormat formatter = new SimpleDateFormat(dateFormat);
  1088.         return formatter.format(currentTime);
  1089.     }
  1091.     public static Date stringToDate(String dateStr, String dateFormat) {
  1092.         SimpleDateFormat formatter = new SimpleDateFormat(dateFormat);
  1093.         try {
  1094.             return formatter.parse(dateStr);
  1095.         } catch (ParseException e) {
  1096.             return null;
  1097.         }
  1098.     }
  1099.     public static String dateToString(Date date, String dateFormat) {
  1100.         SimpleDateFormat formatter = new SimpleDateFormat(dateFormat);
  1101.         return formatter.format(date);
  1102.     }
  1104.    /**
  1105.    *类似QQ/微信 聊天消息的时间
  1106.    */
  1107.     public static String getChatTime(boolean hasYear, long timesamp) {
  1108.         long clearTime = timesamp;
  1109.         String result;
  1110.         SimpleDateFormat sdf = new SimpleDateFormat("dd");
  1111.         Date today = new Date(System.currentTimeMillis());
  1112.         Date otherDay = new Date(clearTime);
  1113.         int temp = Integer.parseInt(sdf.format(today))
  1114.                 - Integer.parseInt(sdf.format(otherDay));
  1115.         switch (temp) {
  1116.             case 0:
  1117.                 result = "今天 " + getHourAndMin(clearTime);
  1118.                 break;
  1119.             case 1:
  1120.                 result = "昨天 " + getHourAndMin(clearTime);
  1121.                 break;
  1122.             case 2:
  1123.                 result = "前天 " + getHourAndMin(clearTime);
  1124.                 break;
  1125.             default:
  1126.                 result = getTime(hasYear,clearTime);
  1127.                 break;
  1128.         }
  1129.         return result;
  1130.     }
  1132.     private static String getTime(boolean hasYear, long time) {
  1133.         String pattern=FORMAT_DATE_TIME;
  1134.         if(!hasYear){
  1135.             pattern = FORMAT_MONTH_DAY_TIME;
  1136.         }
  1137.         SimpleDateFormat format = new SimpleDateFormat(pattern);
  1138.         return format.format(new Date(time));
  1139.     }
  1141.     private static String getHourAndMin(long time) {
  1142.         SimpleDateFormat format = new SimpleDateFormat(FORMAT_TIME);
  1143.         return format.format(new Date(time));
  1144.     }
  1146.     /**
  1147.      * 获取当前日期是星期几<br>
  1148.      *
  1149.      * @param date
  1150.      * @return 当前日期是星期几
  1151.      */
  1152.     public static String getWeekOfDate(Date date) {
  1153.         String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
  1154.         Calendar cal = Calendar.getInstance();
  1155.         cal.setTime(date);
  1156.         int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
  1157.         if (w < 0)
  1158.             w = 0;
  1159.         return weekDays[w];
  1160.     }
  1162. }
  1164. /**
  1165.      * 判断某个日期与今天相差 x年x天
  1166.      * 如果大于1年，显示x年x天 。否则显示 x天
  1167.      * @param timeStamp
  1168.      * @return
  1169.      */
  1170.     public static String getOffsetYearAndDayByTimeStamp(long timeStamp) {
  1171.         String result;
  1172.         long currentTimeStamp = System.currentTimeMillis();
  1173.         long targetTimestamp = timeStamp * 1000L;
  1174.         int days = (int) ((currentTimeStamp - targetTimestamp) / ONE_YEAr);
  1175.         if (days > 365) {
  1176.             //大于1年
  1177.             Calendar calendar1 = Calendar.getInstance();
  1178.             calendar1.setTimeInMillis(currentTimeStamp);
  1179.             Calendar calendar2 = Calendar.getInstance();
  1180.             calendar2.setTimeInMillis(targetTimestamp);
  1181.             //先判断是否同年
  1182.             int y1 = calendar1.get(Calendar.YEAR);
  1183.             int y2 = calendar2.get(Calendar.YEAR);
  1184.             int d1 = calendar1.get(Calendar.DAY_OF_YEAR);
  1185.             int d2 = calendar2.get(Calendar.DAY_OF_YEAR);
  1186.             result = (y1 - y2) + "年" + (d1 - d2);
  1187.         } else {
  1188.             //不满一年，直接返回天数
  1189.             result = String.valueOf(days);
  1190.         }
  1191.         return result;
  1192.     }
  1194.     /**
  1195.      * 描述：计算两个日期所差的天数.
  1196.      *
  1197.      * @param date1 第一个时间的毫秒表示
  1198.      * @param date2 第二个时间的毫秒表示
  1199.      * @return int 所差的天数
  1200.      */
  1201.     public static int getOffsetDay(long date1, long date2) {
  1202.         Calendar calendar1 = Calendar.getInstance();
  1203.         calendar1.setTimeInMillis(date1);
  1204.         Calendar calendar2 = Calendar.getInstance();
  1205.         calendar2.setTimeInMillis(date2);
  1206.         //先判断是否同年
  1207.         int y1 = calendar1.get(Calendar.YEAR);
  1208.         int y2 = calendar2.get(Calendar.YEAR);
  1209.         int d1 = calendar1.get(Calendar.DAY_OF_YEAR);
  1210.         int d2 = calendar2.get(Calendar.DAY_OF_YEAR);
  1211.         int maxDays = 0;
  1212.         int day = 0;
  1213.         if (y1 - y2 > 0) {
  1214.             maxDays = calendar2.getActualMaximum(Calendar.DAY_OF_YEAR);
  1215.             day = d1 - d2 + maxDays;
  1216.         } else if (y1 - y2 < 0) {
  1217.             maxDays = calendar1.getActualMaximum(Calendar.DAY_OF_YEAR);
  1218.             day = d1 - d2 - maxDays;
  1219.         } else {
  1220.             day = d1 - d2;
  1221.         }
  1222.         return day;
  1223.     }
  1225.     /**
  1226.      * 描述：计算两个日期所差的小时数.
  1227.      *
  1228.      * @param date1 第一个时间的毫秒表示
  1229.      * @param date2 第二个时间的毫秒表示
  1230.      * @return int 所差的小时数
  1231.      */
  1232.     public static int getOffsetHour(long date1, long date2) {
  1233.         Calendar calendar1 = Calendar.getInstance();
  1234.         calendar1.setTimeInMillis(date1);
  1235.         Calendar calendar2 = Calendar.getInstance();
  1236.         calendar2.setTimeInMillis(date2);
  1237.         int h1 = calendar1.get(Calendar.HOUR_OF_DAY);
  1238.         int h2 = calendar2.get(Calendar.HOUR_OF_DAY);
  1239.         int h = 0;
  1240.         int day = getOffsetDay(date1, date2);
  1241.         h = h1 - h2 + day * 24;
  1242.         return h;
  1243.     }
  1245.     /**
  1246.      * 描述：计算两个日期所差的分钟数.
  1247.      *
  1248.      * @param date1 第一个时间的毫秒表示
  1249.      * @param date2 第二个时间的毫秒表示
  1250.      * @return int 所差的分钟数
  1251.      */
  1252.     public static int getOffsetMinutes(long date1, long date2) {
  1253.         Calendar calendar1 = Calendar.getInstance();
  1254.         calendar1.setTimeInMillis(date1);
  1255.         Calendar calendar2 = Calendar.getInstance();
  1256.         calendar2.setTimeInMillis(date2);
  1257.         int m1 = calendar1.get(Calendar.MINUTE);
  1258.         int m2 = calendar2.get(Calendar.MINUTE);
  1259.         int h = getOffsetHour(date1, date2);
  1260.         int m = 0;
  1261.         m = m1 - m2 + h * 60;
  1262.         return m;
  1263.     }
  1265. /**
  1266.      * 描述：获取本周的某一天.
  1267.      *
  1268.      * @param format        the format
  1269.      * @param calendarField the calendar field
  1270.      * @return String String类型日期时间
  1271.      */
  1272.     private static String getDayOfWeek(String format, int calendarField) {
  1273.         String strDate = null;
  1274.         try {
  1275.             Calendar c = new GregorianCalendar();
  1276.             SimpleDateFormat mSimpleDateFormat = new SimpleDateFormat(format);
  1277.             int week = c.get(Calendar.DAY_OF_WEEK);
  1278.             if (week == calendarField) {
  1279.                 strDate = mSimpleDateFormat.format(c.getTime());
  1280.             } else {
  1281.                 int offectDay = calendarField - week;
  1282.                 if (calendarField == Calendar.SUNDAY) {
  1283.                     offectDay = 7 - Math.abs(offectDay);
  1284.                 }
  1285.                 c.add(Calendar.DATE, offectDay);
  1286.                 strDate = mSimpleDateFormat.format(c.getTime());
  1287.             }
  1288.         } catch (Exception e) {
  1289.             e.printStackTrace();
  1290.         }
  1291.         return strDate;
  1292.     }
  1293.     /**
  1294.      * 获取当前日期是星期几
  1295.      *
  1296.      * @param date
  1297.      * @return 当前日期是星期几
  1298.      */
  1299.     public static String getWeekOfDate(Date date) {
  1300.         String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
  1301.         Calendar cal = Calendar.getInstance();
  1302.         cal.setTime(date);
  1303.         int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
  1304.         if (w < 0)
  1305.             w = 0;
  1306.         return weekDays[w];
  1307.     }
  1310.     /**
  1311.      * 描述：获取本月第一天.
  1312.      *
  1313.      * @param format the format
  1314.      * @return String String类型日期时间
  1315.      */
  1316.     public static String getFirstDayOfMonth(String format) {
  1317.         String strDate = null;
  1318.         try {
  1319.             Calendar c = new GregorianCalendar();
  1320.             SimpleDateFormat mSimpleDateFormat = new SimpleDateFormat(format);
  1321.             //当前月的第一天
  1322.             c.set(GregorianCalendar.DAY_OF_MONTH, 1);
  1323.             strDate = mSimpleDateFormat.format(c.getTime());
  1324.         } catch (Exception e) {
  1325.             e.printStackTrace();
  1326.         }
  1327.         return strDate;
  1328.     }
  1330.     /**
  1331.      * 描述：获取本月最后一天.
  1332.      *
  1333.      * @param format the format
  1334.      * @return String String类型日期时间
  1335.      */
  1336.     public static String getLastDayOfMonth(String format) {
  1337.         String strDate = null;
  1338.         try {
  1339.             Calendar c = new GregorianCalendar();
  1340.             SimpleDateFormat mSimpleDateFormat = new SimpleDateFormat(format);
  1341.             // 当前月的最后一天
  1342.             c.set(Calendar.DATE, 1);
  1343.             c.roll(Calendar.DATE, -1);
  1344.             strDate = mSimpleDateFormat.format(c.getTime());
  1345.         } catch (Exception e) {
  1346.             e.printStackTrace();
  1347.         }
  1348.         return strDate;
  1349.     }

发表评论

表情：
评论列表 （有 0 条评论，125人围观）

还没有评论，来说两句吧...

相关阅读