You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1157 lines
36 KiB

  1. package com.iformall.utils;
  2. import javax.xml.datatype.XMLGregorianCalendar;
  3. import java.sql.Timestamp;
  4. import java.text.DateFormat;
  5. import java.text.ParseException;
  6. import java.text.SimpleDateFormat;
  7. import java.time.LocalDate;
  8. import java.time.LocalDateTime;
  9. import java.time.Period;
  10. import java.time.ZoneId;
  11. import java.util.ArrayList;
  12. import java.util.Calendar;
  13. import java.util.Date;
  14. import java.util.List;
  15. /**
  16. * 日期处理
  17. *
  18. * @author stormeye.wu
  19. * @email wugq@mippoint.com
  20. * @date 2016年12月21日 下午12:53:33
  21. */
  22. public class DateUtils {
  23. /** 时间格式(yyyy-MM-dd) */
  24. public final static String DATE_PATTERN = "yyyy-MM-dd";
  25. /** 时间格式(yyyy-MM-dd HH:mm:ss) */
  26. public final static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
  27. public final static String[] weekObj=new String[]{"日","一","二","三","四","五","六"};
  28. public static String format(Date date) {
  29. return format(date, DATE_PATTERN);
  30. }
  31. public static String format(Date date, String pattern) {
  32. if(date != null){
  33. SimpleDateFormat df = new SimpleDateFormat(pattern);
  34. return df.format(date);
  35. }
  36. return null;
  37. }
  38. public static final int MONTH_JAN = 1;
  39. public static final int MONTH_FEB = 2;
  40. public static final int MONTH_MAR = 3;
  41. public static final int MONTH_APR = 4;
  42. public static final int MONTH_MAY = 5;
  43. public static final int MONTH_JUN = 6;
  44. public static final int MONTH_JUL = 7;
  45. public static final int MONTH_AUG = 8;
  46. public static final int MONTH_SEP = 9;
  47. public static final int MONTH_OCT = 10;
  48. public static final int MONTH_NOV = 11;
  49. public static final int MONTH_DEC = 12;
  50. public static int TIME_ROOT = 2011;
  51. /**
  52. * 获得系统时间 TODO: format:yyyy-MM-dd HH:mm:ss
  53. *
  54. * @return time
  55. */
  56. public static String getSystemTime(String format) {
  57. // 系统时间
  58. String time = "";
  59. SimpleDateFormat timeformat = new SimpleDateFormat(format);
  60. time = timeformat.format(Calendar.getInstance().getTime());// 求得本地机的系统时间;
  61. return time;
  62. }
  63. public static Calendar getDateFromString(String timeStr, String format) {
  64. SimpleDateFormat formatter = new SimpleDateFormat(format);
  65. Calendar calendar = Calendar.getInstance();
  66. try {
  67. Date date = formatter.parse(timeStr);
  68. calendar.setTime(date);
  69. } catch (ParseException e) {
  70. e.printStackTrace();
  71. }
  72. return calendar;
  73. }
  74. /**
  75. * 获得系统时间 TODO: format:yyyy-MM-dd HH:mm:ss
  76. *
  77. * @return Calendar
  78. */
  79. public static Calendar getSystemTime() {
  80. // 系统时间
  81. Calendar time = Calendar.getInstance();
  82. time.setTime(new Date());// 求得本地机的系统时间;
  83. return time;
  84. }
  85. /**
  86. * 时间比较
  87. *
  88. * @param time1
  89. * @param time2
  90. * @return
  91. */
  92. public static boolean isDateBefore(Calendar time1, Calendar time2) {
  93. if (time1 != null && time2 != null) {
  94. return time1.getTime().before(time2.getTime());
  95. }
  96. return false;
  97. }
  98. /**
  99. * 时间比较
  100. *
  101. * @param time1
  102. * @param time2
  103. * @return
  104. */
  105. public static boolean isDateAfter(Calendar time1, Calendar time2) {
  106. if (time1 != null && time2 != null) {
  107. return time1.getTime().before(time2.getTime());
  108. }
  109. return false;
  110. }
  111. /**
  112. * 时间比较 系统时间早于输入时间
  113. *
  114. * @param date2
  115. * @return
  116. */
  117. public static boolean isDateBefore(String date2) {
  118. try {
  119. // 获得系统时间
  120. Date date1 = new Date();
  121. DateFormat df = DateFormat.getDateTimeInstance();
  122. return date1.before(df.parse(date2));
  123. } catch (ParseException e) {
  124. e.printStackTrace();
  125. return false;
  126. }
  127. }
  128. /**
  129. * 系统时间晚于输入时间
  130. *
  131. * @param date2
  132. * @return
  133. */
  134. public static boolean isDateAfter(String date2) {
  135. try {
  136. // 获得系统时间
  137. Date date1 = new Date();
  138. DateFormat df = DateFormat.getDateTimeInstance();
  139. return date1.after(df.parse(date2));
  140. } catch (ParseException e) {
  141. e.printStackTrace();
  142. return false;
  143. }
  144. }
  145. /**
  146. * 时间比较(不含日期) 系统时间早于输入时间
  147. *
  148. * @param time
  149. * @return
  150. */
  151. public static boolean isTimeBefore(String time) {
  152. String date = "";
  153. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  154. Date dd = Calendar.getInstance().getTime();
  155. date = sdf.format(dd);
  156. return isDateBefore(date + " " + time);
  157. }
  158. /**
  159. * 时间比较(不含日期) 系统时间晚于输入时间
  160. *
  161. * @param time
  162. * @return
  163. */
  164. public static boolean isTimeAfter(String time) {
  165. String date = "";
  166. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  167. Date dd = Calendar.getInstance().getTime();
  168. date = sdf.format(dd);
  169. return isDateAfter(date + " " + time);
  170. }
  171. /**
  172. * 时间转换 TODO:将框架时间控件获得的时间转化成自己想要的时间
  173. *
  174. * @return
  175. */
  176. public static String timeFormat(String format, String oldTime) {
  177. String formatTime = "";
  178. if (!"".equals(oldTime)) {
  179. try {
  180. SimpleDateFormat time = new SimpleDateFormat(
  181. "yyyy-MM-dd HH:mm:ss");
  182. Date date = time.parse(oldTime);
  183. SimpleDateFormat timeformat = new SimpleDateFormat(format);
  184. formatTime = timeformat.format(date);
  185. } catch (ParseException e) {
  186. e.printStackTrace();
  187. }
  188. }
  189. return formatTime;
  190. }
  191. public static String date2String(Calendar calendar) {
  192. Date date = calendar.getTime();
  193. SimpleDateFormat dateFormatter = new SimpleDateFormat(
  194. "yyyy-MM-dd HH:mm:ss");
  195. String timeStr = dateFormatter.format(date);
  196. return timeStr;
  197. }
  198. public static String date2StringYMD(Calendar calendar) {
  199. Date date = calendar.getTime();
  200. SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd");
  201. String timeStr = dateFormatter.format(date);
  202. return timeStr;
  203. }
  204. public static String date2String(Date date) {
  205. SimpleDateFormat dateFormatter = new SimpleDateFormat(
  206. "yyyy-MM-dd HH:mm:ss");
  207. String timeStr = dateFormatter.format(date);
  208. return timeStr;
  209. }
  210. public static String date2String(Date date, String fomartStr) {
  211. SimpleDateFormat dateFormatter = new SimpleDateFormat(fomartStr);
  212. String timeStr = dateFormatter.format(date);
  213. return timeStr;
  214. }
  215. public static String date2String(Calendar date, String fomartStr) {
  216. SimpleDateFormat dateFormatter = new SimpleDateFormat(fomartStr);
  217. String timeStr = dateFormatter.format(date.getTime());
  218. return timeStr;
  219. }
  220. public static Calendar string2Date(String timeStr) {
  221. SimpleDateFormat dateFormatter = new SimpleDateFormat(
  222. "yyyy-MM-dd HH:mm:ss");
  223. Calendar calendar = Calendar.getInstance();
  224. try {
  225. Date date = dateFormatter.parse(timeStr);
  226. calendar.setTime(date);
  227. } catch (Exception e) {
  228. e.printStackTrace();
  229. }
  230. return calendar;
  231. }
  232. /***
  233. * String转换为Calendar
  234. *
  235. * @param timeStr
  236. * 时间字符串
  237. * @param formaStr
  238. * 匹配格式
  239. * @return
  240. */
  241. public static Calendar strToDate(String timeStr, String formaStr) {
  242. SimpleDateFormat dateFormatter = new SimpleDateFormat(formaStr);
  243. Calendar calendar = Calendar.getInstance();
  244. try {
  245. Date date = dateFormatter.parse(timeStr);
  246. calendar.setTime(date);
  247. } catch (Exception e) {
  248. e.printStackTrace();
  249. }
  250. return calendar;
  251. }
  252. public static Date stringToDate(String timeStr) {
  253. SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd");
  254. Date date = null;
  255. try {
  256. date = dateFormatter.parse(timeStr);
  257. } catch (ParseException e) {
  258. // TODO Auto-generated catch block
  259. e.printStackTrace();
  260. }
  261. return date;
  262. }
  263. public static Date stringToDate(String timeStr,String formaStr) {
  264. SimpleDateFormat dateFormatter = new SimpleDateFormat(formaStr);
  265. Date date = null;
  266. try {
  267. date = dateFormatter.parse(timeStr);
  268. } catch (ParseException e) {
  269. // TODO Auto-generated catch block
  270. e.printStackTrace();
  271. }
  272. return date;
  273. }
  274. /**
  275. * 获得当前时间的前3天
  276. *
  277. */
  278. public static String getTimeBefore3() {
  279. Date myDate = new Date();
  280. SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
  281. long myTime = (myDate.getTime() / 1000) - 60 * 60 * 24 * 3;
  282. myDate.setTime(myTime * 1000);
  283. String mDate = formatter.format(myDate);
  284. return mDate;
  285. }
  286. /**
  287. * 获得当前时间前几天
  288. *
  289. * @param days
  290. * 前几天
  291. * @return
  292. */
  293. public static String getTimeBefore(int days, Date myDate) {
  294. Date testDate = myDate;
  295. SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
  296. long myTime = (testDate.getTime() / 1000) - 60 * 60 * 24 * days;
  297. testDate.setTime(myTime * 1000);
  298. String mDate = formatter.format(testDate);
  299. return mDate;
  300. }
  301. /**
  302. * 获得当前时间前几天
  303. *
  304. * @param days
  305. * 前几天
  306. * @return
  307. */
  308. public static String getTimeBefore(int days, Date myDate,String format) {
  309. Date testDate = myDate;
  310. SimpleDateFormat formatter = new SimpleDateFormat(format);
  311. long myTime = (testDate.getTime() / 1000) - 60 * 60 * 24 * days;
  312. testDate.setTime(myTime * 1000);
  313. String mDate = formatter.format(testDate);
  314. return mDate;
  315. }
  316. /**
  317. * 获得当前时间前几小时的时间
  318. *
  319. * @param hour
  320. * 前几小时
  321. * @return
  322. */
  323. public static String getHourTimeBefore(int hour, Date myDate) {
  324. Date testDate = myDate;
  325. SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  326. long myTime = (testDate.getTime() / 1000) - 60 * 60 * hour;
  327. testDate.setTime(myTime * 1000);
  328. String mDate = formatter.format(testDate);
  329. return mDate;
  330. }
  331. /**
  332. * 获得当前时间后几小时的时间
  333. *
  334. * @param hour
  335. * 后几小时
  336. * @return
  337. */
  338. public static Date getHourTimeAfter(int hour, Date myDate) {
  339. long myTime = (myDate.getTime() / 1000) + 60 * 60 * hour;
  340. Date testDate = new Date(myTime * 1000);
  341. return testDate;
  342. }
  343. /**
  344. * 获得指定时间前几天,格式yyyy-MM-dd
  345. *
  346. * @param days
  347. * 前几天
  348. * @return
  349. */
  350. public static String getTimeBefore(int days, String date) {
  351. Date myDate = null;
  352. SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
  353. try {
  354. myDate = formatter.parse(date);
  355. } catch (ParseException e) {
  356. // TODO Auto-generated catch block
  357. e.printStackTrace();
  358. }
  359. if (myDate != null) {
  360. long myTime = (myDate.getTime() / 1000) - 60 * 60 * 24 * days;
  361. myDate.setTime(myTime * 1000);
  362. String mDate = formatter.format(myDate);
  363. return mDate;
  364. }
  365. return null;
  366. }
  367. public static String getTimeBeforeByFormat(int days, String date,
  368. String format) {
  369. Date myDate = null;
  370. SimpleDateFormat formatter = new SimpleDateFormat(format);
  371. try {
  372. myDate = formatter.parse(date);
  373. } catch (ParseException e) {
  374. // TODO Auto-generated catch block
  375. e.printStackTrace();
  376. }
  377. if (myDate != null) {
  378. long myTime = (myDate.getTime() / 1000) - 60 * 60 * 24 * days;
  379. myDate.setTime(myTime * 1000);
  380. String mDate = formatter.format(myDate);
  381. return mDate;
  382. }
  383. return null;
  384. }
  385. /**
  386. * XMLGregorianCalendar转String
  387. *
  388. * @param cal
  389. * @return
  390. */
  391. public static String xMLGregorianCalendar2String(XMLGregorianCalendar cal) {
  392. if (null != cal) {
  393. Calendar calendar = cal.toGregorianCalendar();
  394. String result = date2String(calendar);
  395. return result;
  396. } else {
  397. return null;
  398. }
  399. }
  400. /**
  401. * 字符串转为Calendar
  402. *
  403. * @param timeStr
  404. * 时间字符串格式为yyyy-MM-dd
  405. * @return
  406. */
  407. public static Calendar str2Date(String timeStr) {
  408. SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd");
  409. Calendar calendar = Calendar.getInstance();
  410. try {
  411. Date date = dateFormatter.parse(timeStr);
  412. calendar.setTime(date);
  413. } catch (Exception e) {
  414. e.printStackTrace();
  415. }
  416. return calendar;
  417. }
  418. /**
  419. * java.util.Date转java.sql.date
  420. */
  421. public static Timestamp utilDate2SqlDate(Date utildate) {
  422. SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
  423. formatter.format(utildate);
  424. java.sql.Date sqldate = new java.sql.Date(utildate.getTime());
  425. Timestamp result = new Timestamp(sqldate.getTime());
  426. return result;
  427. }
  428. public static List<String> getTjTimeList(String str_startTime,
  429. String str_endTime, String type) {
  430. List<String> listTjTime = new ArrayList<String>();
  431. // 按日统计
  432. if ("0".equals(type)) {
  433. int startYear = Integer.parseInt(str_startTime.substring(0, 4));
  434. int endYear = Integer.parseInt(str_endTime.substring(0, 4));
  435. int startMonth = Integer.parseInt(str_startTime.substring(5, 7));
  436. int endMonth = Integer.parseInt(str_endTime.substring(5, 7));
  437. int startDay = Integer.parseInt(str_startTime.substring(8));
  438. int endDay = Integer.parseInt(str_endTime.substring(8));
  439. // 开始时间
  440. Calendar start = Calendar.getInstance();
  441. start.set(startYear, startMonth - 1, startDay);
  442. // 结束时间
  443. Calendar end = Calendar.getInstance();
  444. end.set(endYear, endMonth - 1, endDay);
  445. // 日间隔数
  446. long rjg = (end.getTimeInMillis() - start.getTimeInMillis())
  447. / (1000 * 24 * 60 * 60);
  448. for (int i = 0; i <= rjg; i++) {
  449. if (i != 0) {
  450. startDay++;
  451. }
  452. switch (startMonth) {
  453. case 2:
  454. // 如果是闰年
  455. if (startYear % 4 == 0 && startYear % 100 != 0
  456. || startYear % 400 == 0) {
  457. if (startDay > 29) {
  458. startMonth++;
  459. startDay -= 29;
  460. }
  461. } else {
  462. if (startDay > 28) {
  463. startMonth++;
  464. startDay -= 28;
  465. }
  466. }
  467. // listTjTime.add(startYear+"-0"+startMonth+"-"+(startDay>9?startDay:"0"+startDay));
  468. break;
  469. case 4:
  470. if (startDay > 30) {
  471. startMonth++;
  472. startDay -= 30;
  473. }
  474. // listTjTime.add(startYear+"-0"+startMonth+"-"+(startDay>9?startDay:"0"+startDay));
  475. break;
  476. case 6:
  477. if (startDay > 30) {
  478. startMonth++;
  479. startDay -= 30;
  480. }
  481. // listTjTime.add(startYear+"-0"+startMonth+"-"+(startDay>9?startDay:"0"+startDay));
  482. break;
  483. case 9:
  484. if (startDay > 30) {
  485. startMonth++;
  486. startDay -= 30;
  487. //listTjTime.add(startYear + "-" + startMonth + "-0"
  488. // + startDay);
  489. } else {
  490. // listTjTime.add(startYear+"-0"+startMonth+"-"+(startDay>9?startDay:"0"+startDay));
  491. }
  492. break;
  493. case 11:
  494. if (startDay > 30) {
  495. startMonth++;
  496. startDay -= 30;
  497. } else {
  498. // listTjTime.add(startYear+"-"+startMonth+"-"+(startDay>9?startDay:"0"+startDay));
  499. }
  500. break;
  501. case 12:
  502. if (startDay > 31) {
  503. startYear++;
  504. startMonth = 1;
  505. startDay -= 31;
  506. }
  507. // listTjTime.add(startYear+"-"+(startMonth>9?startMonth:"0"+startMonth)+"-"+(startDay>9?startDay:"0"+startDay));
  508. break;
  509. default:
  510. if (startDay > 31) {
  511. startMonth++;
  512. startDay -= 31;
  513. }
  514. // listTjTime.add(startYear+"-"+(startMonth>9?startMonth:"0"+startMonth)+"-"+(startDay>9?startDay:"0"+startDay));
  515. break;
  516. }
  517. listTjTime.add(startYear + "-"
  518. + (startMonth > 9 ? startMonth : "0" + startMonth)
  519. + "-" + (startDay > 9 ? startDay : "0" + startDay));
  520. }
  521. }
  522. // 按月统计
  523. if ("1".equals(type)) {
  524. // 开始年
  525. int startYear = Integer.parseInt(str_startTime.substring(0, 4));
  526. // 结束年
  527. int endYear = Integer.parseInt(str_endTime.substring(0, 4));
  528. // 开始月
  529. int startMonth = Integer.parseInt(str_startTime.substring(5));
  530. // 结束月
  531. int endMonth = Integer.parseInt(str_endTime.substring(5));
  532. // 如果是同一年的
  533. if (startYear == endYear) {
  534. // 循环将从开始到结束的所有日期放到list中
  535. for (int i = 0; i <= endMonth - startMonth; i++) {
  536. if ((startMonth + i) >= 10) {
  537. listTjTime.add(startYear + "-" + (startMonth + i));
  538. } else {
  539. listTjTime.add(startYear + "-0" + (startMonth + i));
  540. }
  541. }
  542. return listTjTime;
  543. } else {
  544. // 年跨度差值
  545. int ncz = endYear - startYear;
  546. // 通过循环先将开始那一年的日期加到list中
  547. for (int i = 0; i <= 12 - startMonth; i++) {
  548. if ((startMonth + i) >= 10) {
  549. listTjTime.add(startYear + "-" + (startMonth + i));
  550. } else {
  551. listTjTime.add(startYear + "-0" + (startMonth + i));
  552. }
  553. }
  554. // 如果年跨度大于1
  555. if (ncz > 1) {
  556. // 循环开始和结束中间的年数
  557. for (int i = 1; i < ncz; i++) {
  558. // 循环12次,将一年的时间加到list
  559. for (int j = 1; j <= 12; j++) {
  560. if (j >= 10) {
  561. listTjTime.add((startYear + i) + "-" + j);
  562. } else {
  563. listTjTime.add((startYear + i) + "-0" + j);
  564. }
  565. }
  566. }
  567. }
  568. // 通过循环将结束那一年的日期加到list中
  569. for (int i = 1; i <= endMonth; i++) {
  570. if (i >= 10) {
  571. listTjTime.add(endYear + "-" + i);
  572. } else {
  573. listTjTime.add(endYear + "-0" + i);
  574. }
  575. }
  576. return listTjTime;
  577. }
  578. }
  579. // 按年统计
  580. if ("2".equals(type)) {
  581. int startYear = Integer.parseInt(str_startTime.substring(0, 4));
  582. int endYear = Integer.parseInt(str_endTime.substring(0, 4));
  583. for (int i = 0; i <= endYear - startYear; i++) {
  584. listTjTime.add(startYear + i + "");
  585. }
  586. return listTjTime;
  587. }
  588. return listTjTime;
  589. }
  590. /**
  591. * 获取当前天数是当年的第几天
  592. *
  593. * @return
  594. */
  595. public static String getCurrentDaysofYear() {
  596. SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
  597. String currentDay = format.format(new Date());
  598. return getDayIndexofYear(currentDay);
  599. }
  600. /**
  601. * 判断是否为闰年
  602. *
  603. * @param year
  604. * @return
  605. */
  606. public static boolean isLeapYear(int year) {
  607. // 判断是不是闰年
  608. if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {
  609. return true;
  610. }
  611. return false;
  612. }
  613. /**
  614. * 获得当月的天数
  615. *
  616. * @param month
  617. * 月份
  618. * @param isLeapYear
  619. * 是否为闰年
  620. * @return
  621. */
  622. public static int getDayofMonth(int month, boolean isLeapYear) {
  623. // 非闰年
  624. final int[] normal = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  625. // 闰年
  626. final int[] leapYear = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  627. if (month != 0 && !isLeapYear) {
  628. return normal[month - 1];
  629. }
  630. if (month != 0 && isLeapYear) {
  631. return leapYear[month - 1];
  632. }
  633. return 0;
  634. }
  635. public static int getDayofYear(int year) {
  636. if (isLeapYear(year))
  637. return 366;
  638. return 365;
  639. }
  640. /**
  641. * 根据日期获取日期在当年中的天数
  642. *
  643. * @param date
  644. * @return
  645. */
  646. public static String getDayIndexofYear(String date) {
  647. int year = 0;
  648. int month = 0;
  649. int day = 0;
  650. String strIndex = "";
  651. boolean isLeapYear = false;
  652. int index = 0;
  653. if (date != null) {
  654. String[] timeArray = date.split("-");
  655. if (timeArray != null && timeArray.length > 0) {
  656. year = Integer.valueOf(timeArray[0]);
  657. month = Integer.valueOf(timeArray[1]);
  658. day = Integer.valueOf(timeArray[2]);
  659. isLeapYear = isLeapYear(year);
  660. for (int i = 1; i < month; i++) {
  661. index += getDayofMonth(i, isLeapYear);
  662. }
  663. index += day;
  664. if (index < 10) {
  665. strIndex = "00" + String.valueOf(index);
  666. } else if (index < 100 && index >= 10) {
  667. strIndex = "0" + String.valueOf(index);
  668. } else {
  669. strIndex = index + "";
  670. }
  671. return strIndex;
  672. }
  673. }
  674. return strIndex;
  675. }
  676. /**
  677. * 获取当前时间,以分钟计算
  678. *
  679. * @return
  680. */
  681. private int index = 0;
  682. public static Date getMondayOfThisWeek() {
  683. Calendar c = Calendar.getInstance();
  684. int day_of_week = c.get(Calendar.DAY_OF_WEEK) - 1;
  685. if (day_of_week == 0)
  686. day_of_week = 7;
  687. c.add(Calendar.DATE, -day_of_week + 1);
  688. return c.getTime();
  689. }
  690. public int getIndex() {
  691. return index;
  692. }
  693. public void setIndex(int index) {
  694. this.index = index;
  695. }
  696. public static String getMintuesFromRoot() {
  697. Calendar cal = Calendar.getInstance();
  698. cal.setTime(new Date());
  699. int year = cal.get(Calendar.YEAR);
  700. int day = 0;
  701. int hours = cal.get(Calendar.HOUR_OF_DAY);
  702. int minutes = cal.get(Calendar.MINUTE);
  703. int seconds = cal.get(Calendar.SECOND);
  704. if (year > 2020)
  705. TIME_ROOT = 2020;
  706. for (int i = TIME_ROOT; i < year; i++) {
  707. day += getDayofYear(i);
  708. }
  709. day += Integer.valueOf(getCurrentDaysofYear());
  710. minutes = day * hours * minutes;
  711. String mins = String.valueOf(minutes);
  712. String sec = String.valueOf(seconds);
  713. switch (mins.length()) {
  714. case 4:
  715. mins = "0".concat(mins);
  716. case 5:
  717. mins = "0".concat(mins);
  718. case 6:
  719. mins = mins.concat(sec.substring(sec.length() - 1, sec.length()));
  720. }
  721. return mins;
  722. }
  723. /**
  724. * 获得一个时间的前段时间
  725. *
  726. * @param days
  727. * 跨度
  728. * @param date
  729. * 当前时间 yyyy-MM-dd/yyyy-MM/yyyy
  730. * @param type
  731. * 类型(0日,1月,2年)
  732. * @return
  733. */
  734. public static String getTimeBefore(int days, String date, String type) {
  735. if ("0".equals(type)) {
  736. Date myDate = null;
  737. SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
  738. try {
  739. myDate = formatter.parse(date);
  740. } catch (ParseException e) {
  741. // TODO Auto-generated catch block
  742. e.printStackTrace();
  743. }
  744. if (myDate != null) {
  745. long myTime = (myDate.getTime() / 1000) - 60 * 60 * 24 * days;
  746. myDate.setTime(myTime * 1000);
  747. String mDate = formatter.format(myDate);
  748. return mDate;
  749. }
  750. }
  751. if ("1".equals(type)) {
  752. try {
  753. int month = Integer.valueOf(date.substring(5, 7));
  754. int year = Integer.valueOf(date.substring(0, 4));
  755. if (days - month > 0) {
  756. // 年跨度
  757. int step = (days - month) / 12 + 1;
  758. // 除去整年后的余月
  759. int m = (days - month) % 12;
  760. year = year - step;
  761. month = 12 - m;
  762. } else {
  763. month = month - days;
  764. }
  765. String newDate = year + "-" + (month > 9 ? month : "0" + month);
  766. return newDate;
  767. } catch (NumberFormatException e) {
  768. // TODO Auto-generated catch block
  769. e.printStackTrace();
  770. }
  771. }
  772. if ("2".equals(type)) {
  773. int year = Integer.valueOf(date.substring(0, 4));
  774. String newDate = (year - days) + "";
  775. return newDate;
  776. }
  777. return "";
  778. }
  779. public static Calendar string2Date(String timeStr, String format) {
  780. SimpleDateFormat dateFormatter = new SimpleDateFormat(format);
  781. Calendar calendar = Calendar.getInstance();
  782. try {
  783. Date date = dateFormatter.parse(timeStr);
  784. calendar.setTime(date);
  785. } catch (Exception e) {
  786. e.printStackTrace();
  787. }
  788. return calendar;
  789. }
  790. public static boolean isValidDate(String str) {
  791. boolean convertSuccess = true;
  792. SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
  793. try {
  794. format.setLenient(false);
  795. format.parse(str);
  796. } catch (ParseException e) {
  797. // e.printStackTrace();
  798. // 如果throw java.text.ParseException或者NullPointerException,就说明格式不对
  799. convertSuccess = false;
  800. }
  801. return convertSuccess;
  802. }
  803. public static String getTimeAfter(int days, Date myDate) {
  804. SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
  805. Calendar now = Calendar.getInstance();
  806. now.setTime(myDate);
  807. now.set(Calendar.DATE, now.get(Calendar.DATE) + days);
  808. String mDate = formatter.format(now.getTime());
  809. return mDate;
  810. }
  811. public static String getMonthStr(int month) {
  812. if (month < 10) {
  813. return "0" + String.valueOf(month);
  814. } else {
  815. return String.valueOf(month);
  816. }
  817. }
  818. /**
  819. * 判断时间是否在时间段内
  820. * @param date
  821. * @param timeStart
  822. * @param timeEnd
  823. * @return
  824. */
  825. public static boolean isInDate(Date date, String timeStart, String timeEnd) {
  826. SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
  827. String strDate = sdf.format(date);
  828. // 截取当前时间时分
  829. String[] dateArr = strDate.split(":");
  830. int strDateH = Integer.parseInt(dateArr[0]);
  831. int strDateM = Integer.parseInt(dateArr[1]);
  832. int strDateT = strDateH * 60 + strDateM;
  833. // 截取开始时间时分
  834. String[] startArr = timeStart.split(":");
  835. int strDateBeginH = Integer.parseInt(startArr[0]);
  836. int strDateBeginM = Integer.parseInt(startArr[1]);
  837. int strDateBeginT = strDateBeginH * 60 + strDateBeginM;
  838. // 截取结束时间时分
  839. String[] endArr = timeEnd.split(":");
  840. int strDateEndH = Integer.parseInt(endArr[0]);
  841. int strDateEndM = Integer.parseInt(endArr[1]);
  842. int strDateEndT = strDateEndH * 60 + strDateEndM;
  843. if (strDateT >= strDateBeginT && strDateT <= strDateEndT) {
  844. return true;
  845. } else {
  846. return false;
  847. }
  848. }
  849. /**
  850. * 获取当前月的第一天
  851. * @return
  852. */
  853. public static Date getFirstDayForCurrMonth(){
  854. Calendar cale = Calendar.getInstance();
  855. cale.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
  856. return cale.getTime();
  857. }
  858. /**
  859. * 获取当前月的第一天
  860. * @return
  861. */
  862. public static Date getFirstDayForCurrMonth(Date date){
  863. Calendar cale = Calendar.getInstance();
  864. cale.setTime(date);
  865. cale.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
  866. return cale.getTime();
  867. }
  868. /**
  869. * 获取指定月的最后一天
  870. * @return
  871. */
  872. public static Date getLastDayForMonth(Date date){
  873. Calendar ca = Calendar.getInstance();
  874. ca.setTime(date);
  875. ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
  876. return DateUtils.getDateFromString(DateUtils.date2String(ca.getTime(),"yyyy-MM-dd")+" 23:59:59","yyyy-MM-dd HH:mm:ss").getTime();
  877. }
  878. /**
  879. * 获取指定月的最后一天
  880. * @return
  881. */
  882. public static Date getLastDayForMonth(String date){
  883. try {
  884. Calendar ca = Calendar.getInstance();
  885. ca.setTime(new SimpleDateFormat("yyyy-MM-dd").parse(date));
  886. ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
  887. return ca.getTime();
  888. } catch (ParseException e) {
  889. e.printStackTrace();
  890. }
  891. return null;
  892. }
  893. /**
  894. * 获取指定日期n个月后的最后一天
  895. * @return
  896. */
  897. public static Date getLastDayForMonth(Date date, int amount){
  898. Calendar ca = Calendar.getInstance();
  899. ca.setTime(date);
  900. ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
  901. ca.add(Calendar.MONTH, amount);
  902. return ca.getTime();
  903. }
  904. /**
  905. * 取得指定月的天数
  906. * */
  907. public static int getMonthDayCount(Date date) {
  908. Calendar a = Calendar.getInstance();
  909. a.setTime(date);
  910. a.set(Calendar.DATE, 1);//把日期设置为当月第一天
  911. a.roll(Calendar.DATE, -1);//日期回滚一天,也就是最后一天
  912. int maxDate = a.get(Calendar.DATE);
  913. return maxDate;
  914. }
  915. /**
  916. * 计算两个日期相隔多少天
  917. * @param smdate
  918. * @param bdate
  919. * @return
  920. * @throws ParseException
  921. */
  922. public static int daysBetween(Date smdate,Date bdate) {
  923. try {
  924. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
  925. smdate=sdf.parse(sdf.format(smdate));
  926. bdate=sdf.parse(sdf.format(bdate));
  927. Calendar cal = Calendar.getInstance();
  928. cal.setTime(smdate);
  929. long time1 = cal.getTimeInMillis();
  930. cal.setTime(bdate);
  931. long time2 = cal.getTimeInMillis();
  932. long between_days=(time2-time1)/(1000*3600*24);
  933. return Integer.parseInt(String.valueOf(between_days));
  934. }catch (Exception e){
  935. e.printStackTrace();
  936. }
  937. return 0;
  938. }
  939. /**
  940. * 获取指定日期n个月后的第一天
  941. * @return
  942. */
  943. public static Date getFirstDayOfNextMonth(Date date,int amount){
  944. Calendar calendar = Calendar.getInstance();
  945. calendar.setTime(date);
  946. calendar.set(Calendar.DAY_OF_MONTH,1);
  947. calendar.add(Calendar.MONTH, amount);
  948. return calendar.getTime();
  949. }
  950. /**
  951. * 获取指定日期n个月后的最后一天
  952. * @return
  953. */
  954. public static Date getLastDayOfNextMonth(Date date,int amount){
  955. Calendar calendar = Calendar.getInstance();
  956. calendar.setTime(date);
  957. calendar.set(Calendar.DAY_OF_MONTH,1);
  958. calendar.add(Calendar.MONTH, amount);
  959. Date d = calendar.getTime();
  960. return getFirstDayForCurrMonth(d);
  961. }
  962. /**
  963. * 判断时间是否在时间段内
  964. * @param nowTime
  965. * @param beginTime
  966. * @param endTime
  967. * @return
  968. */
  969. public static boolean belongCalendar(Date nowTime, Date beginTime, Date endTime) {
  970. Calendar date = Calendar.getInstance();
  971. date.setTime(nowTime);
  972. Calendar begin = Calendar.getInstance();
  973. begin.setTime(beginTime);
  974. Calendar end = Calendar.getInstance();
  975. end.setTime(endTime);
  976. if (date.after(begin) && date.before(end)) {
  977. return true;
  978. } else if (nowTime.compareTo(beginTime) == 0 || nowTime.compareTo(endTime) == 0) {
  979. return true;
  980. } else {
  981. return false;
  982. }
  983. }
  984. /**
  985. * 计算两个时间 相差n个月 零n天
  986. * @return
  987. */
  988. public static int[] getDiff(Date startDate,Date endDate) {
  989. SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
  990. if(sd.format(startDate).equals(sd.format(endDate))){
  991. return new int[] {0, 1};
  992. }
  993. ZoneId zone = ZoneId.systemDefault();
  994. LocalDateTime localDateTime = LocalDateTime.ofInstant(startDate.toInstant(), zone);
  995. LocalDate start = localDateTime.toLocalDate();
  996. localDateTime = LocalDateTime.ofInstant(endDate.toInstant(), zone);
  997. LocalDate end = localDateTime.toLocalDate();
  998. if (!start.isBefore(end)) {
  999. throw new IllegalArgumentException("Start must not be before end.");
  1000. }
  1001. Period period = Period.between(start, end);
  1002. int years = period.getYears();
  1003. int months = period.getMonths();
  1004. int days = period.getDays();
  1005. return new int[] {years * 12 + months, days};
  1006. }
  1007. /**
  1008. * 获取设置后的时间
  1009. * @param date
  1010. * @param type Calendar.DATE Calendar.MONTH
  1011. * @param set
  1012. * @return
  1013. */
  1014. public static Date getDaySet(Date date,int type,int set){
  1015. Calendar cale = Calendar.getInstance();
  1016. cale.setTime(date);
  1017. cale.add(type,set);
  1018. return cale.getTime();
  1019. }
  1020. /**
  1021. * 判断两日期是否同一个月
  1022. * @param date1
  1023. * @param date2
  1024. * @return
  1025. */
  1026. public static boolean isSameMonth(Date date1, Date date2) {
  1027. Calendar calendar1 = Calendar.getInstance();
  1028. calendar1.setTime(date1);
  1029. Calendar calendar2 = Calendar.getInstance();
  1030. calendar2.setTime(date2);
  1031. int year1 = calendar1.get(Calendar.YEAR);
  1032. int year2 = calendar2.get(Calendar.YEAR);
  1033. int month1 = calendar1.get(Calendar.MONTH);
  1034. int month2 = calendar2.get(Calendar.MONTH);
  1035. System.out.println(year1 + " " + month1);
  1036. System.out.println(year2 + " " + month2);
  1037. return calendar1.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR) && calendar1.get(Calendar.MONTH) == calendar2.get(Calendar.MONTH);
  1038. }
  1039. }