Java时间操作工具类

1package com.hh.util;
2
3import java.text.ParseException;
4import java.text.SimpleDateFormat;
5import java.util.Calendar;
6import java.util.Date;
7import java.util.Locale;
8import java.util.TimeZone;
9
10/**
11 * 时间工具类，该类的出现是为了替换DateUtil混乱的方法签名。 在本类的工具方法中，凡涉及到时间的本地化表现形式时，都用String格式。</br>
12 * 凡涉及到子<b>1970-01-01 08:00:00</b> 至某个时间的值时，都用long来表示</br>
13 * 
14 * 本类提供的方法都是依照中国<b>GTM+08:00</b>的时区来计算。</br> 所有的本地化都是按照简体中文 “zh” 来计算。</br>
15 * 
16 * <p>
17 * 请注意：获取的当前毫秒值因为操作系统的原因，都有误差！而且在间隔很小的时间段内（大约十几毫秒，根据操作系统的不用而不同）获取到的
18 * 毫秒值可能相同，可以理解为不同操作系统的最小时间单位为十几毫秒。
19 * </p>
20 * @version 1.0
21 * @author lixunhui@qq.com
22 * @since JDK 1.6
23 **/
24public class DateTools {
25
26	// 日期式样，年月日，用横杠离开，例如：2006-12-25，2008-08-08
27	private static final String YYYY_MM_DD = "yyyy-MM-dd";
28	// 日期式样时分秒，时分秒用冒号离开，
29	private static final String HH_MI_SS = "HH:mm:ss";
30	// 日期式样，年月日时分秒，年月日用横杠离开，时分秒用冒号离开，
31	private static final String YYYY_MM_DD_HH_MI_SS = "yyyy-MM-dd HH:mm:ss";
32	// 中国时区
33	private static TimeZone zone = TimeZone.getTimeZone("GMT+08:00");
34	// 中国国家语言格式
35	private static Locale locale = Locale.CHINESE;
36	private static final SimpleDateFormat FORMAT_YYYY_MM_DD = new SimpleDateFormat(YYYY_MM_DD);
37	private static final SimpleDateFormat FORMAT_HH_MI_SS = new SimpleDateFormat(HH_MI_SS);
38	private static final SimpleDateFormat FORMAT_YYYY_MM_DD_HH_MI_SS = new SimpleDateFormat(YYYY_MM_DD_HH_MI_SS);
39
40	private static final int YEAR = 24 * 60 * 60 * 365;
41	private static final int MONTH = 24 * 60 * 60 * 30;
42	private static final int DAY = 24 * 60 * 60;
43	private static final int HOUR = 60 * 60;
44	private static final int MINUTE = 60;
45
46	public static void main(String[] args) {
47		/**
48		 * String preMonthFirstDayDate = getPreMonthFirstDayDate();
49		 * System.out.println("preMonthFirstDayDate:" + preMonthFirstDayDate);
50		 * long preMonthFirstDayInMillis = getPreMonthFirstDayInMillis();
51		 * System.out.println("preMonthFirstDayInMillis:" +
52		 * preMonthFirstDayInMillis); long preMonthFirstDayInSeconds =
53		 * getPreMonthFirstDayInSeconds();
54		 * System.out.println("preMonthFirstDayInSeconds:" +
55		 * preMonthFirstDayInSeconds); String preMonthFirstDayTime =
56		 * getPreMonthFirstDayTime(); System.out.println("preMonthFirstDayTime:"
57		 * + preMonthFirstDayTime); String preMonthLastDayDate =
58		 * getPreMonthLastDayDate(); System.out.println("preMonthLastDayDate:" +
59		 * preMonthLastDayDate); long preMonthLastDayInMillis =
60		 * getPreMonthLastDayInMillis();
61		 * System.out.println("preMonthLastDayInMillis:" +
62		 * preMonthLastDayInMillis); long preMonthLastDayInSeconds =
63		 * getPreMonthLastDayInSeconds();
64		 * System.out.println("preMonthLastDayInSeconds:" +
65		 * preMonthLastDayInSeconds); String preMonthLastDayTime =
66		 * getPreMonthLastDayTime(); System.out.println("preMonthLastDayTime:" +
67		 * preMonthLastDayTime);
68		 **/
69
70		/**
71		 * String currMonthFirstDayDate = getCurrMonthFirstDayDate();
72		 * System.out.println("currMonthFirstDayDate:" + currMonthFirstDayDate);
73		 * long currMonthFirstDayInMillis = getCurrMonthFirstDayInMillis();
74		 * System.out.println("currMonthFirstDayInMillis:" +
75		 * currMonthFirstDayInMillis); long currMonthFirstDayInSeconds =
76		 * getCurrMonthFirstDayInSeconds();
77		 * System.out.println("currMonthFirstDayInSeconds:" +
78		 * currMonthFirstDayInSeconds); String currMonthFirstDayTime =
79		 * getCurrMonthFirstDayTime();
80		 * System.out.println("currMonthFirstDayTime:" + currMonthFirstDayTime);
81		 * long preMonthLastDayInSeconds = getPreMonthLastDayInSeconds();
82		 * System.out.println("preMonthLastDayInSeconds:" +
83		 * preMonthLastDayInSeconds); long preMonthLastDayInMillis =
84		 * getPreMonthLastDayInMillis();
85		 * System.out.println("preMonthLastDayInMillis:" +
86		 * preMonthLastDayInMillis);
87		 **/
88
89		/**
90		 * String currYearFirstDayDate = getCurrYearFirstDayDate();
91		 * System.out.println("currYearFirstDayDate:" + currYearFirstDayDate);
92		 * String preYearFirstDayDate = getPreYearFirstDayDate();
93		 * System.out.println("preYearFirstDayDate:" + preYearFirstDayDate);
94		 * long preYearFirstDayInMillis = getPreYearFirstDayInMillis();
95		 * System.out.println("preYearFirstDayInMillis:" +
96		 * preYearFirstDayInMillis); long preYearFirstDayInSeconds =
97		 * getPreYearFirstDayInSeconds();
98		 * System.out.println("preYearFirstDayInSeconds:"
99		 * +preYearFirstDayInSeconds); String preYearFirstDayTime =
100		 * getPreYearFirstDayTime(); System.out.println("preYearFirstDayTime:" +
101		 * preYearFirstDayTime); String preYearLastDayDate =
102		 * getPreYearLastDayDate(); System.out.println("preYearLastDayDate:" +
103		 * preYearLastDayDate); long preYearLastDayInMillis =
104		 * getPreYearLastDayInMillis();
105		 * System.out.println("preYearLastDayInMillis:" +
106		 * preYearLastDayInMillis); long preYearLastDayInSeconds =
107		 * getPreYearLastDayInSeconds();
108		 * System.out.println("preYearLastDayInSeconds:" +
109		 * preYearLastDayInSeconds); String preYearLastDayTime =
110		 * getPreYearLastDayTime(); System.out.println("preYearLastDayTime:" +
111		 * preYearLastDayTime);
112		 **/
113		/**
114		 * for(int i=0;i<5;i++){ long currMonthFirstDayInMillis =
115		 * getPreYearFirstDayInMillis();
116		 * System.out.println("currMonthFirstDayInMillis:" +
117		 * currMonthFirstDayInMillis); }
118		 * 
119		 * 
120		 * long parseTime2Second = parseTime2Second("2006-01-01 07:59:59"); long
121		 * parseTime2Second2 = parseTime2Second("2006-01-01 08:00:00");
122		 * System.out.println(parseTime2Second);
123		 * System.out.println(parseTime2Second2);
124		 **/
125		String parseSecond2Days = parseSecond2Days(99999999);
126		System.out.println(parseSecond2Days);
127	}
128
129	/**
130	 * 获取当前时间的本地化表现形式。 如：2012-07-03 18:15:03 yyyy-MM-dd HH:mm:ss
131	 * 
132	 * @return yyyy-MM-dd HH:mm:ss 本地化表现形式
133	 */
134	public static String currentTime() {
135		Calendar calendar = Calendar.getInstance(zone, locale);
136		Calendar.getInstance(zone, locale);
137		Date time = calendar.getTime();
138		String format = FORMAT_YYYY_MM_DD_HH_MI_SS.format(time);
139		return format;
140	}
141
142	/**
143	 * 获取当前日期的本地化表现形式,不包含时间。 如：2012-07-03 yyyy-MM-dd
144	 * 
145	 * @return yyyy-MM-dd 本地化表现形式
146	 */
147	public static String currentDate() {
148		Calendar calendar = Calendar.getInstance(zone, locale);
149		Date time = calendar.getTime();
150		String format = FORMAT_YYYY_MM_DD.format(time);
151		return format;
152	}
153
154	/**
155	 * 获取当前时间至1970-01-01 08:00:00 的毫秒值。 如：1341368657874
156	 * 
157	 * @return long型 毫秒值
158	 */
159	public static long currentTimeInMillis() {
160		Calendar calendar = Calendar.getInstance(zone, locale);
161		long timeInMillis = calendar.getTimeInMillis();
162		return timeInMillis;
163	}
164
165	/**
166	 * 获取当前时间至1970-01-01 08:00:00 的秒值。 如：1341368867 该方法由毫秒值除以1000获得
167	 * 
168	 * @return long型 秒值
169	 */
170	public static long currentTimeInSecond() {
171		Calendar calendar = Calendar.getInstance(zone, locale);
172		long timeInSecond = calendar.getTimeInMillis() / 1000;
173		return timeInSecond;
174	}
175
176	/**
177	 * @param millis
178	 *            距1970-01-01 00:00:00.000的毫秒值
179	 * @return yyyy-MM-dd HH:mm:ss 本地化表现形式
180	 */
181	public static String parseMillis2Time(long millis) {
182		Calendar calendar = Calendar.getInstance(zone, locale);
183		calendar.setTimeInMillis(millis);
184		Date time = calendar.getTime();
185		String format = FORMAT_YYYY_MM_DD_HH_MI_SS.format(time);
186		return format;
187	}
188
189	/**
190	 * 
191	 * @param second
192	 *            距1970-1-1 00:00:00.000的秒值
193	 * @return yyyy-MM-dd HH:mm:ss 本地化表现形式
194	 * @see String parseMillis2Time(long millis)
195	 * @exception RuntimeException
196	 *                如果参数不能按照<code>yyyy-MM-dd HH:mm:ss</code>
197	 *                格式解析，会抛出RuntimeException
198	 */
199	public static String parseSecond2Time(long second) {
200		return parseMillis2Time(second * 1000);
201	}
202
203	/**
204	 * 
205	 * @param time
206	 *            "2012-07-04 12:19:34" 必须是 <code>yyyy-MM-dd HH:mm:ss</code> 格式
207	 * 
208	 * @return long型 秒值
209	 * @exception RuntimeException
210	 *                如果参数不能按照<code>yyyy-MM-dd HH:mm:ss</code>
211	 *                格式解析，会抛出RuntimeException
212	 */
213	public static long parseTime2Second(String time) {
214		if (time == null || time.trim().length() == 0) {
215			return 0L;
216		}
217		Calendar calendar = Calendar.getInstance(zone, locale);
218		Date date = null;
219		try {
220			date = FORMAT_YYYY_MM_DD_HH_MI_SS.parse(time);
221		} catch (ParseException e) {
222			e.printStackTrace();
223			throw new RuntimeException("日期时间格式解析错误，请检查格式是否正确", e);
224		}
225		calendar.setTime(date);
226		return calendar.getTimeInMillis() / 1000;
227	}
228
229	/**
230	 * 获取今天在 <code>00:00:00</code> 的日期和时间本地化表现形式
231	 * 
232	 * @return <code>yyyy-MM-dd HH:mm:ss</code> 本地化表现形式
233	 */
234	public static String getTodayStartTime() {
235		Calendar calendar = Calendar.getInstance(zone, locale);
236		calendar.set(Calendar.HOUR_OF_DAY, 0);
237		calendar.set(Calendar.MINUTE, 0);
238		calendar.set(Calendar.SECOND, 0);
239		calendar.set(Calendar.MILLISECOND, 0);
240		Date date = calendar.getTime();
241		String format = FORMAT_YYYY_MM_DD_HH_MI_SS.format(date);
242		return format;
243	}
244
245	/**
246	 * 获取今天在 <code>00:00:00</code> 至 1970-01-01 08:00:00 的毫秒值
247	 * 
248	 * @return long型 毫秒值
249	 */
250	public static long getTodayStartTimeInMillis() {
251		Calendar calendar = Calendar.getInstance(zone, locale);
252		calendar.set(Calendar.HOUR_OF_DAY, 0);
253		calendar.set(Calendar.MINUTE, 0);
254		calendar.set(Calendar.SECOND, 0);
255		calendar.set(Calendar.MILLISECOND, 0);
256		Date date = calendar.getTime();
257		return date.getTime();
258	}
259
260	/**
261	 * 获取今天在 <code>00:00:00</code> 至 1970-01-01 08:00:00 的秒值</br>
262	 * 
263	 * @return long型 秒值
264	 * @see long getTodayStartTimeInMillis()
265	 */
266	public static long getTodayStartTimeInSeconds() {
267		return getTodayStartTimeInMillis() / 1000;
268	}
269
270	public static String getTodayEndTimes() {
271		return parseMillis2Time(getTodayEndTimeInMillis());
272	}
273
274	/**
275	 * 获取今天在23:59:59 至 1970-01-01 08:00:00 的秒值</br> 假如今天是 2012-07-04，则返回
276	 * 2012-07-04 23:59:59 至 1970-01-01 08:00:00 的秒值
277	 * 
278	 * @return long型 秒值
279	 */
280	public static long getTodayEndTimeInSeconds() {
281		return getTodayEndTimeInMillis() / 1000;
282	}
283
284	/**
285	 * 获取今天在凌晨23:59:59 至 1970-01-01 08:00:00 的毫秒值</br> 假如今天是 2012-07-04，则返回
286	 * 2012-07-04 23:59:59 至 1970-01-01 08:00:00 的毫秒值
287	 * 
288	 * @return long型 毫秒值
289	 */
290	public static long getTodayEndTimeInMillis() {
291		Calendar todayEnd = Calendar.getInstance(zone, locale);
292		todayEnd.set(Calendar.HOUR, 23);
293		todayEnd.set(Calendar.MINUTE, 59);
294		todayEnd.set(Calendar.SECOND, 59);
295		todayEnd.set(Calendar.MILLISECOND, 999);
296		Date date = todayEnd.getTime();
297		return date.getTime();
298	}
299
300	/**
301	 * 获取 自 昨天00:00:00.000 至 1970-01-01 08:00:00 的毫秒值</br> 假如今天是 2012-07-04，则返回
302	 * 2012-07-03 00:00:00 至 1970-01-01 08:00:00 的毫秒值
303	 * 
304	 * @return long型 毫秒值
305	 */
306	public static long getYesterdayStartTimeInMillis() {
307		Calendar calendar = Calendar.getInstance(zone, locale);
308		calendar.set(Calendar.HOUR_OF_DAY, 0);
309		calendar.set(Calendar.MINUTE, 0);
310		calendar.set(Calendar.SECOND, 0);
311		calendar.set(Calendar.MILLISECOND, 0);
312		calendar.add(Calendar.DAY_OF_MONTH, -1);
313		Date date = calendar.getTime();
314		return date.getTime();
315	}
316
317	/**
318	 * 获取 自 昨天00:00:00 至 1970-01-01 08:00:00 的秒值</br> 假如今天是 2012-07-04，则返回
319	 * 2012-07-03 00:00:00 至 1970-01-01 08:00:00 的秒值
320	 * 
321	 * @return long型 秒值
322	 */
323	public static long getYesterdayStartTimeInSeconds() {
324		return getYesterdayStartTimeInMillis() / 1000;
325	}
326
327	/**
328	 * 获取昨天按照 <code>yyyy-MM-dd 00:00:00</code> 本地化表现形式 假如今天是2012-07-04，则返回
329	 * 2012-07-03 00:00:00
330	 * 
331	 * @return 昨天按照 <code>yyyy-MM-dd 00:00:00</code> 本地化表现形式
332	 */
333	public static String getYesterdayStartTime() {
334		Calendar calendar = Calendar.getInstance(zone, locale);
335		calendar.set(Calendar.HOUR_OF_DAY, 0);
336		calendar.set(Calendar.MINUTE, 0);
337		calendar.set(Calendar.SECOND, 0);
338		calendar.set(Calendar.MILLISECOND, 0);
339		calendar.add(Calendar.DAY_OF_MONTH, -1);
340		Date date = calendar.getTime();
341		return FORMAT_YYYY_MM_DD_HH_MI_SS.format(date);
342	}
343
344	/**
345	 * 获取昨天按照 <code>yyyy-MM-dd</code> 本地化表现形式</br> 假如今天是2012-07-04，则返回
346	 * 2012-07-03
347	 * 
348	 * @return 获取昨天按照 <code>yyyy-MM-dd</code> 本地化表现形式
349	 */
350	public static String getYesterdayDate() {
351		Calendar calendar = Calendar.getInstance(zone, locale);
352		calendar.add(Calendar.DAY_OF_MONTH, -1);
353		Date date = calendar.getTime();
354		return FORMAT_YYYY_MM_DD.format(date);
355	}
356
357	/**
358	 * 获取昨天在午夜23:59:59 至 1970-01-01 08:00:00 的毫秒值</br> 假如今天是 2012-07-04，则返回
359	 * 2012-07-03 23:59:59 至 1970-01-01 08:00:00 的毫秒值
360	 * 
361	 * @return long型 毫秒值
362	 */
363	public static long getYesterdayEndTimeInMillis() {
364		Calendar calendar = Calendar.getInstance(zone, locale);
365		calendar.add(Calendar.DAY_OF_MONTH, -1);
366		calendar.set(Calendar.HOUR_OF_DAY, 23);
367		calendar.set(Calendar.MINUTE, 59);
368		calendar.set(Calendar.SECOND, 59);
369		calendar.set(Calendar.MILLISECOND, 999);
370		Date date = calendar.getTime();
371		return date.getTime();
372	}
373
374	/**
375	 * 获取昨天在午夜23:59:59 至 1970-01-01 08:00:00 的秒值</br> 假如今天是 2012-07-04，则返回
376	 * 2012-07-03 23:59:59 至 1970-01-01 08:00:00 的秒值
377	 * 
378	 * @return long型 秒值
379	 */
380	public static long getYesterdayEndTimeInSeconds() {
381		return getYesterdayEndTimeInMillis();
382	}
383
384	/**
385	 * 获取上个月第一天的按照 <code>yyyy-MM-01 00:00:00</code> 本地化表现形式</br>
386	 * 假如今天是2012-07-04，则返回2012-06-01 00:00:00
387	 * 
388	 * @return 获取上个月第一天的按照 <code>yyyy-MM-01 00:00:00</code> 本地化表现形式</br>
389	 */
390	public static String getPreMonthFirstDayTime() {
391		Calendar calendar = Calendar.getInstance(zone, locale);
392		calendar.add(Calendar.MONTH, -1);
393		calendar.set(Calendar.DAY_OF_MONTH, 1);
394		calendar.set(Calendar.HOUR_OF_DAY, 0);
395		calendar.set(Calendar.MINUTE, 0);
396		calendar.set(Calendar.SECOND, 0);
397		calendar.set(Calendar.MILLISECOND, 0);
398		Date date = calendar.getTime();
399		return FORMAT_YYYY_MM_DD_HH_MI_SS.format(date);
400	}
401
402	/**
403	 * 获取上个月第一天的按照 <code>yyyy-MM-01</code> 本地化表现形式</br>
404	 * 假如今天是2012-07-04，则返回2012-06-01
405	 * 
406	 * @return 获取上个月第一天的按照 <code>yyyy-MM-01</code> 本地化表现形式</br>
407	 */
408	public static String getPreMonthFirstDayDate() {
409		Calendar calendar = Calendar.getInstance(zone, locale);
410		calendar.add(Calendar.MONTH, -1);
411		calendar.set(Calendar.DAY_OF_MONTH, 1);
412		Date date = calendar.getTime();
413		return FORMAT_YYYY_MM_DD.format(date);
414	}
415
416	/**
417	 * 获取上个月第一天的00:00:00 至 1970-01-01 08:00:00 的毫秒值</br> 假如今天是 2012-07-04，则返回
418	 * 2012-06-30 00:00:00 至 1970-01-01 08:00:00 的毫秒值
419	 * 
420	 * @return long 毫秒值
421	 */
422	public static long getPreMonthFirstDayInMillis() {
423		Calendar calendar = Calendar.getInstance(zone, locale);
424		calendar.add(Calendar.MONTH, -1);
425		calendar.set(Calendar.DAY_OF_MONTH, 1);
426		calendar.set(Calendar.HOUR_OF_DAY, 0);
427		calendar.set(Calendar.MINUTE, 0);
428		calendar.set(Calendar.SECOND, 0);
429		calendar.set(Calendar.MILLISECOND, 0);
430		Date date = calendar.getTime();
431		return date.getTime();
432	}
433
434	/**
435	 * 获取上个月第一天的00:00:00 至 1970-01-01 08:00:00 的秒值</br> 假如今天是 2012-07-04，则返回
436	 * 2012-06-30 00:00:00 至 1970-01-01 08:00:00 的秒值
437	 * 
438	 * @return long 秒值
439	 */
440	public static long getPreMonthFirstDayInSeconds() {
441		return getPreMonthFirstDayInMillis() / 1000;
442	}
443
444	/**
445	 * 获取上个月最后一天的按照 <code>yyyy-MM-dd 23:59:59</code> 本地化表现形式</br>
446	 * 假如今天是2012-07-04，则返回2012-06-30 23:59:59
447	 * 
448	 * @return 获取上个月最后一天的按照 <code>yyyy-MM-dd 23:59:59</code> 本地化表现形式</br>
449	 */
450	public static String getPreMonthLastDayTime() {
451		Calendar calendar = Calendar.getInstance(zone, locale);
452		calendar.set(Calendar.DAY_OF_MONTH, 1);
453		calendar.add(Calendar.DAY_OF_MONTH, -1);
454		calendar.set(Calendar.HOUR_OF_DAY, 23);
455		calendar.set(Calendar.MINUTE, 59);
456		calendar.set(Calendar.SECOND, 59);
457		calendar.set(Calendar.MILLISECOND, 999);
458		Date date = calendar.getTime();
459		return FORMAT_YYYY_MM_DD_HH_MI_SS.format(date);
460	}
461
462	/**
463	 * 获取上个月最后一天的按照 <code>yyyy-MM-dd</code> 本地化表现形式</br>
464	 * 假如今天是2012-07-04，则返回2012-06-30
465	 * 
466	 * @return 获取上个月最后一天的按照 <code>yyyy-MM-dd</code> 本地化表现形式</br>
467	 */
468	public static String getPreMonthLastDayDate() {
469		Calendar calendar = Calendar.getInstance(zone, locale);
470		calendar.set(Calendar.DAY_OF_MONTH, 1);
471		calendar.add(Calendar.DAY_OF_MONTH, -1);
472		Date date = calendar.getTime();
473		return FORMAT_YYYY_MM_DD.format(date);
474	}
475
476	/**
477	 * 获取上个月最后一天的23:59:59 至 1970-01-01 08:00:00 的毫秒值</br> 假如今天是 2012-07-04，则返回
478	 * 2012-06-30 23:59:59 至 1970-01-01 08:00:00 的毫秒值
479	 * 
480	 * @return long 毫秒值
481	 */
482	public static long getPreMonthLastDayInMillis() {
483		Calendar calendar = Calendar.getInstance(zone, locale);
484		calendar.set(Calendar.DAY_OF_MONTH, 1);
485		calendar.add(Calendar.DAY_OF_MONTH, -1);
486		calendar.set(Calendar.HOUR_OF_DAY, 23);
487		calendar.set(Calendar.MINUTE, 59);
488		calendar.set(Calendar.SECOND, 59);
489		calendar.set(Calendar.MILLISECOND, 999);
490		Date date = calendar.getTime();
491		return date.getTime();
492	}
493
494	/**
495	 * 获取上个月最后一天的23:59:59 至 1970-01-01 08:00:00 的秒值</br> 假如今天是 2012-07-04，则返回
496	 * 2012-06-30 23:59:59 至 1970-01-01 08:00:00 的秒值
497	 * 
498	 * @return long 秒值
499	 */
500	public static long getPreMonthLastDayInSeconds() {
501		return getPreMonthLastDayInMillis() / 1000;
502	}
503
504	/**
505	 * 获取当前月第一天按照 <code>yyyy-MM-dd 00:00:00</code> 本地化表现形式</br>
506	 * 假如今天是2012-07-04，则返回2012-07-01 00:00:00
507	 * 
508	 * @return 获取当前月第一天按照 <code>yyyy-MM-dd 00:00:00</code> 本地化表现形式</br>
509	 */
510	public static String getCurrMonthFirstDayTime() {
511		Calendar calendar = Calendar.getInstance(zone, locale);
512		calendar.set(Calendar.DAY_OF_MONTH, 1);
513		calendar.set(Calendar.HOUR_OF_DAY, 0);
514		calendar.set(Calendar.MINUTE, 0);
515		calendar.set(Calendar.SECOND, 0);
516		calendar.set(Calendar.MILLISECOND, 0);
517		Date date = calendar.getTime();
518		return FORMAT_YYYY_MM_DD_HH_MI_SS.format(date);
519	}
520
521	/**
522	 * 获取当前月第一天按照 <code>yyyy-MM-dd</code> 本地化表现形式</br>
523	 * 假如今天是2012-07-04，则返回2012-07-01
524	 * 
525	 * @return 获取当前月第一天按照 <code>yyyy-MM-dd</code> 本地化表现形式</br>
526	 */
527	public static String getCurrMonthFirstDayDate() {
528		Calendar calendar = Calendar.getInstance(zone, locale);
529		calendar.set(Calendar.DAY_OF_MONTH, 1);
530		calendar.set(Calendar.HOUR_OF_DAY, 0);
531		calendar.set(Calendar.MINUTE, 0);
532		calendar.set(Calendar.SECOND, 0);
533		calendar.set(Calendar.MILLISECOND, 0);
534		Date date = calendar.getTime();
535		return FORMAT_YYYY_MM_DD.format(date);
536	}
537
538	/**
539	 * 获取当前月第一天的00:00:00 至 1970-01-01 08:00:00 的毫秒值</br> 假如今天是 2012-07-04，则返回
540	 * 2012-07-01 00:00:00 至 1970-01-01 08:00:00 的毫秒值
541	 * 
542	 * @return long 毫秒值
543	 */
544	public static long getCurrMonthFirstDayInMillis() {
545		Calendar calendar = Calendar.getInstance(zone, locale);
546		calendar.set(Calendar.DAY_OF_MONTH, 1);
547		calendar.set(Calendar.HOUR_OF_DAY, 0);
548		calendar.set(Calendar.MINUTE, 0);
549		calendar.set(Calendar.SECOND, 0);
550		calendar.set(Calendar.MILLISECOND, 0);
551		Date date = calendar.getTime();
552		return date.getTime();
553	}
554
555	/**
556	 * 获取当前月第一天的00:00:00 至 1970-01-01 08:00:00 的秒值</br> 假如今天是 2012-07-04，则返回
557	 * 2012-07-01 00:00:00 至 1970-01-01 08:00:00 的秒值
558	 * 
559	 * @return long 毫秒值
560	 */
561	public static long getCurrMonthFirstDayInSeconds() {
562		return getCurrMonthFirstDayInMillis() / 1000;
563	}
564
565	/**
566	 * 获取今年第一天按照 <code>yyyy-MM-dd 00:00:00</code> 本地化表现形式</br>
567	 * 假如今天是2012-07-04，则返回2012-01-01
568	 * 
569	 * @return 获取今年第一天按照 <code>yyyy-MM-dd</code> 本地化表现形式</br>
570	 */
571	public static String getCurrYearFirstDayDate() {
572		Calendar calendar = Calendar.getInstance(zone, locale);
573		calendar.set(calendar.get(Calendar.YEAR), Calendar.JANUARY, 1);
574		Date date = calendar.getTime();
575		return FORMAT_YYYY_MM_DD.format(date);
576	}
577
578	/**
579	 * 获取今年第一天按照 <code>yyyy-MM-dd 00:00:00</code> 本地化表现形式</br>
580	 * 假如今天是2012-07-04，则返回2012-01-01 00:00:00
581	 * 
582	 * @return 获取今年第一天按照 <code>yyyy-MM-dd 00:00:00</code> 本地化表现形式</br>
583	 */
584	public static String getCurrYearFirstDayTime() {
585		Calendar calendar = Calendar.getInstance(zone, locale);
586		calendar.set(calendar.get(Calendar.YEAR), Calendar.JANUARY, 1, 0, 0, 0);
587		Date date = calendar.getTime();
588		return FORMAT_YYYY_MM_DD_HH_MI_SS.format(date);
589	}
590
591	/**
592	 * 获取今年第一天的00:00:00 至 1970-01-01 08:00:00 的毫秒值</br> 假如今天是 2012-07-04，则返回
593	 * 2012-01-01 00:00:00 至 1970-01-01 08:00:00 的毫秒值
594	 * 
595	 * @return long 毫秒值
596	 */
597	public static long getCurrYearFirstDayInMillis() {
598		Calendar calendar = Calendar.getInstance(zone, locale);
599		calendar.set(calendar.get(Calendar.YEAR), Calendar.JANUARY, 1, 0, 0, 0);
600		Date date = calendar.getTime();
601		return date.getTime();
602	}
603
604	/**
605	 * 获取今年第一天的00:00:00 至 1970-01-01 08:00:00 的秒值</br> 假如今天是 2012-07-04，则返回
606	 * 2012-01-01 00:00:00 至 1970-01-01 08:00:00 的秒值
607	 * 
608	 * @return long 毫秒值
609	 */
610	public static long getCurrYearFirstDayInSeconds() {
611		return getCurrYearFirstDayInMillis() / 1000;
612	}
613
614	/**
615	 * 获取去年第一天按照 <code>yyyy-MM-dd 00:00:00</code> 本地化表现形式</br>
616	 * 假如今天是2012-07-04，则返回2011-01-01 00:00:00
617	 * 
618	 * @return 获取今年第一天按照 <code>yyyy-MM-dd 00:00:00</code> 本地化表现形式</br>
619	 */
620	public static String getPreYearFirstDayTime() {
621		Calendar calendar = Calendar.getInstance(zone, locale);
622		calendar.set((calendar.get(Calendar.YEAR)) - 1, Calendar.JANUARY, 1, 0, 0, 0);
623		Date date = calendar.getTime();
624		return FORMAT_YYYY_MM_DD_HH_MI_SS.format(date);
625	}
626
627	/**
628	 * 获取去年第一天按照 <code>yyyy-MM-dd</code> 本地化表现形式</br>
629	 * 假如今天是2012-07-04，则返回2011-01-01
630	 * 
631	 * @return 获取今年第一天按照 <code>yyyy-MM-dd</code> 本地化表现形式</br>
632	 */
633	public static String getPreYearFirstDayDate() {
634		Calendar calendar = Calendar.getInstance(zone, locale);
635		calendar.set((calendar.get(Calendar.YEAR)) - 1, Calendar.JANUARY, 1);
636		Date date = calendar.getTime();
637		return FORMAT_YYYY_MM_DD.format(date);
638	}
639
640	/**
641	 * 获取去年第一天的00:00:00 至 1970-01-01 08:00:00 的毫秒值</br> 假如今天是 2012-07-04，则返回
642	 * 2011-01-01 00:00:00 至 1970-01-01 08:00:00 的毫秒值
643	 * 
644	 * @return long 毫秒值
645	 */
646	public static long getPreYearFirstDayInMillis() {
647		Calendar calendar = Calendar.getInstance(zone, locale);
648		calendar.set((calendar.get(Calendar.YEAR)) - 1, Calendar.JANUARY, 1, 0, 0, 0);
649		calendar.set(Calendar.MILLISECOND, 0);
650		Date date = calendar.getTime();
651		return date.getTime();
652	}
653
654	/**
655	 * 获取去年第一天的00:00:00 至 1970-01-01 08:00:00 的秒值</br> 假如今天是 2012-07-04，则返回
656	 * 2011-01-01 00:00:00 至 1970-01-01 08:00:00 的秒值
657	 * 
658	 * @return long 秒值
659	 * @see getPreYearFirstDayInMillis()
660	 */
661	public static long getPreYearFirstDayInSeconds() {
662		return getPreYearFirstDayInMillis() / 1000;
663	}
664
665	/**
666	 * 获取去年最后一天按照 <code>yyyy-MM-dd 23:59:59</code> 本地化表现形式</br>
667	 * 假如今天是2012-07-04，则返回2011-12-31 23:59:59
668	 * 
669	 * @return 获取去年最后一天按照 <code>yyyy-MM-dd 23:59:59</code> 本地化表现形式</br>
670	 */
671	public static String getPreYearLastDayTime() {
672		Calendar calendar = Calendar.getInstance(zone, locale);
673		calendar.set((calendar.get(Calendar.YEAR)) - 1, Calendar.DECEMBER, 31, 23, 59, 59);
674		calendar.set(Calendar.MILLISECOND, 999);
675		Date date = calendar.getTime();
676		return FORMAT_YYYY_MM_DD_HH_MI_SS.format(date);
677	}
678
679	/**
680	 * 获取去年最后一天按照 <code>yyyy-MM-dd</code> 本地化表现形式</br>
681	 * 假如今天是2012-07-04，则返回2011-12-31
682	 * 
683	 * @return 获取去年最后一天按照 <code>yyyy-MM-dd</code> 本地化表现形式</br>
684	 */
685	public static String getPreYearLastDayDate() {
686		Calendar calendar = Calendar.getInstance(zone, locale);
687		calendar.set((calendar.get(Calendar.YEAR)) - 1, Calendar.DECEMBER, 31);
688		calendar.set(Calendar.MILLISECOND, 999);
689		Date date = calendar.getTime();
690		return FORMAT_YYYY_MM_DD.format(date);
691	}
692
693	/**
694	 * 获取去年最后一天的00:00:00 至 1970-01-01 08:00:00 的毫秒值</br> 假如今天是 2012-07-04，则返回
695	 * 2011-12-31 23:59:59 至 1970-01-01 08:00:00 的毫秒值
696	 * 
697	 * @return long 毫秒值
698	 */
699	public static long getPreYearLastDayInMillis() {
700		Calendar calendar = Calendar.getInstance(zone, locale);
701		calendar.set((calendar.get(Calendar.YEAR)) - 1, Calendar.DECEMBER, 31, 23, 59, 59);
702		calendar.set(Calendar.MILLISECOND, 999);
703		Date date = calendar.getTime();
704		return date.getTime();
705	}
706
707	/**
708	 * 获取去年最后一天的00:00:00 至 1970-01-01 08:00:00 的秒值</br> 假如今天是 2012-07-04，则返回
709	 * 2011-12-31 23:59:59 至 1970-01-01 08:00:00 的秒值
710	 * 
711	 * @return long 秒值
712	 * @see getPreYearLastDayInMillis()
713	 */
714	public static long getPreYearLastDayInSeconds() {
715		return getPreYearLastDayInMillis() / 1000;
716	}
717
718	/**
719	 * 将 秒 换算成 X年X月X天
720	 * 
721	 * @param second
722	 * @return
723	 */
724	public static String parseSecond2Days(int second) {
725		int year = second / YEAR;
726		int year_remainder = second % YEAR;
727
728		int month = year_remainder / MONTH;
729		int month_remainder = year_remainder % MONTH;
730
731		int day = month_remainder / DAY;
732
733		if (year == 0) {
734			if (month == 0) {
735				return day + "天";
736			} else {
737				return month + "月" + day + "天";
738			}
739		} else {
740			return year + "年" + month + "月" + day + "天";
741		}
742	}
743}