Java时间工具类

  1 import java.text.ParseException;
  2 import java.text.SimpleDateFormat;
  3 import java.util.Calendar;
  4 import java.util.Date;
  5 
  6 import org.apache.commons.lang.StringUtils;
  7 
  8 /**
  9  * 函数功能
 10  * 1.日期相加减天数
 11  * 2.时间格式化成字符串
 12  * 3.字符串解析成时间对象
 13  * 4.将日期时间格式成只有日期的字符串（可以直接使用dateFormat，Pattern为Null进行格式化）
 14  * 5.当时、分、秒为00:00:00时，将日期时间格式成只有日期的字符串
 15  * 6.将日期时间格式成日期对象，和dateParse互用
 16  * 7.时间加减小时
 17  * 8.时间加减分钟
 18  * 9.时间加减秒数
 19  * 10.时间加减天数
 20  * 11.时间加减月数
 21  * 12.时间加减年数
 22  * 13.时间比较（如果myDate>compareDate返回1，<返回-1，相等返回0）
 23  * 14.获取两个时间中最小的一个时间
 24  * 15.获取两个时间中最大的一个时间
 25  * 16.获取两个日期（不含时分秒）相差的天数，不包含今天
 26  * 17.获取两个日期（不含时分秒）相差的天数，包含今天
 27  * 18.获取日期时间的年份，如2017-02-13，返回2017
 28  * 19.获取日期时间的月份，如2017年2月13日，返回2
 29  * 20.获取日期时间的第几天（即返回日期的dd），如2017-02-13，返回13
 30  * 21.获取日期时间当月的总天数，如2017-02-13，返回28
 31  * 22.获取日期时间当年的总天数，如2017-02-13，返回2017年的总天数
 32  * 23.根据时间获取当月最大的日期
 33  * 24.根据时间获取当月最小的日期，也就是返回当月的1号日期对象
 34  */
 35 public class DateUtils {
 36 
 37     public static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
 38     public static final String MINUTE_PATTERN = "yyyy-MM-dd HH:mm";
 39     public static final String HOUR_PATTERN = "yyyy-MM-dd HH:mm:ss";
 40     public static final String DATE_PATTERN = "yyyy-MM-dd";
 41     public static final String MONTH_PATTERN = "yyyy-MM";
 42     public static final String YEAR_PATTERN = "yyyy";
 43     public static final String MINUTE_ONLY_PATTERN = "mm";
 44     public static final String HOUR_ONLY_PATTERN = "HH";
 45 
 46     /**
 47      * 日期相加减天数
 48      *
 49      * @param date        如果为Null，则为当前时间
 50      * @param days        加减天数
 51      * @param includeTime 是否包括时分秒,true表示包含
 52      * @return
 53      * @throws ParseException
 54      */
 55     public static Date dateAdd(Date date, int days, boolean includeTime) throws ParseException {
 56         if (date == null) {
 57             date = new Date();
 58         }
 59         if (!includeTime) {
 60             SimpleDateFormat sdf = new SimpleDateFormat(DateUtils.DATE_PATTERN);
 61             date = sdf.parse(sdf.format(date));
 62         }
 63         Calendar cal = Calendar.getInstance();
 64         cal.setTime(date);
 65         cal.add(Calendar.DATE, days);
 66         return cal.getTime();
 67     }
 68 
 69     /**
 70      * 时间格式化成字符串
 71      *
 72      * @param date    Date
 73      * @param pattern StringUtils.DATE_TIME_PATTERN || StringUtils.DATE_PATTERN， 如果为空，则为yyyy-MM-dd
 74      * @return
 75      * @throws ParseException
 76      */
 77     public static String dateFormat(Date date, String pattern) throws ParseException {
 78         if (StringUtils.isBlank(pattern)) {
 79             pattern = DateUtils.DATE_PATTERN;
 80         }
 81         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
 82         return sdf.format(date);
 83     }
 84 
 85     /**
 86      * 字符串解析成时间对象
 87      *
 88      * @param dateTimeString String
 89      * @param pattern        StringUtils.DATE_TIME_PATTERN || StringUtils.DATE_PATTERN，如果为空，则为yyyy-MM-dd
 90      * @return
 91      * @throws ParseException
 92      */
 93     public static Date dateParse(String dateTimeString, String pattern) throws ParseException {
 94         if (StringUtils.isBlank(pattern)) {
 95             pattern = DateUtils.DATE_PATTERN;
 96         }
 97         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
 98         return sdf.parse(dateTimeString);
 99     }
100 
101     /**
102      * 将日期时间格式成只有日期的字符串（可以直接使用dateFormat，Pattern为Null进行格式化）
103      *
104      * @param dateTime Date
105      * @return
106      * @throws ParseException
107      */
108     public static String dateTimeToDateString(Date dateTime) throws ParseException {
109         String dateTimeString = DateUtils.dateFormat(dateTime, DateUtils.DATE_TIME_PATTERN);
110         return dateTimeString.substring(0, 10);
111     }
112 
113     /**
114      * 当时、分、秒为00:00:00时，将日期时间格式成只有日期的字符串，
115      * 当时、分、秒不为00:00:00时，直接返回
116      *
117      * @param dateTime Date
118      * @return
119      * @throws ParseException
120      */
121     public static String dateTimeToDateStringIfTimeEndZero(Date dateTime) throws ParseException {
122         String dateTimeString = DateUtils.dateFormat(dateTime, DateUtils.DATE_TIME_PATTERN);
123         if (dateTimeString.endsWith("00:00:00")) {
124             return dateTimeString.substring(0, 10);
125         } else {
126             return dateTimeString;
127         }
128     }
129 
130     /**
131      * 将日期时间格式成日期对象，和dateParse互用
132      *
133      * @param dateTime Date
134      * @return Date
135      * @throws ParseException
136      */
137     public static Date dateTimeToDate(Date dateTime) throws ParseException {
138         Calendar cal = Calendar.getInstance();
139         cal.setTime(dateTime);
140         cal.set(Calendar.HOUR_OF_DAY, 0);
141         cal.set(Calendar.MINUTE, 0);
142         cal.set(Calendar.SECOND, 0);
143         cal.set(Calendar.MILLISECOND, 0);
144         return cal.getTime();
145     }
146 
147     /**
148      * 时间加减小时
149      *
150      * @param startDate 要处理的时间，Null则为当前时间
151      * @param hours     加减的小时
152      * @return Date
153      */
154     public static Date dateAddHours(Date startDate, int hours) {
155         if (startDate == null) {
156             startDate = new Date();
157         }
158         Calendar c = Calendar.getInstance();
159         c.setTime(startDate);
160         c.set(Calendar.HOUR, c.get(Calendar.HOUR) + hours);
161         return c.getTime();
162     }
163 
164     /**
165      * 时间加减分钟
166      *
167      * @param startDate 要处理的时间，Null则为当前时间
168      * @param minutes   加减的分钟
169      * @return
170      */
171     public static Date dateAddMinutes(Date startDate, int minutes) {
172         if (startDate == null) {
173             startDate = new Date();
174         }
175         Calendar c = Calendar.getInstance();
176         c.setTime(startDate);
177         c.set(Calendar.MINUTE, c.get(Calendar.MINUTE) + minutes);
178         return c.getTime();
179     }
180 
181     /**
182      * 时间加减秒数
183      *
184      * @param startDate 要处理的时间，Null则为当前时间
185      * @param minutes   加减的秒数
186      * @return
187      */
188     public static Date dateAddSeconds(Date startDate, int seconds) {
189         if (startDate == null) {
190             startDate = new Date();
191         }
192         Calendar c = Calendar.getInstance();
193         c.setTime(startDate);
194         c.set(Calendar.SECOND, c.get(Calendar.SECOND) + seconds);
195         return c.getTime();
196     }
197 
198     /**
199      * 时间加减天数
200      *
201      * @param startDate 要处理的时间，Null则为当前时间
202      * @param days      加减的天数
203      * @return Date
204      */
205     public static Date dateAddDays(Date startDate, int days) {
206         if (startDate == null) {
207             startDate = new Date();
208         }
209         Calendar c = Calendar.getInstance();
210         c.setTime(startDate);
211         c.set(Calendar.DATE, c.get(Calendar.DATE) + days);
212         return c.getTime();
213     }
214 
215     /**
216      * 时间加减月数
217      *
218      * @param startDate 要处理的时间，Null则为当前时间
219      * @param months    加减的月数
220      * @return Date
221      */
222     public static Date dateAddMonths(Date startDate, int months) {
223         if (startDate == null) {
224             startDate = new Date();
225         }
226         Calendar c = Calendar.getInstance();
227         c.setTime(startDate);
228         c.set(Calendar.MONTH, c.get(Calendar.MONTH) + months);
229         return c.getTime();
230     }
231 
232     /**
233      * 时间加减年数
234      *
235      * @param startDate 要处理的时间，Null则为当前时间
236      * @param years     加减的年数
237      * @return Date
238      */
239     public static Date dateAddYears(Date startDate, int years) {
240         if (startDate == null) {
241             startDate = new Date();
242         }
243         Calendar c = Calendar.getInstance();
244         c.setTime(startDate);
245         c.set(Calendar.YEAR, c.get(Calendar.YEAR) + years);
246         return c.getTime();
247     }
248 
249     /**
250      * 时间比较（如果myDate>compareDate返回1，<返回-1，相等返回0）
251      *
252      * @param myDate      时间
253      * @param compareDate 要比较的时间
254      * @return int
255      */
256     public static int dateCompare(Date myDate, Date compareDate) {
257         Calendar myCal = Calendar.getInstance();
258         Calendar compareCal = Calendar.getInstance();
259         myCal.setTime(myDate);
260         compareCal.setTime(compareDate);
261         return myCal.compareTo(compareCal);
262     }
263 
264     /**
265      * 获取两个时间中最小的一个时间
266      *
267      * @param date
268      * @param compareDate
269      * @return
270      */
271     public static Date dateMin(Date date, Date compareDate) {
272         if (date == null) {
273             return compareDate;
274         }
275         if (compareDate == null) {
276             return date;
277         }
278         if (1 == dateCompare(date, compareDate)) {
279             return compareDate;
280         } else if (-1 == dateCompare(date, compareDate)) {
281             return date;
282         }
283         return date;
284     }
285 
286     /**
287      * 获取两个时间中最大的一个时间
288      *
289      * @param date
290      * @param compareDate
291      * @return
292      */
293     public static Date dateMax(Date date, Date compareDate) {
294         if (date == null) {
295             return compareDate;
296         }
297         if (compareDate == null) {
298             return date;
299         }
300         if (1 == dateCompare(date, compareDate)) {
301             return date;
302         } else if (-1 == dateCompare(date, compareDate)) {
303             return compareDate;
304         }
305         return date;
306     }
307 
308     /**
309      * 获取两个日期（不含时分秒）相差的天数，不包含今天
310      *
311      * @param startDate
312      * @param endDate
313      * @return
314      * @throws ParseException
315      */
316     public static int dateBetween(Date startDate, Date endDate) throws ParseException {
317         Date dateStart = dateParse(dateFormat(startDate, DATE_PATTERN), DATE_PATTERN);
318         Date dateEnd = dateParse(dateFormat(endDate, DATE_PATTERN), DATE_PATTERN);
319         return (int) ((dateEnd.getTime() - dateStart.getTime()) / 1000 / 60 / 60 / 24);
320     }
321 
322     /**
323      * 获取两个日期（不含时分秒）相差的天数，包含今天
324      *
325      * @param startDate
326      * @param endDate
327      * @return
328      * @throws ParseException
329      */
330     public static int dateBetweenIncludeToday(Date startDate, Date endDate) throws ParseException {
331         return dateBetween(startDate, endDate) + 1;
332     }
333 
334     /**
335      * 获取日期时间的年份，如2017-02-13，返回2017
336      *
337      * @param date
338      * @return
339      */
340     public static int getYear(Date date) {
341         Calendar cal = Calendar.getInstance();
342         cal.setTime(date);
343         return cal.get(Calendar.YEAR);
344     }
345 
346     /**
347      * 获取日期时间的月份，如2017年2月13日，返回2
348      *
349      * @param date
350      * @return
351      */
352     public static int getMonth(Date date) {
353         Calendar cal = Calendar.getInstance();
354         cal.setTime(date);
355         return cal.get(Calendar.MONTH) + 1;
356     }
357 
358     /**
359      * 获取日期时间的第几天（即返回日期的dd），如2017-02-13，返回13
360      *
361      * @param date
362      * @return
363      */
364     public static int getDate(Date date) {
365         Calendar cal = Calendar.getInstance();
366         cal.setTime(date);
367         return cal.get(Calendar.DATE);
368     }
369 
370     /**
371      * 获取日期时间当月的总天数，如2017-02-13，返回28
372      *
373      * @param date
374      * @return
375      */
376     public static int getDaysOfMonth(Date date) {
377         Calendar cal = Calendar.getInstance();
378         cal.setTime(date);
379         return cal.getActualMaximum(Calendar.DATE);
380     }
381 
382     /**
383      * 获取日期时间当年的总天数，如2017-02-13，返回2017年的总天数
384      *
385      * @param date
386      * @return
387      */
388     public static int getDaysOfYear(Date date) {
389         Calendar cal = Calendar.getInstance();
390         cal.setTime(date);
391         return cal.getActualMaximum(Calendar.DAY_OF_YEAR);
392     }
393 
394     /**
395      * 根据时间获取当月最大的日期
396      * <li>2017-02-13，返回2017-02-28</li>
397      * <li>2016-02-13，返回2016-02-29</li>
398      * <li>2016-01-11，返回2016-01-31</li>
399      *
400      * @param date Date
401      * @return
402      * @throws Exception
403      */
404     public static Date maxDateOfMonth(Date date) throws Exception {
405         Calendar cal = Calendar.getInstance();
406         cal.setTime(date);
407         int value = cal.getActualMaximum(Calendar.DATE);
408         return dateParse(dateFormat(date, MONTH_PATTERN) + "-" + value, null);
409     }
410 
411     /**
412      * 根据时间获取当月最小的日期，也就是返回当月的1号日期对象
413      *
414      * @param date Date
415      * @return
416      * @throws Exception
417      */
418     public static Date minDateOfMonth(Date date) throws Exception {
419         Calendar cal = Calendar.getInstance();
420         cal.setTime(date);
421         int value = cal.getActualMinimum(Calendar.DATE);
422         return dateParse(dateFormat(date, MONTH_PATTERN) + "-" + value, null);
423     }
424 
425 }