java date 日期操作

最新推荐文章于 2024-07-22 02:40:46 发布
最新推荐文章于 2024-07-22 02:40:46 发布
阅读量920 收藏 1
点赞数
分类专栏： 技术文档 文章标签： java DATE 日期
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mayy123456/article/details/53612250
版权 
  
  
  1. 
 * 类描述：日期操作工具类
  2. 

  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.ArrayList;
  6. import java.util.Calendar;
  7. import java.util.Date;
  8. import java.util.GregorianCalendar;
  9. import java.util.HashMap;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.TimeZone;
  13. 

  14. import org.slf4j.Logger;
  15. import org.slf4j.LoggerFactory;
  16. 

  17. /**
  18.  * <pre>
  19.  * &lt;b&gt;&lt;font color=&quot;blue&quot;&gt;DateUtils&lt;/font&gt;&lt;/b&gt;
  20.  * </pre>
  21.  * 
  22.  * <pre>
  23.  * &lt;b&gt; --描述说明--&lt;/b&gt;
  24.  * </pre>
  25.  * 
  26.  * <pre>
  27.  * 日期操作工具类
  28.  * </pre>
  29.  * 
  30.  * <pre>
  31.  * &lt;b&gt;--样例--&lt;/b&gt;
  32.  *   DateUtils.method();
  33.  * </pre>
  34.  * 
  35.  * JDK版本：JDK1.5
  36.  * 
  37. 

  38.  */
  39. public class DateUtils extends org.apache.commons.lang.time.DateUtils {
  40. 

  41. 	private DateUtils() {
  42. 	}
  43. 

  44. 	/** 一分钟的秒数 */
  45. 	public static final int SECONDS_ONE_MINUTE = 60;
  46. 

  47. 	/** 一秒的毫秒数 */
  48. 	public static final int MILLISECONDS_ONE_SECOND = 1000;
  49. 

  50. 	/** 一小时的秒数 */
  51. 	public static final int SECONDS_ONE_HOUR = 60 * SECONDS_ONE_MINUTE;
  52. 

  53. 	/** 一天的秒数 */
  54. 	public static final int SECONDS_ONE_DAY = 24 * SECONDS_ONE_HOUR;
  55. 

  56. 	/** 数据库存储的时间格式串，如yyyymmdd 或yyyymmddHHMiSS */
  57. 	public static final int DB_STORE_DATE = 1;
  58. 

  59. 	/** 用连字符-分隔的时间时间格式串，如yyyy-mm-dd 或yyyy-mm-dd HH:Mi:SS */
  60. 	public static final int HYPHEN_DISPLAY_DATE = 2;
  61. 

  62. 	/** 用连字符.分隔的时间时间格式串，如yyyy.mm.dd 或yyyy.mm.dd HH:Mi:SS */
  63. 	public static final int DOT_DISPLAY_DATE = 3;
  64. 

  65. 	/** 用中文字符分隔的时间格式串，如yyyy年mm月dd 或yyyy年mm月dd HH:Mi:SS */
  66. 	public static final int CN_DISPLAY_DATE = 4;
  67. 

  68. 	public static final int DB_STORE_MONTH = 5;
  69. 

  70. 	/** 数据库存储的时间格式串，时间数字串 */
  71. 	public static final int DB_STORE_DATE_SPLIT = 1;
  72. 

  73. 	/** 数据库存储的时间格式串，如yyyyMMdd */
  74. 	public static final String DB_STORE_DATE_FMT = "yyyyMMdd";
  75. 

  76. 	/** 数据库存储的时间格式串，如yyyyMMddHHMiSS */
  77. 	public static final String DB_STORE_DATE_FULL = "yyyyMMddHHmmss";
  78. 

  79. 	/** 数据库存储的时间格式串，如yyyyMM */
  80. 	public static final String DB_STORE_DATE_MONTH = "yyyyMM";
  81. 

  82. 	/** 用连字符-分隔的时间格式串 */
  83. 	public static final int LINK_DISPLAY_DATE_SPLIT = 2;
  84. 

  85. 	/** 用连字符-分隔的时间格式串，如yyyy-MM-dd */
  86. 	public static final String LINK_DISPLAY_DATE = "yyyy-MM-dd";
  87. 

  88. 	/** 用连字符-分隔的时间格式串，如yyyy-MM-dd HH:Mi:SS */
  89. 	public static final String LINK_DISPLAY_DATE_FULL = "yyyy-MM-dd HH:mm:ss";
  90. 

  91. 	/** 用连字符-分隔的时间格式串，如yyyy-MM */
  92. 	public static final String LINK_DISPLAY_DATE_MONTH = "yyyy-MM";
  93. 

  94. 	/** 用连字符.分隔的时间格式串 */
  95. 	public static final int DOT_DISPLAY_DATE_SPLIT = 3;
  96. 

  97. 	/** 用连字符.分隔的时间格式串，如yyyy.MM.dd */
  98. 	public static final String DOT_DISPLAY_DATE_FMT = "yyyy.MM.dd";
  99. 

  100. 	/** 用连字符.分隔的时间格式串，如yyyy.MM.dd HH:Mi:SS */
  101. 	public static final String DOT_DISPLAY_DATE_FULL = "yyyy.MM.dd HH:mm:ss";
  102. 

  103. 	/** 用连字符.分隔的时间格式串，如yyyy.MM */
  104. 	public static final String DOT_DISPLAY_DATE_MONTH = "yyyy.MM";
  105. 

  106. 	/** 用中文字符分隔的时间格式串 */
  107. 	public static final int CN_DISPLAY_DATE_SPLIT = 4;
  108. 

  109. 	/** 用中文字符分隔的时间格式串 */
  110. 	public static final int CN_DISPLAY_TIME_SPLIT = 5;
  111. 

  112. 	/** 用中文字符分隔的时间格式串，如yyyy年MM月dd日 */
  113. 	public static final String CN_DISPLAY_DATE_FMT = "yyyy年MM月dd日";
  114. 

  115. 	/** 用中文字符分隔的时间格式串，如yyyy年MM月dd日 HH时Mi分SS秒 */
  116. 	public static final String CN_DISPLAY_TIME_FULL = "yyyy年MM月dd日 HH时mm分ss秒";
  117. 

  118. 	/** 用中文字符分隔的时间格式串，如yyyy年MM月dd日 HH:Mi:SS */
  119. 	public static final String CN_DISPLAY_DATE_FULL = "yyyy年MM月dd日 HH:mm:ss";
  120. 

  121. 	/** 用中文字符分隔的时间格式串，如yyyy年MM月 */
  122. 	public static final String CN_DISPLAY_DATE_MONTH = "yyyy年MM月";
  123. 

  124. 	private static Logger logger = LoggerFactory.getLogger(DateUtils.class);
  125. 

  126. 	/**
  127. 	 * 根据相应的长度，及格式化分隔符返回日期类型
  128. 	 * 
  129. 	 * @param formatType
  130. 	 * @param length
  131. 	 * @return
  132. 

  133. 	 */
  134. 	private static String getFormatType(int formatSplitType, int length) {
  135. 		String formatStr = null;
  136. 		switch (formatSplitType) {
  137. 		case LINK_DISPLAY_DATE_SPLIT:
  138. 			switch (length) {
  139. 			case 14:
  140. 				formatStr = LINK_DISPLAY_DATE_FULL;
  141. 				break;
  142. 			default:
  143. 				formatStr = LINK_DISPLAY_DATE;
  144. 			}
  145. 			break;
  146. 		case DOT_DISPLAY_DATE_SPLIT:
  147. 			switch (length) {
  148. 			case 14:
  149. 				formatStr = DOT_DISPLAY_DATE_FULL;
  150. 				break;
  151. 			default:
  152. 				formatStr = DOT_DISPLAY_DATE_FMT;
  153. 			}
  154. 			break;
  155. 		case CN_DISPLAY_DATE_SPLIT:
  156. 			switch (length) {
  157. 			case 14:
  158. 				formatStr = CN_DISPLAY_DATE_FULL;
  159. 				break;
  160. 			default:
  161. 				formatStr = CN_DISPLAY_DATE_FMT;
  162. 			}
  163. 			break;
  164. 		case CN_DISPLAY_TIME_SPLIT:
  165. 			switch (length) {
  166. 			case 14:
  167. 				formatStr = CN_DISPLAY_TIME_FULL;
  168. 				break;
  169. 			default:
  170. 				formatStr = CN_DISPLAY_DATE_FMT;
  171. 			}
  172. 			break;
  173. 		default:
  174. 			switch (length) {
  175. 			case 14:
  176. 				formatStr = DB_STORE_DATE_FULL;
  177. 				break;
  178. 			default:
  179. 				formatStr = DB_STORE_DATE_FMT;
  180. 			}
  181. 			break;
  182. 		}
  183. 		return formatStr;
  184. 	}
  185. 

  186. 	/**
  187. 	 * 得到格式化时间串
  188. 	 * 
  189. 	 * @param date
  190. 	 *            指定时间
  191. 	 * @param formatType
  192. 	 *            时间格式的类型
  193. 	 * @return 指定时间的格式化时间串
  194. 	 */
  195. 	private static String getDateStr(Date date, String formatStr) {
  196. 		SimpleDateFormat fomate = new SimpleDateFormat(formatStr);
  197. 		return fomate.format(date);
  198. 	}
  199. 

  200. 	/**
  201. 	 * 将日期格式串(数字字符串)转换为各种显示的格式
  202. 	 * 
  203. 	 * @param dateStr
  204. 	 *            最小6位，最大14位的数据库存储格式时间串如:20041212
  205. 	 * @param formatType
  206. 	 *            时间格式的类型
  207. 	 * @return 格式化的时间串
  208. 	 */
  209. 	private static String toDisplayStr(String dateStr, String formatStr) {
  210. 		dateStr = dateStr.replaceAll("[^0-9]", "");
  211. 		SimpleDateFormat fomateDate = null;
  212. 		switch (dateStr.length()) {
  213. 		case 4:
  214. 			fomateDate = new SimpleDateFormat("yyyy");
  215. 			break;
  216. 		case 6:
  217. 			fomateDate = new SimpleDateFormat("yyyyMM");
  218. 			break;
  219. 		case 8:
  220. 			fomateDate = new SimpleDateFormat("yyyyMMdd");
  221. 			break;
  222. 		case 10:
  223. 			fomateDate = new SimpleDateFormat("yyyyMMddHH");
  224. 			break;
  225. 		case 12:
  226. 			fomateDate = new SimpleDateFormat("yyyyMMddHHmm");
  227. 			break;
  228. 		case 14:
  229. 			fomateDate = new SimpleDateFormat("yyyyMMddHHmmss");
  230. 			break;
  231. 		}
  232. 		try {
  233. 			return getDateStr(fomateDate.parse(dateStr), formatStr);
  234. 		} catch (ParseException e) {
  235. 			return StringUtils.toVisualString(dateStr);
  236. 		}
  237. 	}
  238. 

  239. 	/**
  240. 	 * 时间字符格式化检验
  241. 	 * 
  242. 	 * @param dateStr
  243. 	 * @return
  244. 	
  245. 	 */
  246. 	private static boolean checkDateStr(String dateStr) {
  247. 		if (dateStr != null) {
  248. 			String dateStrCheck = dateStr.replaceAll("[^0-9]", "");
  249. 			if (dateStrCheck.length() >= 4 && dateStrCheck.length() <= 14 && dateStrCheck.length() % 2 == 0) {
  250. 				return true;
  251. 			}
  252. 		}
  253. 		return false;
  254. 	}
  255. 

  256. 	/** 获取当前日期字符串 yyyyMMdd */
  257. 	public static String getCurrentDate() {
  258. 		Date date = new Date();
  259. 		return getDateStr(date, DB_STORE_DATE_FMT);
  260. 	}
  261. 

  262. 	/** 获取当前日期+时间字符串 yyyyMMddHHmmss */
  263. 	public static String getCurrentTime() {
  264. 		Date date = new Date();
  265. 		return getDateStr(date, DB_STORE_DATE_FULL);
  266. 	}
  267. 

  268. 	/**
  269. 	 * 根据格式化类型将时间类型的数据格式化，并以字符串形式返回。
  270. 	 * 
  271. 	 * @param object
  272. 	 * @param formatType
  273. 	 * @return
  274. 	
  275. 	 */
  276. 	public static String getDateStr(Object object, String formatStr) {
  277. 		if (object == null) {
  278. 			return null;
  279. 		}
  280. 		String resultDateStr = null;
  281. 		if (object instanceof java.util.Date) {
  282. 			resultDateStr = getDateStr((Date) object, formatStr);
  283. 		} else if (object instanceof String) {
  284. 			String dateStr = (String) object;
  285. 			if (!checkDateStr(dateStr)) {
  286. 				return null;
  287. 			}
  288. 			resultDateStr = toDisplayStr(dateStr, formatStr);
  289. 		} else if (object instanceof Integer) {
  290. 			String dateStr = ((Integer) object).toString();
  291. 			if (!checkDateStr(dateStr)) {
  292. 				return null;
  293. 			}
  294. 			resultDateStr = toDisplayStr(dateStr, formatStr);
  295. 		}
  296. 		return resultDateStr;
  297. 	}
  298. 

  299. 	/**
  300. 	 * 根据格式化类型将时间类型的数据格式化，并以字符串形式返回。
  301. 	 * 
  302. 	 * @param object
  303. 	 * @param formatType
  304. 	 * @return
  305. 	
  306. 	 */
  307. 	public static String getDateStrByStr(String dateStr, int formatSliptType) {
  308. 		if (!checkDateStr(dateStr)) {
  309. 			return dateStr;
  310. 		}
  311. 		dateStr = dateStr.replaceAll("[^0-9]", "");
  312. 		String formateType = getFormatType(formatSliptType, dateStr.length());
  313. 		return toDisplayStr(dateStr, formateType);
  314. 	}
  315. 

  316. 	/**
  317. 	 * 转化Date类型
  318. 	 * 
  319. 	 * @param dateStr
  320. 	 * @return
  321. 	
  322. 	 */
  323. 	public static Date changeStrToDate(String dateStr) {
  324. 		if (!checkDateStr(dateStr)) {
  325. 			return null;
  326. 		}
  327. 		dateStr = dateStr.replaceAll("[^0-9]", "");
  328. 		String formatStr = getFormatType(DB_STORE_DATE_SPLIT, dateStr.length());
  329. 		SimpleDateFormat fomateDate = new SimpleDateFormat(formatStr);
  330. 		try {
  331. 			return fomateDate.parse(dateStr);
  332. 		} catch (ParseException e) {
  333. 			e.printStackTrace();
  334. 		}
  335. 		return null;
  336. 	}
  337. 

  338. 	/**
  339. 	 * 获取某个分钟之后的时间
  340. 	 * 
  341. 	 * @param dateStr
  342. 	 *            String 时间字符串
  343. 	 * @param later
  344. 	 *            long 分钟
  345. 	 * @return
  346. 	
  347. 	 */
  348. 	public static Date getLaterDate(String dateStr, long later) {
  349. 		Date date = changeStrToDate(dateStr);
  350. 		date.setTime(date.getTime() + later * 60 * 1000);
  351. 		return date;
  352. 	}
  353. 

  354. 	public static void convertDate(String datestr) {
  355. 		try {
  356. 			SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd HH时mm分ss秒");
  357. 			Date date = format.parse(datestr);
  358. 			System.out.println(date.toString());
  359. 		} catch (Exception ex) {
  360. 			ex.printStackTrace();
  361. 		}
  362. 

  363. 	}
  364. 

  365. 	/**
  366. 	 * 获取某个分钟之后的时间
  367. 	 * 
  368. 	 * @param date
  369. 	 *            Date 时间
  370. 	 * @param later
  371. 	 *            long 分钟
  372. 	 * @return
  373. 	
  374. 	 */
  375. 	public static Date getLaterDate(Date date, long later) {
  376. 		date.setTime(date.getTime() + later * 60 * 1000);
  377. 		return date;
  378. 	}
  379. 

  380. 	/**
  381. 	 * 获取某个分钟之后的时间字符串
  382. 	 * 
  383. 	 * @param dateStr
  384. 	 *            String 时间字符串
  385. 	 * @param later
  386. 	 *            int 分钟
  387. 	 * @param formatStr
  388. 	 *            String 格式化字符串类型
  389. 	 * @return
  390. 	
  391. 	 */
  392. 	public static String getLaterDateStr(String dateStr, long later, String formatStr) {
  393. 		Date date = getLaterDate(dateStr, later);
  394. 		return getDateStr(date, formatStr);
  395. 	}
  396. 

  397. 	/**
  398. 	 * 获取某个分钟之前的时间
  399. 	 * 
  400. 	 * @param dateStr
  401. 	 *            String 时间字符串
  402. 	 * @param later
  403. 	 *            long 分钟
  404. 	 * @return
  405. 	
  406. 	 */
  407. 	public static Date getBeforeDate(String dateStr, long later) {
  408. 		Date date = changeStrToDate(dateStr);
  409. 		date.setTime(date.getTime() - later * 60 * 1000);
  410. 		return date;
  411. 	}
  412. 

  413. 	/**
  414. 	 * 获取某个分钟之前的时间字符串
  415. 	 * 
  416. 	 * @param dateStr
  417. 	 *            String 时间字符串
  418. 	 * @param later
  419. 	 *            int 分钟
  420. 	 * @param formatStr
  421. 	 *            String 格式化字符串类型
  422. 	 * @return
  423. 	
  424. 	 */
  425. 	public static String getBeforeDateStr(String dateStr, long later, String formatStr) {
  426. 		Date date = getBeforeDate(dateStr, later);
  427. 		return getDateStr(date, formatStr);
  428. 	}
  429. 

  430. 	public static int getDaysBetween(Date date1, Date date2) {
  431. 		Calendar c1 = Calendar.getInstance();
  432. 		c1.setTime(date1);
  433. 		Calendar c2 = Calendar.getInstance();
  434. 		c2.setTime(date2);
  435. 		if (c1.after(c2)) {
  436. 			Calendar swap = c1;
  437. 			c1 = c2;
  438. 			c2 = swap;
  439. 		}
  440. 		int days = c2.get(Calendar.DAY_OF_YEAR) - c1.get(Calendar.DAY_OF_YEAR);
  441. 		int y2 = c2.get(Calendar.YEAR);
  442. 		if (c1.get(Calendar.YEAR) != y2) {
  443. 			c1 = (Calendar) c1.clone();
  444. 			do {
  445. 				days += c1.getActualMaximum(Calendar.DAY_OF_YEAR);
  446. 				c1.add(Calendar.YEAR, 1);
  447. 			} while (c1.get(Calendar.YEAR) != y2);
  448. 		}
  449. 		return days;
  450. 	}
  451. 

  452. 	public static long getHoursBetween(String startTime, String endTime, String format) {
  453. 		// 按照传入的格式生成一个simpledateformate对象
  454. 		SimpleDateFormat sd = new SimpleDateFormat(format);
  455. 		long nd = 1000 * 24 * 60 * 60;// 一天的毫秒数
  456. 		long nh = 1000 * 60 * 60;// 一小时的毫秒数
  457. 		long nm = 1000 * 60;// 一分钟的毫秒数
  458. 		long ns = 1000;// 一秒钟的毫秒数long diff;try {
  459. 		// 获得两个时间的毫秒时间差异
  460. 		try {
  461. 			Long diff = sd.parse(endTime).getTime() - sd.parse(startTime).getTime();
  462. 			long day = diff / nd;// 计算差多少天
  463. 			long hour = diff / nh;// 计算差多少小时
  464. 			long min = diff / nm;// 计算差多少分钟
  465. 			long sec = diff / ns;// 计算差多少秒//输出结果
  466. 			return hour;
  467. 		} catch (ParseException e) {
  468. 			e.printStackTrace();
  469. 		}
  470. 		return 0;
  471. 	}
  472. 

  473. 	/**
  474. 	 * 得到精确到秒的格式化当前时间串
  475. 	 * 
  476. 	 * @param formatType
  477. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  478. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  479. 	 * @return 当前时间格式化时间串
  480. 	 */
  481. 	public static String getCurrTimeStr(int formatType) {
  482. 		return getTimeStr(new Date(), formatType);
  483. 	}
  484. 

  485. 	/**
  486. 	 * 根据传入的OutFormat，DateStr进行格式化
  487. 	 * 
  488. 	 * @param DateStr
  489. 	 *            时间字符串,OutFormat输出格式字符串
  490. 	 * @return 根据格式字符串格式后的字符串类型
  491. 	 */
  492. 	public static String ToDisplayStrByFormarStr(String DateStr, String OutFormat) {
  493. 		OutFormat = OutFormat.trim();
  494. 		if (!"yyyyMMdd".equals(OutFormat) && !"yyyyMMddHHmmss".equals(OutFormat) && !"yyyy-MM-dd".equals(OutFormat) && !"yyyy-MM-dd HH:mm:ss".equals(OutFormat) && !"yyyy.MM.dd".equals(OutFormat) && !"yyyy.MM.dd HH:mm:ss".equals(OutFormat)
  495. 				&& !"yyyy年MM月dd日".equals(OutFormat) && !"yyyy年MM月dd日 HH:mm:ss".equals(OutFormat) && !"yyyy年MM月dd日 HH时mm分ss秒".equals(OutFormat)) {
  496. 			throw new IllegalArgumentException("时间格式化字符串不是合法的值。");
  497. 		} else {
  498. 			String formatStr = null;
  499. 			if ("yyyyMMdd".equals(OutFormat) || "yyyyMMddHHmmss".equals(OutFormat)) {
  500. 				formatStr = toDisplayStr(DateStr, DB_STORE_DATE);
  501. 			}
  502. 			if ("yyyy-MM-dd".equals(OutFormat) || "yyyy-MM-dd HH:mm:ss".equals(OutFormat)) {
  503. 				formatStr = toDisplayStr(DateStr, HYPHEN_DISPLAY_DATE);
  504. 			}
  505. 			if ("yyyy.MM.dd".equals(OutFormat) || "yyyy.MM.dd HH:mm:ss".equals(OutFormat)) {
  506. 				formatStr = toDisplayStr(DateStr, DOT_DISPLAY_DATE);
  507. 			}
  508. 			if ("yyyy年MM月dd日".equals(OutFormat) || "yyyy年MM月dd日 HH:mm:ss".equals(OutFormat) || "yyyy年MM月dd日 HH时mm分ss秒".equals(OutFormat)) {
  509. 				formatStr = toDisplayStr(DateStr, CN_DISPLAY_DATE);
  510. 			}
  511. 			return formatStr;
  512. 		}
  513. 	}
  514. 

  515. 	/**
  516. 	 * 得到精确到秒的格式化时间串
  517. 	 * 
  518. 	 * @param date
  519. 	 *            指定时间
  520. 	 * @param formatType
  521. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  522. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  523. 	 * @return 指定时间的格式化时间串
  524. 	 */
  525. 	public static String getTimeStr(Date date, int formatType) {
  526. 		if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
  527. 			throw new IllegalArgumentException("时间格式化类型不是合法的值。");
  528. 		} else {
  529. 			String formatStr = null;
  530. 			switch (formatType) {
  531. 			case DB_STORE_DATE:
  532. 				formatStr = "yyyyMMddHHmmss";
  533. 				break;
  534. 			case HYPHEN_DISPLAY_DATE:
  535. 				formatStr = "yyyy'-'MM'-'dd HH:mm:ss";
  536. 				break;
  537. 			case DOT_DISPLAY_DATE:
  538. 				formatStr = "yyyy.MM.dd HH:mm:ss";
  539. 				break;
  540. 			case CN_DISPLAY_DATE:
  541. 				formatStr = "yyyy'年'MM'月'dd HH:mm:ss";
  542. 				break;
  543. 			}
  544. 			SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
  545. 			return sdf.format(date);
  546. 		}
  547. 	}
  548. 

  549. 	/**
  550. 	 * 得到精确到天的当前格式化日期串
  551. 	 * 
  552. 	 * @param formatType
  553. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  554. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  555. 	 * @return
  556. 	 */
  557. 	public static String getCurrDateStr(int formatType) {
  558. 		return getDateStr(new Date(), formatType);
  559. 	}
  560. 

  561. 	/**
  562. 	 * 得到精确到天的指定时间格式化日期串
  563. 	 * 
  564. 	 * @param date
  565. 	 *            指定时间
  566. 	 * @param formatType
  567. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  568. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  569. 	 * @return 指定时间格式化日期串
  570. 	 */
  571. 	public static String getDateStr(Date date, int formatType) {
  572. 		if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
  573. 			throw new IllegalArgumentException("时间格式化类型不是合法的值。");
  574. 		} else {
  575. 			String formatStr = null;
  576. 			switch (formatType) {
  577. 			case DB_STORE_DATE:
  578. 				formatStr = "yyyyMMdd";
  579. 				break;
  580. 			case HYPHEN_DISPLAY_DATE:
  581. 				formatStr = "yyyy-MM-dd";
  582. 				break;
  583. 			case DOT_DISPLAY_DATE:
  584. 				formatStr = "yyyy.MM.dd";
  585. 				break;
  586. 			case CN_DISPLAY_DATE:
  587. 				formatStr = "yyyy'年'MM'月'dd";
  588. 				break;
  589. 			}
  590. 			SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
  591. 			return sdf.format(date);
  592. 		}
  593. 	}
  594. 

  595. 	/**
  596. 	 * 得到精确到月的当前时间格式化年月串
  597. 	 * 
  598. 	 * @param formatType
  599. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  600. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  601. 	 * @return 精确到月当前时间格式化年月串
  602. 	 */
  603. 	public static String getYearMonthStr(int formatType) {
  604. 		return getYearMonthStr(new Date(), formatType);
  605. 	}
  606. 

  607. 	/**
  608. 	 * 得到精确到月的指定时间格式化年月串
  609. 	 * 
  610. 	 * @param date
  611. 	 *            指定的时间
  612. 	 * @param formatType
  613. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  614. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  615. 	 * @return 精确到月当前时间格式化年月串
  616. 	 */
  617. 	public static String getYearMonthStr(Date date, int formatType) {
  618. 		if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
  619. 			throw new IllegalArgumentException("时间格式化类型不是合法的值。");
  620. 		} else {
  621. 			String formatStr = null;
  622. 			switch (formatType) {
  623. 			case DB_STORE_DATE:
  624. 				formatStr = "yyyyMM";
  625. 				break;
  626. 			case HYPHEN_DISPLAY_DATE:
  627. 				formatStr = "yyyy-MM";
  628. 				break;
  629. 			case DOT_DISPLAY_DATE:
  630. 				formatStr = "yyyy.MM";
  631. 				break;
  632. 			case CN_DISPLAY_DATE:
  633. 				formatStr = "yyyy'年'MM'月'";
  634. 				break;
  635. 			}
  636. 			SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
  637. 			return sdf.format(date);
  638. 		}
  639. 	}
  640. 

  641. 	/**
  642. 	 * 将数据库存储的日期格式串转换为各种显示的格式
  643. 	 * 
  644. 	 * @param dateStr
  645. 	 *            最小6位，最大14位的数据库存储格式时间串如:20041212
  646. 	 * @param formatType
  647. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  648. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  649. 	 * @return 格式化的时间串
  650. 	 */
  651. 	public static String toDisplayStr(String dateStr, int formatType) {
  652. 		if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
  653. 			throw new IllegalArgumentException("时间格式化类型不是合法的值。");
  654. 		}
  655. 		if (dateStr == null || dateStr.length() < 6 || formatType == DB_STORE_DATE) {
  656. 			return StringUtils.toVisualString(dateStr);
  657. 		} else {
  658. 			if (dateStr.length() > 14) {
  659. 				dateStr = StringUtils.substring(dateStr, 0, 14);
  660. 			}
  661. 			char[] charArr = null;
  662. 			switch (formatType) {
  663. 			case HYPHEN_DISPLAY_DATE:
  664. 				charArr = new char[] { '-', '-', ' ', ':', ':' };
  665. 				break;
  666. 			case DOT_DISPLAY_DATE:
  667. 				charArr = new char[] { '.', '.', ' ', ':', ':' };
  668. 				break;
  669. 			case CN_DISPLAY_DATE:
  670. 				charArr = new char[] { '年', '月', '日', ':', ':' };
  671. 				break;
  672. 			default:
  673. 				charArr = new char[] { '-', '-', ' ', ':', ':' };
  674. 			}
  675. 			try {
  676. 				SimpleDateFormat sdf_1 = null;
  677. 				SimpleDateFormat sdf_2 = null;
  678. 				switch (dateStr.length()) {
  679. 				case 6:
  680. 					sdf_1 = new SimpleDateFormat("yyyyMM");
  681. 					sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] + "'MM");
  682. 					break;
  683. 				case 8:
  684. 					sdf_1 = new SimpleDateFormat("yyyyMMdd");
  685. 					sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] + "'MM'" + charArr[1] + "'dd");
  686. 					break;
  687. 				case 10:
  688. 					sdf_1 = new SimpleDateFormat("yyyyMMddHH");
  689. 					sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] + "'MM'" + charArr[1] + "'dd'" + charArr[2] + "'HH");
  690. 					break;
  691. 				case 12:
  692. 					sdf_1 = new SimpleDateFormat("yyyyMMddHHmm");
  693. 					sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] + "'MM'" + charArr[1] + "'dd'" + charArr[2] + "'HH'" + charArr[3] + "'mm");
  694. 					break;
  695. 				case 14:
  696. 					sdf_1 = new SimpleDateFormat("yyyyMMddHHmmss");
  697. 					sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] + "'MM'" + charArr[1] + "'dd'" + charArr[2] + "'HH'" + charArr[3] + "'mm'" + charArr[4] + "'ss");
  698. 					break;
  699. 				case 17:
  700. 					sdf_1 = new SimpleDateFormat("yyyyMMddHHmmss");
  701. 					sdf_2 = new SimpleDateFormat("yyyy'" + charArr[0] + "'MM'" + charArr[1] + "'dd'" + charArr[2] + "'HH'" + charArr[3] + "'mm'" + charArr[4] + "'ss");
  702. 					break;
  703. 				default:
  704. 					return dateStr;
  705. 				}
  706. 				return sdf_2.format(sdf_1.parse(dateStr));
  707. 			} catch (ParseException ex) {
  708. 				return dateStr;
  709. 			}
  710. 		}
  711. 	}
  712. 

  713. 	/**
  714. 	 * 将数据库存储的日期格式串转换为各种显示的格式
  715. 	 * 
  716. 	 * @param dateStr
  717. 	 *            最小6位，最大14位的数据库存储格式时间串如:20041212
  718. 	 * @param formatType
  719. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  720. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  721. 	 * @return 格式化的时间串
  722. 	 */
  723. 	public static String toDisplayStrCn(String dateStr, int dateLen) {
  724. 		String formatdate = dateStr.replaceAll("/", "").replaceAll(":", "").replaceAll("-", "").trim();
  725. 		String temp_str = "";
  726. 		char[] c = formatdate.toCharArray();
  727. 		boolean bb = false;
  728. 		for (int j = 0; j < c.length; j++) {
  729. 			if (!Character.isDigit(c[j])) {
  730. 				bb = true;
  731. 				break;
  732. 			}
  733. 		}
  734. 		if (bb) {
  735. 			return dateStr;
  736. 		}
  737. 		formatdate = formatdate.replaceAll(" ", "");
  738. 		if (formatdate == null || "".equals(formatdate.trim()))
  739. 			return "";
  740. 		switch (dateLen) {
  741. 		case 4:
  742. 			if (formatdate.length() >= dateLen)
  743. 				temp_str = formatdate.substring(0, dateLen) + "年";
  744. 			else
  745. 				temp_str = formatdate.substring(0, formatdate.length()) + "年";
  746. 			break;
  747. 		case 6:
  748. 			if (formatdate.length() >= dateLen) {
  749. 				temp_str = formatdate.substring(0, 4) + "年";
  750. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  751. 			} else
  752. 				temp_str = formatdate.substring(0, formatdate.length()) + "年";
  753. 			break;
  754. 		case 8:
  755. 			if (formatdate.length() >= dateLen) {
  756. 				temp_str = formatdate.substring(0, 4) + "年";
  757. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  758. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(6, 8)) + "日";
  759. 			} else if (formatdate.length() >= 6) {
  760. 				temp_str = formatdate.substring(0, 4) + "年";
  761. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  762. 			} else {
  763. 				temp_str = formatdate.substring(0, formatdate.length()) + "年";
  764. 			}
  765. 			break;
  766. 		case 12:
  767. 			if (formatdate.length() >= dateLen) {
  768. 				temp_str = formatdate.substring(0, 4) + "年";
  769. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  770. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(6, 8)) + "日";
  771. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(8, 10)) + "时";
  772. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(10, 12)) + "分";
  773. 			} else if (formatdate.length() >= 10) {
  774. 				temp_str = formatdate.substring(0, 4) + "年";
  775. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  776. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(6, 8)) + "日";
  777. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(8, 10)) + "时";
  778. 			} else if (formatdate.length() >= 8) {
  779. 				temp_str = formatdate.substring(0, 4) + "年";
  780. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  781. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(6, 8)) + "日";
  782. 			} else if (formatdate.length() >= 6) {
  783. 				temp_str = formatdate.substring(0, 4) + "年";
  784. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  785. 			} else {
  786. 				temp_str = formatdate.substring(0, formatdate.length()) + "年";
  787. 			}
  788. 			break;
  789. 		case 14:
  790. 			if (formatdate.length() >= dateLen) {
  791. 				temp_str = formatdate.substring(0, 4) + "年";
  792. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  793. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(6, 8)) + "日";
  794. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(8, 10)) + "时";
  795. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(10, 12)) + "分";
  796. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(12, 14)) + "秒";
  797. 			} else if (formatdate.length() >= 12) {
  798. 				temp_str = formatdate.substring(0, 4) + "年";
  799. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  800. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(6, 8)) + "日";
  801. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(8, 10)) + "时";
  802. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(10, 12)) + "分";
  803. 			} else if (formatdate.length() >= 10) {
  804. 				temp_str = formatdate.substring(0, 4) + "年";
  805. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  806. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(6, 8)) + "日";
  807. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(8, 10)) + "时";
  808. 			} else if (formatdate.length() >= 8) {
  809. 				temp_str = formatdate.substring(0, 4) + "年";
  810. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  811. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(6, 8)) + "日";
  812. 			} else if (formatdate.length() >= 6) {
  813. 				temp_str = formatdate.substring(0, 4) + "年";
  814. 				temp_str = temp_str + Integer.valueOf(formatdate.substring(4, 6)) + "月";
  815. 			} else {
  816. 				temp_str = formatdate.substring(0, formatdate.length()) + "年";
  817. 			}
  818. 			break;
  819. 		default:
  820. 			return dateStr;
  821. 		}
  822. 		return temp_str;
  823. 	}
  824. 

  825. 	/**
  826. 	 * 将显示格式的时间字符串转换为数据库存储的类型
  827. 	 * 
  828. 	 * @param dateStr
  829. 	 *            最小4位，最大19位。显示的时间格式时间串如:2004-12-12
  830. 	 * @return 数据库存储的时间字符串
  831. 	 */
  832. 	public static String toStoreStr(String dateStr) {
  833. 		if (dateStr == null || dateStr.trim().equals("")) {
  834. 			return "";
  835. 		}
  836. 		StringBuffer strBuf = new StringBuffer();
  837. 		for (int i = 0; i < dateStr.length(); i++) {
  838. 			if (dateStr.charAt(i) >= '0' && dateStr.charAt(i) <= '9') {
  839. 				strBuf.append(dateStr.charAt(i));
  840. 			}
  841. 		}
  842. 		return strBuf.toString();
  843. 	}
  844. 

  845. 	/**
  846. 	 * 将生日存储的时间格式转化为年龄（周岁，小数点后不计）
  847. 	 * 
  848. 	 * @param birthdayStr
  849. 	 *            生日字段 "yyyymmdd"
  850. 	 * @return 年龄
  851. 	 */
  852. 	public static String birthdayToAge(String birthdayStr) {
  853. 		if (birthdayStr == null || birthdayStr.length() < 6) {
  854. 			return "";
  855. 		} else {
  856. 			int birthYear = Integer.parseInt(birthdayStr.substring(0, 4));
  857. 			int birthMonth = Integer.parseInt(birthdayStr.substring(4, 6));
  858. 			Calendar cal = new GregorianCalendar();
  859. 			int currYear = cal.get(Calendar.YEAR);
  860. 			int currMonth = cal.get(Calendar.MONTH)+1;
  861. 			int age = currYear - birthYear;
  862. 			age -= (currMonth < birthMonth) ? 1 : 0;
  863. 			return "" + age;
  864. 		}
  865. 	}
  866. 

  867. 	/**
  868. 	 * 将生日存储的时间格式转化为年龄（周岁，小数点后不计）
  869. 	 * 
  870. 	 * @param birthdayStr
  871. 	 *            生日字段 "yyyy-MM-dd"
  872. 	 * @return 年龄
  873. 	 */
  874. 	public static String birthdayToAge2(String birthdayStr) {
  875. 		if (birthdayStr == null || birthdayStr.length() < 8) {
  876. 			return "";
  877. 		} else {
  878. 			Calendar cal2 = new GregorianCalendar();
  879. 			cal2.setTime(getDate(birthdayStr, "yyyy-MM-dd"));
  880. 			int birthYear = Integer.parseInt(birthdayStr.substring(0, 4));
  881. 			Calendar cal = new GregorianCalendar();
  882. 			int currYear = cal.get(Calendar.YEAR);
  883. 			int age = currYear - birthYear;
  884. 			cal2.add(Calendar.YEAR, age);
  885. 			if (cal.getTimeInMillis() < cal2.getTimeInMillis()) {
  886. 				age = age - 1;
  887. 			}
  888. 			if (age < 0) {
  889. 				age = 0;
  890. 			}
  891. 			return "" + age;
  892. 		}
  893. 	}
  894. 

  895. 	/**
  896. 	 * @param dateTimeStr
  897. 	 *            String 格式化的时间串
  898. 	 * @param formatType
  899. 	 *            数据格式类型 {@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  900. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  901. 	 * @param detal
  902. 	 *            int 增加或减少的时间
  903. 	 * @param field
  904. 	 *            int 参见Calendar中关于时间字段属性的定义
  905. 	 * @return String 返回的
  906. 	 */
  907. 	public static String add(String dateTimeStr, int formatType, int detal, int field) {
  908. 		if (dateTimeStr == null || dateTimeStr.length() < 6) {
  909. 			return dateTimeStr;
  910. 		} else {
  911. 			try {
  912. 				String formatStr = null;
  913. 				switch (formatType) {
  914. 				case DB_STORE_DATE:
  915. 					formatStr = "yyyyMMddHHmmss";
  916. 					break;
  917. 				case HYPHEN_DISPLAY_DATE:
  918. 					formatStr = "yyyy-MM-dd HH:mm:ss";
  919. 					break;
  920. 				case DOT_DISPLAY_DATE:
  921. 					formatStr = "yyyy.MM.dd HH:mm:ss";
  922. 					break;
  923. 				case CN_DISPLAY_DATE:
  924. 					formatStr = "yyyy'年'MM'月' HH：mm：ss";
  925. 					break;
  926. 				default:
  927. 					formatStr = "yyyyMMddHHmmss";
  928. 					break;
  929. 				}
  930. 

  931. 				formatStr = formatStr.substring(0, dateTimeStr.length());
  932. 				SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
  933. 				Date d = sdf.parse(dateTimeStr);
  934. 				GregorianCalendar g = new GregorianCalendar();
  935. 				g.setTime(d);
  936. 				g.add(field, detal);
  937. 				d = g.getTime();
  938. 				return sdf.format(d);
  939. 			} catch (ParseException ex) {
  940. 				ex.printStackTrace();
  941. 				return dateTimeStr;
  942. 			}
  943. 		}
  944. 	}
  945. 

  946. 	// /**
  947. 	// * @param date Date 时间
  948. 	// * @param detal int 增加的时间
  949. 	// * @param field int 参见Calendar中关于时间字段属性的定义
  950. 	// * @return Date
  951. 	// */
  952. 	// public static Date add(Date date, int detal, int field)
  953. 	// {
  954. 	// Calendar g = new GregorianCalendar();
  955. 	// g.setTime(date);
  956. 	// g.add(field, detal);
  957. 	// return g.getTime();
  958. 	// }
  959. 	/**
  960. 	 * 日期、时间格式化
  961. 	 * 
  962. 	 * @param date
  963. 	 *            Date 将要被格式化的日期对象
  964. 	 * @param outFmt
  965. 	 *            String 返回样式，参照类说明，如：yyyy年MM月dd日
  966. 	 * @return String 格式化后的日期、时间字符串，data为null时返回null，outFmt非法时返回yyyyMMdd格式
  967. 	 */
  968. 	public static String getDateFormat(Date date, String outFmt) {
  969. 		if (null == date) {
  970. 			return null;
  971. 		}
  972. 		if (null == outFmt || "".equals(outFmt.trim())) { // outFmt非法
  973. 			outFmt = "yyyyMMdd";
  974. 		}
  975. 

  976. 		String retu = null;
  977. 		SimpleDateFormat dateFormat = null;
  978. 		try {
  979. 			dateFormat = new SimpleDateFormat(outFmt);
  980. 		} catch (IllegalArgumentException iaex) { // outFmt非法
  981. 			dateFormat = new SimpleDateFormat("yyyyMMdd");
  982. 		}
  983. 		retu = dateFormat.format(date);
  984. 

  985. 		dateFormat = null;
  986. 

  987. 		return retu;
  988. 	}
  989. 

  990. 	/**
  991. 	 * 把日期时间对象格式化为yyyyMMdd样式
  992. 	 * 
  993. 	 * @param date
  994. 	 *            Date 将要被格式化的日期对象
  995. 	 * @return String 格式化后的日期、时间字符串，如：20041001
  996. 	 */
  997. 	public static String getDateFormat(Date date) {
  998. 		return getDateFormat(date, "yyyyMMdd");
  999. 	}
  1000. 

  1001. 	/**
  1002. 	 * 把系统当前日期时间格式化为指定的样式
  1003. 	 * 
  1004. 	 * @param outFmt
  1005. 	 *            String 返回样式，参照类说明，如：yyyy年MM月dd日
  1006. 	 * @return String 格式化后的日期、时间字符串，如：2004年10月01日
  1007. 	 */
  1008. 	public static String getDateFormat(String outFmt) {
  1009. 		return getDateFormat(new Date(), outFmt);
  1010. 	}
  1011. 

  1012. 	/**
  1013. 	 * 把系统当前日期时间格式化为默认样式yyyyMMdd
  1014. 	 * 
  1015. 	 * @return String 格式化后的日期、时间字符串，如：20041001
  1016. 	 */
  1017. 	public static String getDateFormat() {
  1018. 		return getDateFormat(new Date(), "yyyyMMdd");
  1019. 	}
  1020. 

  1021. 	/**
  1022. 	 * 日期、时间格式化
  1023. 	 * 
  1024. 	 * @param millis
  1025. 	 *            long the number of milliseconds（毫秒） since January 1, 1970,
  1026. 	 *            00:00:00 GMT.
  1027. 	 * @param outFmt
  1028. 	 *            String 返回样式，参照类说明，如：yyyy年MM月dd日
  1029. 	 * @return String 格式化后的日期、时间字符串
  1030. 	 */
  1031. 	public static String getDateFormat(long millis, String outFmt) {
  1032. 		Calendar calendar = Calendar.getInstance();
  1033. 		calendar.setTimeInMillis(millis);
  1034. 

  1035. 		String retu = getDateFormat(calendar.getTime(), outFmt);
  1036. 		calendar = null;
  1037. 		return retu;
  1038. 	}
  1039. 

  1040. 	/**
  1041. 	 * 日期、时间格式化
  1042. 	 * 
  1043. 	 * @param datestr
  1044. 	 *            String 存在一定格式的日期、时间字符串，如：20041001、200410011503
  1045. 	 * @param inFmt
  1046. 	 *            String 对datestr参数格式说明，参照类说明，如：yyyyMMdd、yyyyMMddHHmm
  1047. 	 * @param outFmt
  1048. 	 *            String 返回样式，参照类说明，如：yyyy年MM月dd日
  1049. 	 * @throws ParseException
  1050. 	 *             当datestr不能格式化为inFmt格式时抛出此异常
  1051. 	 * @return String 格式化后的日期、时间字符串，如：2004年10月01日、2004年10月01日 <BR>
  1052. 	 *         输出样式outFmt非法时，使用yyyyMMdd格式输出
  1053. 	 */
  1054. 	public static String getDateFormat(String datestr, String inFmt, String outFmt) throws ParseException {
  1055. 		if (null == datestr || "".equals(datestr.trim())) {
  1056. 			return datestr;
  1057. 		}
  1058. 

  1059. 		if (null == inFmt || "".equals(inFmt.trim())) {
  1060. 			return datestr;
  1061. 		}
  1062. 

  1063. 		if (null == outFmt || "".equals(outFmt.trim())) { // 输出样式非法
  1064. 			outFmt = "yyyyMMdd";
  1065. 		}
  1066. 

  1067. 		java.util.Date inDate = getDate(datestr, inFmt);
  1068. 

  1069. 		if (null == inDate) { // 根据inFmt分析datestr时抛出异常
  1070. 			return datestr;
  1071. 		}
  1072. 

  1073. 		String retu = getDateFormat(inDate, outFmt);
  1074. 		inDate = null;
  1075. 		return retu;
  1076. 	}
  1077. 

  1078. 	/**
  1079. 	 * 把日期时间字符串，按inFmt样式转化为日期对象，然后格式化为默认样式yyyyMMdd
  1080. 	 * 
  1081. 	 * @param datestr
  1082. 	 *            String 存在一定格式的日期、时间字符串，如：20041001、200410011503
  1083. 	 * @param inFmt
  1084. 	 *            String 对datestr参数格式说明，参照类说明，如：yyyyMMdd、yyyyMMddHHmm
  1085. 	 * @throws ParseException
  1086. 	 *             当datestr不能格式化为inFmt格式时抛出此异常
  1087. 	 * @return String 格式化后的日期、时间字符串，如：20041001、20041001
  1088. 	 */
  1089. 	public static String getDateFormat(String datestr, String inFmt) throws ParseException {
  1090. 		return getDateFormat(datestr, inFmt, "yyyyMMdd");
  1091. 	}
  1092. 

  1093. 	/**
  1094. 	 * 根据inFmt的样式，日期时间字符串转化为日期时间对象
  1095. 	 * 
  1096. 	 * @param datestr
  1097. 	 *            String 日期时间字符串，如：20041001、2004年10月01日 15:03
  1098. 	 * @param inFmt
  1099. 	 *            String 对datestr参数格式说明，参照类说明，如yyyyMMdd、yyyy年MM月dd日 HH:mm
  1100. 	 * @return Date 日期时间对象，格式inFmt非法时，使用yyyyMMdd格式
  1101. 	 */
  1102. 	public static Date getDate(String datestr, String inFmt) {
  1103. 		if (null == datestr || "".equals(datestr.trim())) {
  1104. 			return null;
  1105. 		}
  1106. 

  1107. 		if (null == inFmt || "".equals(inFmt.trim())) { // inFmt非法
  1108. 			inFmt = "yyyyMMdd";
  1109. 		}
  1110. 

  1111. 		java.util.Date inDate = null;
  1112. 

  1113. 		// 依据inFmt格式把日期字符串转化为日期对象
  1114. 		SimpleDateFormat inDateFormat = new SimpleDateFormat(inFmt);
  1115. 		inDateFormat.setLenient(true);
  1116. 		try {
  1117. 			inDate = inDateFormat.parse(datestr);
  1118. 		} catch (ParseException e) {
  1119. 			logger.error("日期转换出错：" + datestr,e);
  1120. 		}
  1121. 		return inDate;
  1122. 	}
  1123. 

  1124. 	/**
  1125. 	 * 对日期时间对象进行调整，实现如昨天是几号，去年的今天星期几等. <BR>
  1126. 	 * 例子：
  1127. 	 * 
  1128. 	 * <pre>
  1129. 	 * &lt;blockquote&gt;
  1130. 	 * 计算去年今天星期几
  1131. 	 * Date date = DateUtils.addDate(new Date(),Calendar.YEAR,-1);
  1132. 	 * System.out.println(DateUtils.getDateFormat(date,&quot;E&quot;));
  1133. 	 * 打印60天后是什么日期，并显示为 yyyy-MM-dd 星期
  1134. 	 * Date date = DateUtils.addDate(new Date(),Calendar.DATE,60);
  1135. 	 * System.out.println(DateUtils.getDateFormat(date,&quot;yyyy-MM-dd E&quot;));
  1136. 	 * &lt;/blockquote&gt;
  1137. 	 * </pre>
  1138. 	 * 
  1139. 	 * @param date
  1140. 	 *            Date 需要调整的日期时间对象
  1141. 	 * @param CALENDARFIELD
  1142. 	 *            int 对日期时间对象以什么单位进行调整：
  1143. 	 * 
  1144. 	 *            <pre>
  1145. 	 * &lt;blockquote&gt;
  1146. 	 * 年 Calendar.YEAR
  1147. 	 * 月 Calendar.MONTH
  1148. 	 * 日 Calendar.DATE
  1149. 	 * 时 Calendar.HOUR
  1150. 	 * 分 Calendar.MINUTE
  1151. 	 * 秒 Calendar.SECOND
  1152. 	 * &lt;/blockquote&gt;
  1153. 	 * </pre>
  1154. 	 * 
  1155. 	 * @param amount
  1156. 	 *            int 调整数量，>0表向后调整（明天，明年），<0表向前调整（昨天，去年）
  1157. 	 * @return Date 调整后的日期时间对象
  1158. 	 */
  1159. 	public static Date addDate(Date date, int CALENDARFIELD, int amount) {
  1160. 		if (null == date) {
  1161. 			return date;
  1162. 		}
  1163. 		Calendar calendar = Calendar.getInstance();
  1164. 		calendar.setTime(date);
  1165. 		calendar.add(CALENDARFIELD, amount);
  1166. 		return calendar.getTime();
  1167. 	}
  1168. 

  1169. 	/**
  1170. 	 * 对日期时间对象进行调整.
  1171. 	 * 
  1172. 	 * @param datestr
  1173. 	 *            String 需要调整的日期时间字符串，它的格式为yyyyMMdd
  1174. 	 * @param CALENDARFIELD
  1175. 	 *            int 对日期时间对象以什么单位进行调整
  1176. 	 * @param amount
  1177. 	 *            int 调整数量
  1178. 	 * @throws ParseException
  1179. 	 *             当datestr不能格式化为yyyyMMdd格式时抛出此异常
  1180. 	 * @return Date 调整后的日期时间对象
  1181. 	 * @see #addDate(java.util.Date, int, int)
  1182. 	 */
  1183. 	public static Date addDate(String datestr, int CALENDARFIELD, int amount) throws ParseException {
  1184. 		return addDate(getDate(datestr, "yyyyMMdd"), CALENDARFIELD, amount);
  1185. 	}
  1186. 

  1187. 	/**
  1188. 	 * 对日期时间对象进行调整.
  1189. 	 * 
  1190. 	 * @param datestr
  1191. 	 *            String 需要调整的日期时间字符串，它的格式为yyyyMMdd
  1192. 	 * @param CALENDARFIELD
  1193. 	 *            int 对日期时间对象以什么单位进行调整
  1194. 	 * @param amount
  1195. 	 *            int 调整数量
  1196. 	 * @throws ParseException
  1197. 	 *             当datestr不能格式化为yyyyMMdd格式时抛出此异常
  1198. 	 * @return Date 调整后的日期时间对象
  1199. 	 * @see #addDate(java.util.Date, int, int)
  1200. 	 */
  1201. 	public static Date addDate(String datestr, String fmt, int CALENDARFIELD, int amount) throws ParseException {
  1202. 		return addDate(getDate(datestr, fmt), CALENDARFIELD, amount);
  1203. 	}
  1204. 

  1205. 	/**
  1206. 	 * 根据出生日期，计算出在某一个日期的年龄
  1207. 	 * 
  1208. 	 * @param birthday
  1209. 	 *            Date 出生日期时间对象
  1210. 	 * @param date2
  1211. 	 *            Date 计算日期对象
  1212. 	 * @return int 返回date2那一天出生日期为birthday的年龄，如果birthday大于date2则返回-1
  1213. 	 */
  1214. 	public static int getAge(Date birthday, Date date2) {
  1215. 		if (null == birthday || null == date2) {
  1216. 			return -1;
  1217. 		}
  1218. 

  1219. 		if (birthday.after(date2)) { // birthday大于date2
  1220. 			return -1;
  1221. 		}
  1222. 

  1223. 		int ibdYear = StringUtils.getInt(getDateFormat(birthday, "yyyy"), -1);
  1224. 		int idate2Year = StringUtils.getInt(getDateFormat(date2, "yyyy"), -1);
  1225. 

  1226. 		if (ibdYear < 0 || idate2Year < 0) {
  1227. 			return -1;
  1228. 		}
  1229. 		if (ibdYear > idate2Year) {
  1230. 			return -1;
  1231. 		}
  1232. 

  1233. 		return idate2Year - ibdYear + 1;
  1234. 	}
  1235. 

  1236. 	/**
  1237. 	 * 根据出生日期，计算出当前的年龄
  1238. 	 * 
  1239. 	 * @param birthday
  1240. 	 *            Date 出生日期时间对象
  1241. 	 * @return int 返回出生日期为birthday的年龄，如果birthday大于当前系统日期则返回-1
  1242. 	 */
  1243. 	public static int getAge(Date birthday) {
  1244. 		return getAge(birthday, new Date());
  1245. 	}
  1246. 

  1247. 	/**
  1248. 	 * 根据出生日期，计算出当前的年龄
  1249. 	 * 
  1250. 	 * @param birthdaystr
  1251. 	 *            String 出生日期时间字符串，其格式一定为yyyyMMdd
  1252. 	 * @throws ParseException
  1253. 	 *             当datestr不能格式化为yyyyMMdd格式时抛出此异常
  1254. 	 * @return int 返回出生日期为birthday的年龄，如果birthday大于当前系统日期则返回-1
  1255. 	 */
  1256. 	public static int getAge(String birthdaystr) throws ParseException {
  1257. 		return getAge(getDate(birthdaystr, "yyyyMMdd"));
  1258. 	}
  1259. 

  1260. 	/**
  1261. 	 * 得到14位的当前格式化时间
  1262. 	 * 
  1263. 	 * @param formatType
  1264. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  1265. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  1266. 	 * @return java.lang.String
  1267. 	 */
  1268. 	public static String getCurrTime(int formatType) {
  1269. 		if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
  1270. 			throw new IllegalArgumentException("时间格式化类型不是合法的值。");
  1271. 		} else {
  1272. 			String formatStr = null;
  1273. 			switch (formatType) {
  1274. 			case DB_STORE_DATE:
  1275. 				formatStr = "yyyyMMddHHmmss";
  1276. 				break;
  1277. 			case HYPHEN_DISPLAY_DATE:
  1278. 				formatStr = "yyyy'-'MM'-'dd HH:mm:ss";
  1279. 				break;
  1280. 			case DOT_DISPLAY_DATE:
  1281. 				formatStr = "yyyy.MM.dd HH:mm:ss";
  1282. 				break;
  1283. 			case CN_DISPLAY_DATE:
  1284. 				formatStr = "yyyy'年'MM'月'dd'日' HH时mm分ss秒";
  1285. 				break;
  1286. 			}
  1287. 			SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
  1288. 			return sdf.format(new Date());
  1289. 		}
  1290. 	}
  1291. 

  1292. 	/**
  1293. 	 * 得到8位的当前格式化日期
  1294. 	 * 
  1295. 	 * @param formatType
  1296. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  1297. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  1298. 	 * @return java.lang.String
  1299. 	 */
  1300. 	public static String getCurrDate(int formatType) {
  1301. 		if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
  1302. 			throw new IllegalArgumentException("时间格式化类型不是合法的值。");
  1303. 		} else {
  1304. 			String formatStr = null;
  1305. 			switch (formatType) {
  1306. 			case DB_STORE_DATE:
  1307. 				formatStr = "yyyyMMdd";
  1308. 				break;
  1309. 			case HYPHEN_DISPLAY_DATE:
  1310. 				formatStr = "yyyy-MM-dd";
  1311. 				break;
  1312. 			case DOT_DISPLAY_DATE:
  1313. 				formatStr = "yyyy.MM.dd";
  1314. 				break;
  1315. 			case CN_DISPLAY_DATE:
  1316. 				formatStr = "yyyy'年'MM'月'dd'日'";
  1317. 				break;
  1318. 			}
  1319. 			SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
  1320. 			return sdf.format(new Date());
  1321. 		}
  1322. 	}
  1323. 

  1324. 	/**
  1325. 	 * 得到6位的当前格式化年月
  1326. 	 * 
  1327. 	 * @param formatType
  1328. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  1329. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  1330. 	 * @return java.lang.String
  1331. 	 */
  1332. 	public static String getYearMonth(int formatType) {
  1333. 		if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
  1334. 			throw new IllegalArgumentException("时间格式化类型不是合法的值。");
  1335. 		} else {
  1336. 			String formatStr = null;
  1337. 			switch (formatType) {
  1338. 			case DB_STORE_DATE:
  1339. 				formatStr = "yyyyMM";
  1340. 				break;
  1341. 			case HYPHEN_DISPLAY_DATE:
  1342. 				formatStr = "yyyy-MM";
  1343. 				break;
  1344. 			case DOT_DISPLAY_DATE:
  1345. 				formatStr = "yyyy.MM";
  1346. 				break;
  1347. 			case CN_DISPLAY_DATE:
  1348. 				formatStr = "yyyy'年'MM'月'";
  1349. 				break;
  1350. 			}
  1351. 			SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
  1352. 			return sdf.format(new Date());
  1353. 		}
  1354. 	}
  1355. 

  1356. 	/**
  1357. 	 * 得到6位的上月格式化年月
  1358. 	 * 
  1359. 	 * @param formatType
  1360. 	 *            时间格式的类型{@link #DB_STORE_DATE}, {@link #EN_HTML_DISPLAY_DATE},
  1361. 	 *            {@link #CN_HTML_DISPLAY_DATE}
  1362. 	 * @return java.lang.String
  1363. 	 */
  1364. 	public static String getLastYearMonth(int formatType) {
  1365. 		if (formatType < DB_STORE_DATE || formatType > CN_DISPLAY_DATE) {
  1366. 			throw new IllegalArgumentException("时间格式化类型不是合法的值。");
  1367. 		} else {
  1368. 			String formatStr = null;
  1369. 			switch (formatType) {
  1370. 			case DB_STORE_DATE:
  1371. 				formatStr = "yyyyMM";
  1372. 				break;
  1373. 			case HYPHEN_DISPLAY_DATE:
  1374. 				formatStr = "yyyy-MM";
  1375. 				break;
  1376. 			case DOT_DISPLAY_DATE:
  1377. 				formatStr = "yyyy.MM";
  1378. 				break;
  1379. 			case CN_DISPLAY_DATE:
  1380. 				formatStr = "yyyy'年'MM'月'";
  1381. 				break;
  1382. 			}
  1383. 			SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
  1384. 			Calendar cal = Calendar.getInstance();
  1385. 			Date date = new Date();
  1386. 			cal.setTime(date);
  1387. 			cal.set(Calendar.DATE, 1);
  1388. 			cal.add(Calendar.MONTH, -1);
  1389. 			return sdf.format(cal.getTime());
  1390. 		}
  1391. 	}
  1392. 

  1393. 	/**
  1394. 	 * 获取时间所对应的毫秒
  1395. 	 * 
  1396. 	 * @param datetime
  1397. 	 *            String 时间字符串
  1398. 	 * @param inFmt
  1399. 	 *            String 时间格式化串
  1400. 	 * @return long 毫秒数
  1401. 	 * @throws ParseException
  1402. 	 */
  1403. 	public static long getTimeValue(String datetime, String inFmt) throws ParseException {
  1404. 		return getDate(datetime, inFmt).getTime();
  1405. 	}
  1406. 

  1407. 	/**
  1408. 	 * 获取时间字符串
  1409. 	 * 
  1410. 	 * @param milliSeconds
  1411. 	 *            long 从1970年到现在的毫
  1412. 	 * @param formatType
  1413. 	 *            int 时间类型
  1414. 	 * @return String 时间字符串
  1415. 	 */
  1416. 	public static String getTimeStr(long milliSeconds, int formatType) {
  1417. 		Date d = new Date(milliSeconds);
  1418. 		return getTimeStr(d, formatType);
  1419. 	}
  1420. 

  1421. 	/**
  1422. 	 * 对日期时间对象进行调整
  1423. 	 * 
  1424. 	 * @param date
  1425. 	 * @param CALENDARFIELD
  1426. 	 * 
  1427. 	 *            <pre>
  1428. 	 * 年 Calendar.YEAR
  1429. 	 * 月 Calendar.MONTH
  1430. 	 * 日 Calendar.DATE
  1431. 	 * 时 Calendar.HOUR
  1432. 	 * 分 Calendar.MINUTE
  1433. 	 * 秒 Calendar.SECOND
  1434. 	 * </pre>
  1435. 	 * 
  1436. 	 * @param amount
  1437. 	 *            调整数量，>0表向后调整（明天，明年），<0表向前调整（昨天，去年）
  1438. 	 * @return
  1439. 	
  1440. 	 */
  1441. 	public static Date transpositionDate(String dateStr, int CALENDARFIELD, int amount) {
  1442. 		if (null == dateStr) {
  1443. 			return null;
  1444. 		}
  1445. 		return transpositionDate(changeStrToDate(dateStr), CALENDARFIELD, amount);
  1446. 	}
  1447. 

  1448. 	/**
  1449. 	 * 对日期时间对象进行调整
  1450. 	 * 
  1451. 	 * @param date
  1452. 	 * @param CALENDARFIELD
  1453. 	 * 
  1454. 	 *            <pre>
  1455. 	 * 年 Calendar.YEAR
  1456. 	 * 月 Calendar.MONTH
  1457. 	 * 日 Calendar.DATE
  1458. 	 * 时 Calendar.HOUR
  1459. 	 * 分 Calendar.MINUTE
  1460. 	 * 秒 Calendar.SECOND
  1461. 	 * </pre>
  1462. 	 * 
  1463. 	 * @param amount
  1464. 	 *            调整数量，>0表向后调整（明天，明年），<0表向前调整（昨天，去年）
  1465. 	 * @return
  1466. 	
  1467. 	 */
  1468. 	public static Date transpositionDate(Date date, int CALENDARFIELD, int amount) {
  1469. 		if (null == date) {
  1470. 			return date;
  1471. 		}
  1472. 		Calendar calendar = Calendar.getInstance();
  1473. 		calendar.setTime(date);
  1474. 		calendar.add(CALENDARFIELD, amount);
  1475. 		return calendar.getTime();
  1476. 	}
  1477. 

  1478. 	/**
  1479. 	 * 对日期时间对象进行调整
  1480. 	 * 
  1481. 	 * @param date
  1482. 	 * @param CALENDARFIELD
  1483. 	 * 
  1484. 	 *            <pre>
  1485. 	 * 年 Calendar.YEAR
  1486. 	 * 月 Calendar.MONTH
  1487. 	 * 日 Calendar.DATE
  1488. 	 * 时 Calendar.HOUR
  1489. 	 * 分 Calendar.MINUTE
  1490. 	 * 秒 Calendar.SECOND
  1491. 	 * </pre>
  1492. 	 * 
  1493. 	 * @param amount
  1494. 	 *            调整数量，>0表向后调整（明天，明年），<0表向前调整（昨天，去年）
  1495. 	 * @return
  1496. 	
  1497. 	 */
  1498. 	public static String transpositionDateStr(String dateStr, int CALENDARFIELD, int amount) {
  1499. 		if (null == dateStr) {
  1500. 			return dateStr;
  1501. 		}
  1502. 		return changeDateToStr(transpositionDate(dateStr, CALENDARFIELD, amount), DB_STORE_DATE_FULL);
  1503. 	}
  1504. 

  1505. 	/**
  1506. 	 * 得到格式化时间串
  1507. 	 * 
  1508. 	 * @param date
  1509. 	 *            指定时间
  1510. 	 * @param formatType
  1511. 	 *            时间格式的类型
  1512. 	 * @return 指定时间的格式化时间串
  1513. 	 */
  1514. 	public static String changeDateToStr(Date date, String formatStr) {
  1515. 		SimpleDateFormat fomate = new SimpleDateFormat(formatStr);
  1516. 		return fomate.format(date);
  1517. 	}
  1518. 

  1519. 	/**
  1520. 	 * 根据时间跨距，取得对应的行政月。例如：9-26到10-26 返回的月份为10月
  1521. 	 * 
  1522. 	 * @day 从那天开始(例如：26)
  1523. 	 * @format 时间格式的类型：YYMMDD、YYMMDDHHmMSS
  1524. 	 * @return 指定的格式化时间
  1525. 	 */
  1526. 	public static String getStrationTime(int day, String formatStr) {
  1527. 		Calendar cal = Calendar.getInstance();
  1528. 		Date date = cal.getTime();
  1529. 		Calendar g = new GregorianCalendar();
  1530. 		g.setTime(date);
  1531. 		if (cal.get(Calendar.DATE) > day) {
  1532. 			g.add(Calendar.MONTH, 1);
  1533. 		}
  1534. 		Date d = g.getTime();
  1535. 		return getDateStr(d, formatStr);
  1536. 	}
  1537. 

  1538. 	/**
  1539. 	 * 计算两个任意日期间的相差的天数（自然天）
  1540. 	 * 
  1541. 	 * @param fromDay
  1542. 	 *            起始日期
  1543. 	 * @param toDay
  1544. 	 *            终止日期
  1545. 	 * @return 两日期间的相差的天数 (NullPointerException if fromDay or toDay is null) <br>
  1546. 	 *         注：fromDay 可以大于 toDay
  1547. 	
  1548. 	 */
  1549. 	public static int daysBetween(Date fromDay, Date toDay) {
  1550. 		int result = -1;
  1551. 		if (fromDay != null && toDay != null) {
  1552. 			fromDay = getFirstTime(fromDay);
  1553. 			toDay = getFirstTime(toDay);
  1554. 			long off = fromDay.getTime() - toDay.getTime(); // 毫秒数差值
  1555. 			result = (int) ((Math.abs(off)) / 1000 / 60 / 60 / 24); // 获取天数的差值
  1556. 		}
  1557. 		return result;
  1558. 	}
  1559. 

  1560. 	/**
  1561. 	 * 取得当天0点整时刻的日期值
  1562. 	 * 
  1563. 	 * @parm srcDate 日期
  1564. 	 * @return 00:00:00:000时刻的日期 如: 输入日期 2009-5-7 11:29:56:101,则输出2009-5-7
  1565. 	 *         00:00:00:000
  1566. 	
  1567. 	 */
  1568. 	public static Date getFirstTime(Date srcDate) {
  1569. 		Calendar calendar = Calendar.getInstance();
  1570. 		calendar.setTime(srcDate);
  1571. 		calendar.set(Calendar.HOUR_OF_DAY, 0);
  1572. 		calendar.set(Calendar.MINUTE, 0);
  1573. 		calendar.set(Calendar.SECOND, 0);
  1574. 		calendar.set(Calendar.MILLISECOND, 0);
  1575. 		return calendar.getTime();
  1576. 	}
  1577. 

  1578. 	/**
  1579. 	 * 取得两个日期间的所有日期(不包括toDate)
  1580. 	 * 
  1581. 	 * @param fromDate
  1582. 	 *            起始日期
  1583. 	 * @param toDate
  1584. 	 *            终止日期
  1585. 	 * @return 两个日期间的所有日期(0点时该的值)，不包括终止日期，从小到大的顺序
  1586. 

  1587. 	 */
  1588. 	public static Date[] datesBetween(Date fromDate, Date toDate) {
  1589. 		Date from = getFirstTime(fromDate);
  1590. 		Date to = getFirstTime(toDate);
  1591. 		int days = daysBetween(from, to);
  1592. 		Date[] dates = new Date[days];
  1593. 		for (int i = 0; i < days; i++) {
  1594. 			Calendar calendar = Calendar.getInstance();
  1595. 			calendar.setTime(from);
  1596. 			calendar.add(Calendar.DAY_OF_MONTH, i);
  1597. 			dates[i] = calendar.getTime();
  1598. 		}
  1599. 		return dates;
  1600. 	}
  1601. 

  1602. 	/**
  1603. 	 * 根据当前日期，加上对应数(不包括toDate)
  1604. 	 * 
  1605. 	 * @param type
  1606. 	 *            小时，分钟，毫秒。Calendar中的常量
  1607. 	 * @param addNmu
  1608. 	 *            添加数 DateUtil中的常量
  1609. 	 * @param formatStr
  1610. 	 *            格式化返回的字符串
  1611. 	 * @return 添加完后的时间
  1612. 	
  1613. 	 */
  1614. 	public static String getAddTime(int type, int addNum, String formatStr) {
  1615. 		Calendar calendar = Calendar.getInstance();
  1616. 		calendar.setTime(new Date());
  1617. 		calendar.add(type, addNum);
  1618. 		calendar.getTime();
  1619. 		return DateUtils.changeDateToStr(calendar.getTime(), formatStr);
  1620. 	}
  1621. 

  1622. 	/**
  1623. 	 * 转成中文日期显示 yyyy年MM月dd日 HH时mm分ss秒
  1624. 	 * 
  1625. 	 * @param dateStr
  1626. 	 * @return
  1627. 	
  1628. 	 */
  1629. 	public static String converToChineseDate(String dateStr) {
  1630. 		if (StringUtils.isNullBlank(dateStr)) {
  1631. 			throw new RuntimeException("传入日期不能为空");
  1632. 		}
  1633. 		SimpleDateFormat sf = null;
  1634. 		if (dateStr.trim().length() == 8) {
  1635. 			sf = new SimpleDateFormat("yyyy年MM月dd日");
  1636. 		} else {
  1637. 			sf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
  1638. 		}
  1639. 		String dateFmt = "";
  1640. 		Date d = DateUtils.changeStrToDate(dateStr);
  1641. 		dateFmt = sf.format(d);
  1642. 		return dateFmt;
  1643. 	}
  1644. 

  1645. 	public static String getAddDate(String dateStr, int timeType, int number) {
  1646. 		String returnDate = "";
  1647. 		try {
  1648. 			Date date = DateUtils.addDate(dateStr, timeType, number);
  1649. 			returnDate = new SimpleDateFormat("yyyyMMdd").format(date);
  1650. 		} catch (ParseException e) {
  1651. 			e.printStackTrace();
  1652. 		}
  1653. 		return returnDate;
  1654. 	}
  1655. 

  1656. 	/**
  1657. 	 * 根据时间日期字符串和格式，返回指定时间跨度的日期
  1658. 	 * 
  1659. 	 * @param dateStr
  1660. 	 * @param fmt
  1661. 	 * @param timeType
  1662. 	 * @param number
  1663. 	 * @return
  1664. 	 */
  1665. 	public static String getAddDate(String dateStr, String fmt, int timeType, int number) {
  1666. 		String returnDate = "";
  1667. 		try {
  1668. 			Date date = DateUtils.addDate(dateStr, fmt, timeType, number);
  1669. 			returnDate = new SimpleDateFormat(fmt).format(date);
  1670. 		} catch (ParseException e) {
  1671. 			e.printStackTrace();
  1672. 		}
  1673. 		return returnDate;
  1674. 	}
  1675. 

  1676. 	/**
  1677. 	 * 计算两个日期内的天数
  1678. 	 * 
  1679. 	 * @param startDay
  1680. 	 *            20120101
  1681. 	 * @param endDay
  1682. 	 *            20121212
  1683. 	 * @return 返回List<String>
  1684. 	
  1685. 	 */
  1686. 	public static List<String> getTwoDateDays(String startDay, String endDay) {
  1687. 		if (startDay == null)
  1688. 			return new ArrayList<String>();
  1689. 		if (endDay == null)
  1690. 			return new ArrayList<String>();
  1691. 		if (startDay.length() > 8) {
  1692. 			startDay = startDay.substring(0, 8);
  1693. 		}
  1694. 		if (endDay.length() > 8) {
  1695. 			endDay = endDay.substring(0, 8);
  1696. 		}
  1697. 		List<String> lDate = new ArrayList<String>();
  1698. 		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
  1699. 		Date dBegin;
  1700. 		try {
  1701. 			dBegin = sdf.parse(startDay);
  1702. 			Date dEnd = sdf.parse(endDay);
  1703. 			lDate.add(startDay);
  1704. 			Calendar cal = Calendar.getInstance();
  1705. 			// 使用给定的 Date 设置此 Calendar 的时间
  1706. 			cal.setTime(dBegin);
  1707. 			boolean bContinue = true;
  1708. 			while (bContinue) {
  1709. 				// 根据日历的规则，为给定的日历字段添加或减去指定的时间量
  1710. 				cal.add(Calendar.DAY_OF_MONTH, 1);
  1711. 				// 测试此日期是否在指定日期之后
  1712. 				if (dEnd.after(cal.getTime())) {
  1713. 					lDate.add(DateUtils.getDateFormat(cal.getTime()));
  1714. 				} else {
  1715. 					break;
  1716. 				}
  1717. 			}
  1718. 			lDate.add(endDay);
  1719. 			return lDate;
  1720. 		} catch (ParseException e) {
  1721. 			e.printStackTrace();
  1722. 		}
  1723. 

  1724. 		return lDate;
  1725. 	}
  1726. 

  1727. 	/**
  1728. 	 * 获得两个日期内的月份
  1729. 	 * 
  1730. 	 * @param startDay
  1731. 	 *            201201
  1732. 	 * @param endDay
  1733. 	 *            201203
  1734. 	 * @return 返回List<String> {"201201","201202","201203"}
  1735. 	 */
  1736. 	public static List<String> getTwoDateMonths(String startMonth, String endMonth) {
  1737. 		List<String> lDate = new ArrayList<String>();
  1738. 		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
  1739. 		Date dBegin;
  1740. 		try {
  1741. 			dBegin = sdf.parse(startMonth);
  1742. 			Date dEnd = sdf.parse(endMonth);
  1743. 			lDate.add(startMonth);
  1744. 			Calendar cal = Calendar.getInstance();
  1745. 			// 使用给定的 Date 设置此 Calendar 的时间
  1746. 			cal.setTime(dBegin);
  1747. 			boolean bContinue = true;
  1748. 			while (bContinue) {
  1749. 				// 根据日历的规则，为给定的日历字段添加或减去指定的时间量
  1750. 				cal.add(Calendar.MONTH, 1);
  1751. 				// 测试此日期是否在指定日期之后
  1752. 				if (dEnd.after(cal.getTime())) {
  1753. 					lDate.add(DateUtils.getDateFormat(cal.getTime(), "yyyyMM"));
  1754. 				} else {
  1755. 					break;
  1756. 				}
  1757. 			}
  1758. 			lDate.add(endMonth);
  1759. 			return lDate;
  1760. 		} catch (ParseException e) {
  1761. 			e.printStackTrace();
  1762. 		}
  1763. 

  1764. 		return lDate;
  1765. 	}
  1766. 

  1767. 	/**
  1768. 	 * 获取每个月的第一天和最后一天
  1769. 	 * 
  1770. 	 * @param startMon
  1771. 	 * @param endMon
  1772. 	 * @return
  1773. 	
  1774. 	 */
  1775. 	public static List<String[]> getTwoDateMonth(String startMon, String endMon) {
  1776. 		Calendar scal = Calendar.getInstance();
  1777. 		Calendar ecal = Calendar.getInstance();
  1778. 		Date sde = DateUtils.getDate(startMon, "yyyyMM");
  1779. 		Date ede = DateUtils.getDate(endMon, "yyyyMM");
  1780. 		scal.setTime(sde);
  1781. 		ecal.setTime(ede);
  1782. 		List<Date> dlist = new ArrayList<Date>();
  1783. 		dlist.add(scal.getTime());
  1784. 		while (scal.getTime().before(ecal.getTime())) {
  1785. 			scal.add(Calendar.MONTH, 1);
  1786. 			dlist.add(scal.getTime());
  1787. 		}
  1788. 		List<String[]> sList = new ArrayList<String[]>();
  1789. 		for (int i = 0; i < dlist.size(); i++) {
  1790. 			Date d = dlist.get(i);
  1791. 			String[] mon = new String[2];
  1792. 			mon[0] = DateUtils.getDateFormat(d);
  1793. 			Calendar tpCal = Calendar.getInstance();
  1794. 			tpCal.setTime(d);
  1795. 			tpCal.add(Calendar.MONTH, 1);
  1796. 			tpCal.add(Calendar.DAY_OF_MONTH, -1);
  1797. 			mon[1] = DateUtils.getDateFormat(tpCal.getTime());
  1798. 			sList.add(mon);
  1799. 		}
  1800. 

  1801. 		return sList;
  1802. 	}
  1803. 

  1804. 	/**
  1805. 	 * 获取一个月的所有天
  1806. 	 * 
  1807. 	 * @param month
  1808. 	 * @return
  1809. 

  1810. 	 */
  1811. 	public static List<String> getMonthDays(String month) {
  1812. 		Calendar scal = Calendar.getInstance();
  1813. 		Date sde = DateUtils.getDate(month, "yyyyMM");
  1814. 		scal.setTime(sde);
  1815. 		Date d = scal.getTime();
  1816. 		String startDay = DateUtils.getDateFormat(d);
  1817. 		Calendar tpCal = Calendar.getInstance();
  1818. 		tpCal.setTime(d);
  1819. 		tpCal.add(Calendar.MONTH, 1);
  1820. 		tpCal.add(Calendar.DAY_OF_MONTH, -1);
  1821. 		String endDay = DateUtils.getDateFormat(tpCal.getTime());
  1822. 		return getTwoDateDays(startDay, endDay);
  1823. 	}
  1824. 

  1825. 	/**
  1826. 	 * 获取日期时间0点
  1827. 	 * 
  1828. 	 * @param date
  1829. 	 * @return
  1830. 		 */
  1831. 	public static String getFirstDateTime(String date) {
  1832. 		if (StringUtils.isNullBlank(date)) {
  1833. 			return "";
  1834. 		}
  1835. 		if (date.length() < 8) {
  1836. 			return "";
  1837. 		} else {
  1838. 			date = StringUtils.rightPad(date.substring(0, 8), 14, "0");
  1839. 		}
  1840. 		return date;
  1841. 	}
  1842. 

  1843. 	/**
  1844. 	 * 获取日期时间23点59'59
  1845. 	 * 
  1846. 	 * @param date
  1847. 	 * @return
  1848. 	
  1849. 	 */
  1850. 	public static String getEndDateTime(String date) {
  1851. 		if (StringUtils.isNullBlank(date)) {
  1852. 			return "";
  1853. 		}
  1854. 		if (date.length() < 8) {
  1855. 			return "";
  1856. 		} else {
  1857. 			date = date.substring(0, 8) + "235959";
  1858. 		}
  1859. 		return date;
  1860. 	}
  1861. 

  1862. 	/**
  1863. 	 * 根据日期计算属于第几周
  1864. 	 * 
  1865. 	 * @param date
  1866. 	 *            格式 yyyyMMdd
  1867. 	 * @throws ParseException
  1868. 	 */
  1869. 	public static int getWeekOfYear(String date) {
  1870. 		try {
  1871. 			SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
  1872. 			Calendar cal = Calendar.getInstance();
  1873. 			cal.setFirstDayOfWeek(Calendar.MONDAY); // 设置每周的第一天为星期一
  1874. 			// cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);// 每周从周一开始
  1875. 			// cal.setMinimalDaysInFirstWeek(1); // 设置每周最少为1天
  1876. 			cal.setTime(df.parse(date));
  1877. 			int year = getWeekOfYear(cal);
  1878. 			String week = year + "" + cal.get(Calendar.WEEK_OF_YEAR);
  1879. 			if (cal.get(Calendar.WEEK_OF_YEAR) < 10) {
  1880. 				week = year + "0" + cal.get(Calendar.WEEK_OF_YEAR);
  1881. 			}
  1882. 			int weekInt = Integer.valueOf(week);
  1883. 			if (getWeekDayByDay2(date.substring(0, 4) + "0101") > 4) {
  1884. 				weekInt--;
  1885. 			}
  1886. 			if (weekInt % 100 == 0) {
  1887. 				year = year - 1;
  1888. 				cal.add(Calendar.DAY_OF_YEAR, -7);
  1889. 				week = year + "" + (cal.get(Calendar.WEEK_OF_YEAR) + 1);
  1890. 				weekInt = Integer.valueOf(week);
  1891. 				if (getWeekDayByDay2(date.substring(0, 4) + "0101") > 4) {
  1892. 					weekInt--;
  1893. 				}
  1894. 			}
  1895. 			return weekInt;
  1896. 		} catch (Exception e) {
  1897. 			e.printStackTrace();
  1898. 		}
  1899. 		return 0;
  1900. 	}
  1901. 

  1902. 	/**
  1903. 	 * 两个时间段内的所有周
  1904. 	 * 
  1905. 	 * @param startDate
  1906. 	 * @param endDate
  1907. 	 * @return
  1908. 	
  1909. 	 */
  1910. 	public static List<String> queryAllWeekInTwoDates(String startDate, String endDate) {
  1911. 		Calendar scal = Calendar.getInstance();
  1912. 		Calendar ecal = Calendar.getInstance();
  1913. 		Date sde = DateUtils.getDate(startDate, "yyyyMMdd");
  1914. 		Date ede = DateUtils.getDate(endDate, "yyyyMMdd");
  1915. 		scal.setTime(sde);
  1916. 		ecal.setTime(ede);
  1917. 		Map<String, Object> tempMap = new HashMap<String, Object>();
  1918. 		List<String> res = new ArrayList<String>();
  1919. 		while (scal.getTime().before(ecal.getTime())) {
  1920. 			scal.add(Calendar.DAY_OF_MONTH, 1);
  1921. 			int week = getWeekOfYear(DateUtils.changeDateToStr(scal.getTime(), "yyyyMMdd"));
  1922. 			if (!tempMap.containsKey(week + "")) {
  1923. 				tempMap.put(week + "", week);
  1924. 				res.add(week + "");
  1925. 			}
  1926. 		}
  1927. 		return res;
  1928. 		// List<String> list = new ArrayList<String>();
  1929. 		// try {
  1930. 		// if(StringUtils.isNotBlank(startDate)&&StringUtils.isNotBlank(endDate)){
  1931. 		// SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
  1932. 		// Calendar cal1 = Calendar.getInstance();
  1933. 		// cal1.setTime(df.parse(startDate));
  1934. 		// int syear = getWeekOfYear(cal1);
  1935. 		// cal1.setTime(df.parse(endDate));
  1936. 		// int eyear = getWeekOfYear(cal1);
  1937. 		//
  1938. 		// int sweek = getWeekOfYear(startDate);
  1939. 		// int eweek = getWeekOfYear(endDate);
  1940. 		// for (int i = syear; i <= eyear; i++) {
  1941. 		// int week = getWeekOfYear(i + "1231") % 100;
  1942. 		// int prevWeek = getWeekOfYear(i + "1224") % 100;
  1943. 		// if(week < prevWeek){
  1944. 		// week = prevWeek;
  1945. 		// }
  1946. 		// int nextWeek = getWeekOfYear(i + "0107") % 100;
  1947. 		// int start = 1;
  1948. 		// if(week > 50 && nextWeek == 2){
  1949. 		// start = 2;
  1950. 		// }
  1951. 		// for (int j = start; j <= week; j++) {
  1952. 		// int val = Integer.valueOf(i+""+j);
  1953. 		// if(j<10){
  1954. 		// val = Integer.valueOf(i+"0"+j);
  1955. 		// }
  1956. 		// if(val>=sweek&&val<=eweek){
  1957. 		// list.add(String.valueOf(val));
  1958. 		// }
  1959. 		// }
  1960. 		// }
  1961. 		// }
  1962. 		// } catch (Exception e) {
  1963. 		// e.printStackTrace();
  1964. 		// }
  1965. 		// return list;
  1966. 	}
  1967. 

  1968. 	/**
  1969. 	 * 获取这个周是属于哪一年
  1970. 	 * 
  1971. 	 * @param cl
  1972. 	 * @return 返回年份 如:2012
  1973. 	
  1974. 	 */
  1975. 	public static int getWeekOfYear(Calendar cl) {
  1976. 		if (cl.get(Calendar.MONTH) == Calendar.JANUARY && cl.get(Calendar.WEEK_OF_YEAR) > 50) {
  1977. 			return cl.get(Calendar.YEAR) - 1;
  1978. 		} else {
  1979. 			if (cl.get(Calendar.MONTH) == Calendar.DECEMBER && cl.get(Calendar.WEEK_OF_YEAR) < 2) {
  1980. 				return cl.get(Calendar.YEAR) + 1;
  1981. 			} else {
  1982. 				return cl.get(Calendar.YEAR);
  1983. 			}
  1984. 		}
  1985. 	}
  1986. 

  1987. 	/**
  1988. 	 * TODO需要测试 获得指定日期的去年同一周期的时间 如： 20110920000000 为
  1989. 	 * 2011年38周星期二，则返回2010年38周星期二的日期
  1990. 	 * 
  1991. 	 * @param dateStr
  1992. 	 *            yyyyMMddHHmmss
  1993. 	 * @return
  1994. 	 */
  1995. 	public static String getPrevYearWeekDate(String dateStr) {
  1996. 		Calendar calendar = Calendar.getInstance();
  1997. 		Date date = DateUtils.getDate(dateStr, "yyyyMMddHHmmss");
  1998. 		calendar.setTime(date);
  1999. 		int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
  2000. 		if (dayOfWeek == 1) {
  2001. 			dayOfWeek = 7;
  2002. 		} else {
  2003. 			dayOfWeek = dayOfWeek - 1;
  2004. 		}
  2005. 		int week = DateUtils.getWeekOfYear(dateStr.substring(0, 8));
  2006. 

  2007. 		week = week % 100;
  2008. 		calendar.add(Calendar.YEAR, -1);
  2009. 		calendar.setFirstDayOfWeek(Calendar.MONDAY);
  2010. 		int prevWeek = DateUtils.getWeekOfYear(getDateFormat(calendar.getTime(), "yyyyMMdd"));// calendar.get(Calendar.WEEK_OF_YEAR);
  2011. 		prevWeek = prevWeek % 100;
  2012. 		int prevXq = calendar.get(Calendar.DAY_OF_WEEK);
  2013. 		if (prevXq == Calendar.SUNDAY) {
  2014. 			prevXq = 7;
  2015. 		} else {
  2016. 			prevXq = prevXq - 1;
  2017. 		}
  2018. 		// 如果是跨年，单独处理
  2019. 		if (Math.abs(prevWeek - week) > 10) {
  2020. 			if (prevWeek > week) {
  2021. 				prevWeek = week - 1;
  2022. 			} else {
  2023. 				prevWeek = week + 1;
  2024. 			}
  2025. 		}
  2026. 		int temp = (prevWeek - week) * 7 + (prevXq - dayOfWeek);
  2027. 		calendar.add(Calendar.DAY_OF_YEAR, -temp);
  2028. 		return DateUtils.getDateFormat(calendar.getTime(), "yyyyMMddHHmmss");
  2029. 	}
  2030. 

  2031. 	public static int getWeekDayByDay2(String day) {
  2032. 		Date d = changeStrToDate(day);
  2033. 		Calendar cal = Calendar.getInstance();
  2034. 		cal.setFirstDayOfWeek(Calendar.MONDAY);
  2035. 		cal.setTime(d);
  2036. 		int week = cal.get(Calendar.DAY_OF_WEEK);
  2037. 		switch (week) {
  2038. 		case 1:
  2039. 			return 7;
  2040. 		default:
  2041. 			return week - 1;
  2042. 		}
  2043. 

  2044. 	}
  2045. 

  2046. 	/**
  2047. 	 * 根据指定日期，获得星期几的中文
  2048. 	 * 
  2049. 	 * @param datestr
  2050. 	 *            yyyyMMdd格式
  2051. 	 * @return
  2052. 	 */
  2053. 	public static String getWeekDayString(String datestr) {
  2054. 		String weekString = "";
  2055. 		final String dayNames[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
  2056. 		Calendar calendar = Calendar.getInstance();
  2057. 		Date date = DateUtils.getDate(datestr, "yyyyMMdd");
  2058. 		calendar.setTime(date);
  2059. 		int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
  2060. 		weekString = dayNames[dayOfWeek - 1];
  2061. 		return weekString;
  2062. 	}
  2063. 

  2064. 	/**
  2065. 	 * 根据指定周和星期，获得对应的中文格式 如： 2011381 转为：2011年38周星期一 ，2011387 转为：2011年38周星期日
  2066. 	 * 
  2067. 	 * @param datestr
  2068. 	 * @return
  2069. 	 */
  2070. 	public static String getWeekDayCnStr(String datestr) {
  2071. 		String weekString = datestr.substring(0, 4) + "年" + datestr.substring(4, 6) + "周";
  2072. 		final String dayNames[] = { "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日" };
  2073. 		int dayOfWeek = Integer.parseInt(datestr.substring(6));
  2074. 		weekString += dayNames[dayOfWeek - 1];
  2075. 		return weekString;
  2076. 	}
  2077. 

  2078. 	/**
  2079. 	 * 根据日期字符串获得是某年某周星期几，最后一位：星期一为1，星期日为7 如： 20110920 返回2011382
  2080. 	 * 
  2081. 	 * @param datestr
  2082. 	 *            yyyyMMdd
  2083. 	 * @return
  2084. 	 */
  2085. 	public static String getYearWeekDay(String datestr) {
  2086. 		Calendar calendar = Calendar.getInstance();
  2087. 		Date date = DateUtils.getDate(datestr, "yyyyMMdd");
  2088. 		calendar.setTime(date);
  2089. 		calendar.setFirstDayOfWeek(Calendar.MONDAY);
  2090. 		int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
  2091. 		if (dayOfWeek == 1) {
  2092. 			dayOfWeek = 7;
  2093. 		} else {
  2094. 			dayOfWeek = dayOfWeek - 1;
  2095. 		}
  2096. 		int week = DateUtils.getWeekOfYear(datestr);
  2097. 		// week = week - 1;
  2098. 		return String.valueOf(week + "" + dayOfWeek);
  2099. 	}
  2100. 

  2101. 	/**
  2102. 	 * 获得指定时间的年和周 如：20110920 返回2011年38周
  2103. 	 * 
  2104. 	 * @param date
  2105. 	 * @return
  2106. 	 */
  2107. 	public static String getYearWeekStr(Date date) {
  2108. 		Calendar calendar = Calendar.getInstance();
  2109. 		calendar.setTime(date);
  2110. 		int week = DateUtils.getWeekOfYear(DateUtils.getDateStr(date, "yyyyMMdd"));
  2111. 		// week = week - 1;
  2112. 		String yy = String.valueOf(week / 100);
  2113. 		String ww = String.valueOf(week % 100);
  2114. 		int w = week % 100;
  2115. 		if (w < 10) {
  2116. 			ww = "0" + w;
  2117. 		}
  2118. 		return yy + "年" + ww + "周";
  2119. 	}
  2120. 

  2121. 	/**
  2122. 	 * 计算输入日期是星期几
  2123. 	 * 
  2124. 	 * @param day
  2125. 	 * @return 返回 星期一
  2126. 	
  2127. 	 */
  2128. 	public static String getWeekDayByDay(String day) {
  2129. 		if (day == null)
  2130. 			return "";
  2131. 		Date d = changeStrToDate(day);
  2132. 		Calendar cal = Calendar.getInstance();
  2133. 		cal.setFirstDayOfWeek(Calendar.MONDAY);
  2134. 		cal.setTime(d);
  2135. 		int week = cal.get(Calendar.DAY_OF_WEEK);
  2136. 		switch (week) {
  2137. 		case 1:
  2138. 			return "星期日";
  2139. 		case 2:
  2140. 			return "星期一";
  2141. 		case 3:
  2142. 			return "星期二";
  2143. 		case 4:
  2144. 			return "星期三";
  2145. 		case 5:
  2146. 			return "星期四";
  2147. 		case 6:
  2148. 			return "星期五";
  2149. 		case 7:
  2150. 			return "星期六";
  2151. 		default:
  2152. 			return "";
  2153. 		}
  2154. 

  2155. 	}
  2156. 

  2157. 	public static List<String> getHoursBetweenTwoDayByMins(String sday, String eday, int mins) {
  2158. 		Calendar scal = Calendar.getInstance();
  2159. 		Calendar ecal = Calendar.getInstance();
  2160. 		Date sde = DateUtils.getDate(sday, "yyyyMMddHHmmss");
  2161. 		Date ede = DateUtils.getDate(eday, "yyyyMMddHHmmss");
  2162. 		scal.setTime(sde);
  2163. 		ecal.setTime(ede);
  2164. 		List<Date> dlist = new ArrayList<Date>();
  2165. 		List<String> resList = new ArrayList<String>();
  2166. 		dlist.add(scal.getTime());
  2167. 		while (scal.getTime().before(ecal.getTime())) {
  2168. 			scal.add(Calendar.MINUTE, mins);
  2169. 			dlist.add(scal.getTime());
  2170. 		}
  2171. 		for (int i = 0; i < dlist.size(); i++) {
  2172. 			Date d = dlist.get(i);
  2173. 			String hour = DateUtils.changeDateToStr(d, "yyyyMMddHH");
  2174. 			resList.add(hour);
  2175. 		}
  2176. 		return resList;
  2177. 	}
  2178. 

  2179. 	/**
  2180. 	 * 获取当月第一天日期
  2181. 	 * 
  2182. 	 * @return
  2183. 	 */
  2184. 	public static Date getFirstDateOfMonth() {
  2185. 		Calendar cal = Calendar.getInstance();
  2186. 		cal.set(GregorianCalendar.DAY_OF_MONTH, 1);
  2187. 		Date date = cal.getTime();
  2188. 		return date;
  2189. 	}
  2190. 

  2191. 	/**
  2192. 	 * 获取输入日期所在周的第一天和最后一天
  2193. 	 * 
  2194. 	 * @param date
  2195. 	 * @return
  2196. 	
  2197. 	 */
  2198. 	public static String[] getFirstAndEndDayOfWeekByDate(String date) {
  2199. 		String[] twoDays = new String[2];
  2200. 		Calendar cal = Calendar.getInstance();
  2201. 		Date d = DateUtils.changeStrToDate(date);
  2202. 		cal.setTime(d);
  2203. 		int day_of_week = cal.get(Calendar.DAY_OF_WEEK) - 2;
  2204. 		cal.add(Calendar.DATE, -day_of_week);
  2205. 		twoDays[0] = DateUtils.getDateFormat(cal.getTime(), "yyyyMMdd");
  2206. 		cal.add(Calendar.DATE, 6);
  2207. 		twoDays[1] = DateUtils.getDateFormat(cal.getTime(), "yyyyMMdd");
  2208. 		return twoDays;
  2209. 	}
  2210. 

  2211. 	/**
  2212. 	 * 获取输入日期所在周的第一天和最后一天
  2213. 	 * 
  2214. 	 * @param date
  2215. 	 * @return
  2216. 	
  2217. 	 */
  2218. 	public static String getFirstDayOfWeekByDate(String date) {
  2219. 		Calendar cal = Calendar.getInstance();
  2220. 		Date d = DateUtils.changeStrToDate(date);
  2221. 		cal.setTime(d);
  2222. 		int day_of_week = cal.get(Calendar.DAY_OF_WEEK) - 2;
  2223. 		if (day_of_week == -1) {
  2224. 			day_of_week = 6;
  2225. 		}
  2226. 		cal.add(Calendar.DATE, -day_of_week);
  2227. 		return DateUtils.getDateFormat(cal.getTime(), "yyyyMMdd");
  2228. 	}
  2229. 

  2230. 	/**
  2231. 	 * 今天算起前几周是第几周
  2232. 	 * 
  2233. 	 * @param amount
  2234. 	 * @return
  2235. 	
  2236. 	 */
  2237. 	public static String getWeekBeforeWeek(int amount) {
  2238. 		int days = 7 * amount;
  2239. 		String day = DateUtils.add(DateUtils.getCurrentDate(), DateUtils.DB_STORE_DATE, days, Calendar.DAY_OF_MONTH);
  2240. 		String week = DateUtils.getWeekOfYear(day) + "";
  2241. 		return week;
  2242. 	}
  2243. 

  2244. 	/**
  2245. 	 * 指定时间算起前几周是第几周
  2246. 	 * 
  2247. 	 * @param amount
  2248. 	 * @return
  2249. 	
  2250. 	 */
  2251. 	public static String getWeekBeforeDate(Date date, int amount) {
  2252. 		int days = 7 * amount;
  2253. 		String day = DateUtils.add(getDateStr(date, DB_STORE_DATE_FMT), DateUtils.DB_STORE_DATE, days, Calendar.DAY_OF_MONTH);
  2254. 		String week = DateUtils.getWeekOfYear(day) + "";
  2255. 		return week;
  2256. 	}
  2257. 

  2258. 	/**
  2259. 	 * 两个时间段内的所有小时
  2260. 	 * 
  2261. 	 * @param sday
  2262. 	 *            格式yyyyMMddhhmmss
  2263. 	 * @param eday
  2264. 	 *            格式yyyyMMddhhmmss
  2265. 	 * @return
  2266. 	 
  2267. 	 */
  2268. 	public static List<String> getHoursBetweenTwoDay(String sday, String eday) {
  2269. 		Calendar scal = Calendar.getInstance();
  2270. 		Calendar ecal = Calendar.getInstance();
  2271. 		Date sde = DateUtils.getDate(sday, "yyyyMMddHHmmss");
  2272. 		Date ede = DateUtils.getDate(eday, "yyyyMMddHHmmss");
  2273. 		scal.setTime(sde);
  2274. 		ecal.setTime(ede);
  2275. 		List<Date> dlist = new ArrayList<Date>();
  2276. 		List<String> resList = new ArrayList<String>();
  2277. 		dlist.add(scal.getTime());
  2278. 		while (scal.getTime().before(ecal.getTime())) {
  2279. 			scal.add(Calendar.HOUR_OF_DAY, 1);
  2280. 			dlist.add(scal.getTime());
  2281. 		}
  2282. 		for (int i = 0; i < dlist.size(); i++) {
  2283. 			Date d = dlist.get(i);
  2284. 			String hour = DateUtils.changeDateToStr(d, "yyyyMMddHH");
  2285. 			resList.add(hour);
  2286. 		}
  2287. 		return resList;
  2288. 	}
  2289. 

  2290. 	/**
  2291. 	 * 获取0-23点的小时点。
  2292. 	 * 
  2293. 	 * @return
  2294. 	
  2295. 	 */
  2296. 	public static List<String> getHours(String sday, String eday) {
  2297. 		List<String> lst = getHoursBetweenTwoDay(sday, eday);
  2298. 		List<String> res = new ArrayList<String>();
  2299. 		if (lst.size() <= 24) {
  2300. 			for (int i = 0; i < lst.size(); i++) {
  2301. 				res.add(lst.get(i).substring(8, 10));
  2302. 			}
  2303. 		} else {
  2304. 			for (int i = 0; i <= 23; i++) {
  2305. 				res.add(lst.get(i).substring(8, 10));
  2306. 			}
  2307. 		}
  2308. 		return res;
  2309. 	}
  2310. 

  2311. 	/**
  2312. 	 * 获取上一周的今天
  2313. 	 * 
  2314. 	 * @return
  2315. 	
  2316. 	 */
  2317. 	public static String getPerWeekDateStr() {
  2318. 		Calendar curr = Calendar.getInstance();
  2319. 		curr.set(Calendar.DAY_OF_MONTH, curr.get(Calendar.DAY_OF_MONTH) - 7);
  2320. 		Date perDate = curr.getTime();
  2321. 		return getDateStr(perDate, DB_STORE_DATE);
  2322. 	}
  2323. 

  2324. 	/**
  2325. 	 * 取得当前日期是多少周
  2326. 	 * 
  2327. 	 * @param date
  2328. 	 * @return
  2329. 	 */
  2330. 	public static int getWeekOfYear(Date date) {
  2331. 		Calendar c = new GregorianCalendar();
  2332. 		c.setFirstDayOfWeek(Calendar.MONDAY);
  2333. 		c.setMinimalDaysInFirstWeek(7);
  2334. 		c.setTime(date);
  2335. 

  2336. 		return c.get(Calendar.WEEK_OF_YEAR);
  2337. 	}
  2338. 

  2339. 	/**
  2340. 	 * 取得当前日期是第几天
  2341. 	 * 
  2342. 	 * @param date
  2343. 	 * @return
  2344. 	
  2345. 	 */
  2346. 	public static int getDayOfYear() {
  2347. 		TimeZone zone = TimeZone.getTimeZone("Asia/Shanghai");
  2348. 		Calendar cal = Calendar.getInstance(zone);
  2349. 		int daynum = cal.get(cal.DAY_OF_YEAR);
  2350. 		return daynum;
  2351. 	}
  2352. 

  2353. 	/**
  2354. 	 * 得到某一年周的总数
  2355. 	 * 
  2356. 	 * @param year
  2357. 	 * @return
  2358. 	 */
  2359. 	public static int getMaxWeekNumOfYear(int year) {
  2360. 		Calendar c = new GregorianCalendar();
  2361. 		c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
  2362. 

  2363. 		return getWeekOfYear(c.getTime());
  2364. 	}
  2365. 

  2366. 	/**
  2367. 	 * 得到某年某周的第一天
  2368. 	 * 
  2369. 	 * @param year
  2370. 	 * @param week
  2371. 	 * @return
  2372. 	 */
  2373. 	public static String getFirstDayOfWeek(int year, int week) {
  2374. 		Calendar c = new GregorianCalendar();
  2375. 		c.set(Calendar.YEAR, year);
  2376. 		c.set(Calendar.MONTH, Calendar.JANUARY);
  2377. 		c.set(Calendar.DATE, 1);
  2378. 

  2379. 		Calendar cal = (GregorianCalendar) c.clone();
  2380. 		cal.add(Calendar.DATE, week * 7);
  2381. 

  2382. 		return getFirstDayOfWeek(cal.getTime());
  2383. 	}
  2384. 

  2385. 	/**
  2386. 	 * 得到某年某周的最后一天
  2387. 	 * 
  2388. 	 * @param year
  2389. 	 * @param week
  2390. 	 * @return
  2391. 	 */
  2392. 	public static String getLastDayOfWeek(int year, int week) {
  2393. 		Calendar c = new GregorianCalendar();
  2394. 		c.set(Calendar.YEAR, year);
  2395. 		c.set(Calendar.MONTH, Calendar.JANUARY);
  2396. 		c.set(Calendar.DATE, 1);
  2397. 

  2398. 		Calendar cal = (GregorianCalendar) c.clone();
  2399. 		cal.add(Calendar.DATE, week * 7);
  2400. 

  2401. 		return getLastDayOfWeek(cal.getTime());
  2402. 	}
  2403. 

  2404. 	/**
  2405. 	 * 取得指定日期所在周的第一天
  2406. 	 * 
  2407. 	 * @param date
  2408. 	 * @return
  2409. 	 */
  2410. 	public static String getFirstDayOfWeek(Date date) {
  2411. 		Calendar c = new GregorianCalendar();
  2412. 		c.setFirstDayOfWeek(Calendar.MONDAY);
  2413. 		c.setTime(date);
  2414. 		c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
  2415. 		return DateUtils.changeDateToStr(c.getTime(), DateUtils.DB_STORE_DATE_FULL);
  2416. 	}
  2417. 

  2418. 	/**
  2419. 	 * 取得指定日期所在周的最后一天
  2420. 	 * 
  2421. 	 * @param date
  2422. 	 * @return
  2423. 	 */
  2424. 	public static String getLastDayOfWeek(Date date) {
  2425. 		Calendar c = new GregorianCalendar();
  2426. 		c.setFirstDayOfWeek(Calendar.MONDAY);
  2427. 		c.setTime(date);
  2428. 		c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
  2429. 		return DateUtils.changeDateToStr(c.getTime(), DateUtils.DB_STORE_DATE_FULL);
  2430. 	}
  2431. 

  2432. 	/**
  2433. 	 * 取得当前日期所在周的第一天
  2434. 	 * 
  2435. 	 * @param date
  2436. 	 * @return
  2437. 	 */
  2438. 	public static String getFirstDayOfWeek() {
  2439. 		Calendar c = new GregorianCalendar();
  2440. 		c.setFirstDayOfWeek(Calendar.MONDAY);
  2441. 		c.setTime(new Date());
  2442. 		c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
  2443. 		return DateUtils.changeDateToStr(c.getTime(), DateUtils.DB_STORE_DATE_FULL);
  2444. 	}
  2445. 

  2446. 	/**
  2447. 	 * 取得当前日期所在周的最后一天
  2448. 	 * 
  2449. 	 * @param date
  2450. 	 * @return
  2451. 	 */
  2452. 	public static String getLastDayOfWeek() {
  2453. 		Calendar c = new GregorianCalendar();
  2454. 		c.setFirstDayOfWeek(Calendar.MONDAY);
  2455. 		c.setTime(new Date());
  2456. 		c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
  2457. 		return DateUtils.changeDateToStr(c.getTime(), DateUtils.DB_STORE_DATE_FULL);
  2458. 	}
  2459. 

  2460. 	/**
  2461. 	 * 获取两日期时间差
  2462. 	 * 
  2463. 	 * @param sday
  2464. 	 * @param eday
  2465. 	 * @return
  2466. 	
  2467. 	 */
  2468. 	public static Long getDiffBetweenTwoDay(String sday, String eday) {
  2469. 		Date sde = null;
  2470. 		Date ede = null;
  2471. 		try {
  2472. 			sde = DateUtils.getDate(sday, "yyyyMMddHHmmss");
  2473. 

  2474. 			ede = DateUtils.getDate(eday, "yyyyMMddHHmmss");
  2475. 		} catch (Exception e) {
  2476. 

  2477. 			e.printStackTrace();
  2478. 		}
  2479. 		// 获得两个时间的毫秒时间差异
  2480. 		long diff = ede.getTime() - sde.getTime();
  2481. 		return diff;
  2482. 	}
  2483. 

  2484. 	/**
  2485. 	 * 获取当前年份
  2486. 	 * 
  2487. 	 * @return 如2014
  2488. 	
  2489. 	 */
  2490. 	public static String getNowYear() {
  2491. 		Calendar ca = Calendar.getInstance();
  2492. 		ca.setTime(new java.util.Date());
  2493. 		String year = "" + ca.get(Calendar.YEAR);
  2494. 		return year;
  2495. 	}
  2496. 

  2497. 	/**
  2498. 	 * 获取当前月份
  2499. 	 * 
  2500. 	 * @return 如2014
  2501. 	 
  2502. 	 */
  2503. 	public static String getNowMonth() {
  2504. 		Calendar ca = Calendar.getInstance();
  2505. 		ca.setTime(new java.util.Date());
  2506. 		String month = ca.get(Calendar.MONTH) + 1 + "";
  2507. 		return month;
  2508. 	}
  2509. 

  2510. 	/**
  2511. 	 * 获取当前日期
  2512. 	 * 
  2513. 	 * @return 如2014
  2514. 	
  2515. 	 */
  2516. 	public static String getNowDay() {
  2517. 		Calendar ca = Calendar.getInstance();
  2518. 		ca.setTime(new java.util.Date());
  2519. 		String year = "" + ca.get(Calendar.DAY_OF_MONTH);
  2520. 		return year;
  2521. 	}
  2522. 

  2523. 	public static boolean isLeapYear(String year) {
  2524. 		int yearInt = Integer.parseInt(year);
  2525. 		if (yearInt % 400 == 0 || (yearInt % 100 != 0) && (yearInt % 4 == 0)) {
  2526. 			return true;
  2527. 		}
  2528. 		return false;
  2529. 	}
  2530. 

  2531. 	/**
  2532. 	 * 根据年龄推算出生日期
  2533. 	 * 
  2534. 	 * @param age
  2535. 	 *            年龄
  2536. 	 * @return 出生日期
  2537. 	 * @author
  2538. 	 */
  2539. 	public static String Age2Birth(String age) {
  2540. 		// 获取当前日期
  2541. 		Calendar currCalendar = Calendar.getInstance();
  2542. 		// 获取当前年份
  2543. 		int currYear = currCalendar.get(Calendar.YEAR);
  2544. 		// 获取当前月份
  2545. 		int currMonth = currCalendar.get(Calendar.MONTH) + 1;
  2546. 		// 获取当日
  2547. 		int currDay = currCalendar.get(Calendar.DAY_OF_MONTH);
  2548. 		// 计算出生年份
  2549. 		int birthYear = currYear - Integer.parseInt(age);
  2550. 		// 返回出生日期
  2551. 		String realMonth = String.valueOf(currMonth).length() == 1 ? "0" + String.valueOf(currMonth) : String.valueOf(currMonth);
  2552. 		return String.valueOf(birthYear) + realMonth + String.valueOf(currDay);
  2553. 

  2554. 	}
  2555. 

  2556. 	public static void main(String[] args) throws ParseException {
  2557. 		// System.out.println(DateUtils.getAge("19500614"));
  2558. 		/*
  2559. 		 * System.out.println(getWeekOfYear(new Date()));
  2560. 		 * System.out.println(getDayOfYear());
  2561. 		 * System.out.println(getWeekOfYear(new Date())); System.out.println(new
  2562. 		 * Date().getMonth()+1); System.out.println(getMaxWeekNumOfYear(2016));
  2563. 		 * System.out.println(getDayOfYear());
  2564. 		 */
  2565. 		System.out.println(birthdayToAge("20151001"));
  2566. 		System.out.println(birthdayToAge("20151101"));
  2567. 		System.out.println(isLeapYear("2004"));
  2568. 	}
  2569. 

  2570. 	/**
  2571. 	 * 如果是早上，在0-6点返回0点，6-12点返回6点，12-18点返回12点，18-24点返回18点
  2572. 	 */
  2573. 	public static String getSearchTime() {
  2574. 		String dateStr = DateUtils.getCurrentTime();
  2575. 		String hour = dateStr.substring(8, 10);
  2576. 		int ihour = Integer.parseInt(hour);
  2577. 		if (0 < ihour && ihour <= 6) {
  2578. 			return DateUtils.getCurrentDate() + "000000";
  2579. 		}
  2580. 		if (6 < ihour && ihour <= 12) {
  2581. 			return DateUtils.getCurrentDate() + "060000";
  2582. 		}
  2583. 		if (12 < ihour && ihour <= 18) {
  2584. 			return DateUtils.getCurrentDate() + "120000";
  2585. 		}
  2586. 		if (18 < ihour && ihour <= 24) {
  2587. 			return DateUtils.getCurrentDate() + "180000";
  2588. 		}
  2589. 		return DateUtils.getCurrentDate() + "000000";
  2590. 

  2591. 	}
  2592. 

  2593. 	/**
  2594. 	 * 获取两个时间相差的分钟
  2595. 	 * 
  2596. 	 * @param stime
  2597. 	 * @param etime
  2598. 	 * @return
  2599. 	 */
  2600. 	public static long getBetweenMinute(String stime, String etime) {
  2601. 		Date kssj = DateUtils.getDate(stime, DateUtils.DB_STORE_DATE_FULL);
  2602. 		Date jssj = DateUtils.getDate(etime, DateUtils.DB_STORE_DATE_FULL);
  2603. 		Calendar instance = Calendar.getInstance();
  2604. 		instance.setTime(kssj);
  2605. 		Calendar instance1 = Calendar.getInstance();
  2606. 		instance1.setTime(jssj);
  2607. 		long xgsj = instance1.getTimeInMillis() - instance.getTimeInMillis();
  2608. 		return xgsj / (1000 * 60);
  2609. 	}
  2610. 

  2611. 	public static boolean isBeforeTime(String stime, String etime) {
  2612. 		if (StringUtils.isBlank(stime) || StringUtils.isBlank(etime)) {
  2613. 			return true;
  2614. 		}
  2615. 		Date kssj = DateUtils.getDate(stime, DateUtils.DB_STORE_DATE_FULL);
  2616. 		
  2617. 		Date jssj = DateUtils.getDate(etime, DateUtils.DB_STORE_DATE_FULL);
  2618. 		return kssj.before(jssj);
  2619. 	}
  2620. }

风中摇曳的男子
关注
专栏目录
java8日期操作
jianguang01的博客
06-13 488
工作时用到的记录一下,方便再次使用时查找(跟着工作持续更新) 1.获取一个日期到此次日期的月底距离多少天 // 获取当前时间--也可以自定义时间然后转为LocalDateTime即可 LocalDateTime localDate = LocalDateTime.now(); // 获取此次日期的月底时间 LocalDateTime lastDayMonth = localDate.with...
收藏到一个好的java时间格式大全（类）
eminem
12-17 7038
http://www.busfly.cn/post/java_string_date_time_class_all.html（原文） 又收藏到一个好的java时间格式大全,这个是做成了类的 java.util.*; import java.text.*; import java.util.Calendar; public class VeDate { /** * 获...
java date 操作_Java常用日期操作
weixin_31176789的博客
02-23 282
//日期转字符串,根据需要调整格式@Testpublic voidDateToString(){Date currentTime= newDate();SimpleDateFormat formatter= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String dateString=formatter.format(currentTime);Syst...
Java中的日期时间类详解（Date、DateFormat、Calendar）
weixin_65752158的博客
07-05 2142
继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，我们重点看以下两个构造函数利用空参构造可以自动设置当前系统时间的毫秒时刻利用有参构造指定long类型的构造参数，可以自定义毫秒时刻。利用setTime修改时间把方法参数给定的毫秒值设置给日期对象利用getTime获取时间把日期对象转换成对应的时间毫秒值。tips:在使用println方法时，会自动调用Date类中的toString方法。
java中new Date指定2023年8月23日
最新发布
weixin_31776191的博客
07-22 69
Java中使用new Date指定日期：2023年8月23日 在Java编程语言中，处理日期和时间是一项常见的任务。Java提供了多种方式来创建和操作日期对象。本文将介绍如何使用java.util.Date类来指定一个特定的日期——2023年8月23日，并展示如何使用旅行图和序列图来描述这一过程。 1. 创建Date对象 ...
java Date常用操作方法
weixin_30824599的博客
10-22 65
public class DateTool { public static final String PATTERN_DEFAULT = "yyyy-MM-dd"; public static final String PATTERN_DAYPATH = "yyyy\\MM\\dd\\"; public static final String PATTERN_DATETIME = ...
JAVA日期Date操作
l8947943的博客
12-29 2105
1.获取当前时间 Date d = new Date(); //当无参数时候，打印出来的是系统当前时间 System.out.println(d); Date d1 = new Date(5000); // 当有参数时候，表示得到系统初试时间，从1970年1月1日 早上8点0分0秒 开始经历了5秒的时间 System.out.println(d1); 输出如图所示 2.当前时间转成数...
java的日期时间操作
elukuangben的专栏
10-02 905
/**     * 以指定的格式来格式化日期     *     * @param date Date     * @param format String     * @return String     */    public String formatDateByFormat(java.util.Date date,String format)    {        String res
Date日期操作工具类
09-27
本主题聚焦于一个名为"Date日期操作工具类"的实用工具，它提供了丰富的功能，包括日期格式化、字符串与日期之间的转换、日期的加减操作以及计算日期间隔等。 首先，让我们深入理解`java.util.Date`类。Date类代表了...
java 操作的日期 date
02-23
`java.time.LocalDate`、`java.time.LocalDateTime`和`java.time.ZonedDateTime`等类提供了更强大、更直观的时间日期操作。例如，创建一个当前日期的LocalDate对象： ```java import java.time.LocalDate; ...
学习Java的Date、Calendar日期操作
09-03
`java.util.Calendar`是抽象类，提供了比`Date`更灵活的日期/时间操作。`Calendar`是线程安全的，并且支持更复杂的日期字段操作，如增加或减少某个日期字段的值。创建`Calendar`实例通常通过`Calendar.getInstance()...
Java Date操作大全
05-27
Java Date操作大全 例举了所有java 日期操作
java中的时间操作
04-20
java中的时间操作
java日期操作工具类（获取指定日期、日期转换、相隔天数）
09-02
Java日期操作是编程中常见的需求，特别是在处理时间相关的业务逻辑时。在Java中，我们可以使用`java.util.Date`、`java.util.Calendar`以及`java.text.SimpleDateFormat`等类来完成日期和时间的操作。以下是对给定...
Java Calendar日历与Date日期的相互转换详解
08-25
Java Calendar日历与Date日期的相互转换是Java开发中的一项基本技术，掌握这项技术可以帮助开发者更好地处理日期和时间相关的操作。在本文中，我们将详细介绍Java Calendar日历与Date日期的相互转换，包括Calendar...
Java中的日期相关操作
净月使者的博客
09-12 1011
小爷心情很糟糕 今天突然笔试到一道关于时间操作的题目，认为会很简单，可是写着写着突然懵逼了~~~，关键是到java8发生了很大的改变，jiji~~~ 各种时间所在包及应用场景： 1、java.util 包下        Class Date             在软件三层架构（在ui层和逻辑层应该使用java.util.Date,在持久层需要使用java.sql.Date）      ...
Java中时间日期的操作
T_Cage的博客
12-05 2878
java 日期时间转字符串 字符串转日期时间 日期操作的方法
java——date时间类型操作
tang_seven的博客
04-04 3293
简单总结java.util.Date类的使用，包括初始化，获取时间，与String类型转换以及时间先后比较；并简单总结java9新的时间框架localDateTime
Java 关于DATE时间类型的操作
qq_43801592的博客
10-31 856
DATE类型注解格式、SQL和代码获取日期当天开始和结束时间
Java Date操作经典实例与性能测试
《经典示例Java日期操作类.pdf》是一份实用的教程，不仅介绍了Java Date类的基础用法，还通过实例演示了其在实际编程中的应用，对于学习和掌握Java日期处理技巧非常有帮助。同时，Java私塾的活动也为开发者提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值