java Date时间格式工具类DateUtil

权声明：本文为博主原创文章，未经博主允许不得转载。

[java] view plain copy
  1. package com.common;  
  2.   
  3.   
  4. import java.sql.Timestamp;  
  5. import java.text.DateFormat;  
  6. import java.text.ParseException;  
  7. import java.text.SimpleDateFormat;  
  8. import java.util.ArrayList;  
  9. import java.util.Calendar;  
  10. import java.util.Date;  
  11. import java.util.GregorianCalendar;  
  12. import java.util.HashMap;  
  13. import java.util.Iterator;  
  14. import java.util.LinkedHashMap;  
  15. import java.util.List;  
  16.   
  17. /** 
  18.  * 日期工具类 
  19.  */  
  20. public class DateUtil{  
  21.       
  22.     // ==格式到年==   
  23.     /** 
  24.      * 日期格式，年份，例如：2004，2008 
  25.      */  
  26.     public static final String DATE_FORMAT_YYYY = "yyyy";  
  27.       
  28.       
  29.     // ==格式到年月 ==   
  30.     /** 
  31.      * 日期格式，年份和月份，例如：200707，200808 
  32.      */  
  33.     public static final String DATE_FORMAT_YYYYMM = "yyyyMM";  
  34.   
  35.     /** 
  36.      * 日期格式，年份和月份，例如：200707，2008-08 
  37.      */  
  38.     public static final String DATE_FORMAT_YYYY_MM = "yyyy-MM";  
  39.   
  40.       
  41.     // ==格式到年月日==   
  42.     /** 
  43.      * 日期格式，年月日，例如：050630，080808 
  44.      */  
  45.     public static final String DATE_FORMAT_YYMMDD = "yyMMdd";  
  46.   
  47.     /** 
  48.      * 日期格式，年月日，用横杠分开，例如：06-12-25，08-08-08 
  49.      */  
  50.     public static final String DATE_FORMAT_YY_MM_DD = "yy-MM-dd";  
  51.   
  52.     /** 
  53.      * 日期格式，年月日，例如：20050630，20080808 
  54.      */  
  55.     public static final String DATE_FORMAT_YYYYMMDD = "yyyyMMdd";  
  56.       
  57.     /** 
  58.      * 日期格式，年月日，用横杠分开，例如：2006-12-25，2008-08-08 
  59.      */  
  60.     public static final String DATE_FORMAT_YYYY_MM_DD = "yyyy-MM-dd";  
  61.       
  62.     /** 
  63.      * 日期格式，年月日，例如：2016.10.05 
  64.      */  
  65.     public static final String DATE_FORMAT_POINTYYYYMMDD = "yyyy.MM.dd";  
  66.       
  67.     /** 
  68.      * 日期格式，年月日，例如：2016年10月05日 
  69.      */  
  70.     public static final String DATE_TIME_FORMAT_YYYY年MM月DD日 = "yyyy年MM月dd日";  
  71.       
  72.       
  73.     // ==格式到年月日 时分 ==   
  74.       
  75.     /** 
  76.      * 日期格式，年月日时分，例如：200506301210，200808081210 
  77.      */  
  78.     public static final String DATE_FORMAT_YYYYMMDDHHmm = "yyyyMMddHHmm";  
  79.   
  80.     /** 
  81.      * 日期格式，年月日时分，例如：20001230 12:00，20080808 20:08 
  82.      */  
  83.     public static final String DATE_TIME_FORMAT_YYYYMMDD_HH_MI = "yyyyMMdd HH:mm";  
  84.       
  85.     /** 
  86.      * 日期格式，年月日时分，例如：2000-12-30 12:00，2008-08-08 20:08 
  87.      */  
  88.     public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI = "yyyy-MM-dd HH:mm";  
  89.       
  90.       
  91.     // ==格式到年月日 时分秒==   
  92.     /** 
  93.      * 日期格式，年月日时分秒，例如：20001230120000，20080808200808 
  94.      */  
  95.     public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISS = "yyyyMMddHHmmss";  
  96.       
  97.     /** 
  98.      * 日期格式，年月日时分秒，年月日用横杠分开，时分秒用冒号分开 
  99.      * 例如：2005-05-10 23：20：00，2008-08-08 20:08:08 
  100.      */  
  101.     public static final String DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS = "yyyy-MM-dd HH:mm:ss";  
  102.   
  103.       
  104.     // ==格式到年月日 时分秒 毫秒==   
  105.     /** 
  106.      * 日期格式，年月日时分秒毫秒，例如：20001230120000123，20080808200808456 
  107.      */  
  108.     public static final String DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS = "yyyyMMddHHmmssSSS";  
  109.       
  110.       
  111.     // ==特殊格式==  
  112.     /** 
  113.      * 日期格式，月日时分，例如：10-05 12:00 
  114.      */  
  115.     public static final String DATE_FORMAT_MMDDHHMI = "MM-dd HH:mm";  
  116.   
  117.       
  118.     /* ************工具方法***************   */  
  119.       
  120.     /**  
  121.      * 获取某日期的年份 
  122.      * @param date  
  123.      * @return  
  124.      */  
  125.     public static Integer getYear(Date date) {  
  126.         Calendar cal = Calendar.getInstance();  
  127.         cal.setTime(date);  
  128.         return cal.get(Calendar.YEAR);  
  129.     }    
  130.       
  131.     /** 
  132.      * 获取某日期的月份 
  133.      * @param date 
  134.      * @return 
  135.      */  
  136.     public static Integer getMonth(Date date) {  
  137.         Calendar cal = Calendar.getInstance();  
  138.         cal.setTime(date);  
  139.         return cal.get(Calendar.MONTH) + 1;  
  140.     }  
  141.       
  142.     /** 
  143.      * 获取某日期的日数 
  144.      * @param date 
  145.      * @return 
  146.      */  
  147.     public static Integer getDay(Date date){  
  148.         Calendar cal = Calendar.getInstance();  
  149.         cal.setTime(date);  
  150.          int day=cal.get(Calendar.DATE);//获取日  
  151.          return day;  
  152.     }  
  153.       
  154.     /** 
  155.      * 格式化Date时间 
  156.      * @param time Date类型时间 
  157.      * @param timeFromat String类型格式 
  158.      * @return 格式化后的字符串 
  159.      */  
  160.     public static String parseDateToStr(Date time, String timeFromat){  
  161.         DateFormat dateFormat=new SimpleDateFormat(timeFromat);  
  162.         return dateFormat.format(time);  
  163.     }  
  164.       
  165.     /** 
  166.      * 格式化Timestamp时间 
  167.      * @param timestamp Timestamp类型时间 
  168.      * @param timeFromat 
  169.      * @return 格式化后的字符串 
  170.      */  
  171.     public static String parseTimestampToStr(Timestamp timestamp,String timeFromat){  
  172.         SimpleDateFormat df = new SimpleDateFormat(timeFromat);  
  173.         return df.format(timestamp);  
  174.     }  
  175.       
  176.     /** 
  177.      * 格式化Date时间 
  178.      * @param time Date类型时间 
  179.      * @param timeFromat String类型格式 
  180.      * @param defaultValue 默认值为当前时间Date 
  181.      * @return 格式化后的字符串 
  182.      */  
  183.     public static String parseDateToStr(Date time, String timeFromat, final Date defaultValue){  
  184.         try{  
  185.             DateFormat dateFormat=new SimpleDateFormat(timeFromat);  
  186.             return dateFormat.format(time);  
  187.         }catch (Exception e){  
  188.             if(defaultValue!=null)  
  189.                 return parseDateToStr(defaultValue, timeFromat);  
  190.             else  
  191.                 return parseDateToStr(new Date(), timeFromat);  
  192.         }  
  193.     }  
  194.       
  195.     /** 
  196.      * 格式化Date时间 
  197.      * @param time Date类型时间 
  198.      * @param timeFromat String类型格式 
  199.      * @param defaultValue 默认时间值String类型 
  200.      * @return 格式化后的字符串 
  201.      */  
  202.     public static String parseDateToStr(Date time, String timeFromat, final String defaultValue){  
  203.         try{  
  204.             DateFormat dateFormat=new SimpleDateFormat(timeFromat);  
  205.             return dateFormat.format(time);  
  206.         }catch (Exception e){  
  207.             return defaultValue;  
  208.         }  
  209.     }  
  210.       
  211.     /** 
  212.      * 格式化String时间 
  213.      * @param time String类型时间 
  214.      * @param timeFromat String类型格式 
  215.      * @return 格式化后的Date日期 
  216.      */  
  217.     public static Date parseStrToDate(String time, String timeFromat) {  
  218.         if (time == null || time.equals("")) {  
  219.             return null;  
  220.         }  
  221.           
  222.         Date date=null;  
  223.         try{  
  224.             DateFormat dateFormat=new SimpleDateFormat(timeFromat);  
  225.             date=dateFormat.parse(time);  
  226.         }catch(Exception e){  
  227.               
  228.         }  
  229.         return date;  
  230.     }  
  231.       
  232.     /** 
  233.      * 格式化String时间 
  234.      * @param strTime String类型时间 
  235.      * @param timeFromat String类型格式 
  236.      * @param defaultValue 异常时返回的默认值 
  237.      * @return 
  238.      */  
  239.     public static Date parseStrToDate(String strTime, String timeFromat,  
  240.             Date defaultValue) {  
  241.         try {  
  242.             DateFormat dateFormat = new SimpleDateFormat(timeFromat);  
  243.             return dateFormat.parse(strTime);  
  244.         } catch (Exception e) {  
  245.             return defaultValue;  
  246.         }  
  247.     }  
  248.       
  249.     /** 
  250.      * 当strTime为2008-9时返回为2008-9-1 00:00格式日期时间，无法转换返回null. 
  251.      * @param strTime 
  252.      * @return 
  253.      */  
  254.     public static Date strToDate(String strTime) {  
  255.         if(strTime==null || strTime.trim().length()<=0)  
  256.             return null;  
  257.           
  258.         Date date = null;  
  259.         List<String> list = new ArrayList<String>(0);  
  260.           
  261.         list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);  
  262.         list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);  
  263.         list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI);  
  264.         list.add(DATE_TIME_FORMAT_YYYYMMDD_HH_MI);  
  265.         list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISS);  
  266.         list.add(DATE_FORMAT_YYYY_MM_DD);  
  267.         //list.add(DATE_FORMAT_YY_MM_DD);  
  268.         list.add(DATE_FORMAT_YYYYMMDD);  
  269.         list.add(DATE_FORMAT_YYYY_MM);  
  270.         list.add(DATE_FORMAT_YYYYMM);  
  271.         list.add(DATE_FORMAT_YYYY);  
  272.           
  273.           
  274.         for (Iterator iter = list.iterator(); iter.hasNext();) {  
  275.             String format = (String) iter.next();  
  276.             if(strTime.indexOf("-")>0 && format.indexOf("-")<0)  
  277.                 continue;  
  278.             if(strTime.indexOf("-")<0 && format.indexOf("-")>0)  
  279.                 continue;  
  280.             if(strTime.length()>format.length())  
  281.                 continue;  
  282.             date = parseStrToDate(strTime, format);  
  283.             if (date != null)  
  284.                 break;  
  285.         }  
  286.   
  287.         return date;  
  288.     }  
  289.       
  290.     /** 
  291.      * 解析两个日期之间的所有月份 
  292.      * @param beginDateStr 开始日期，至少精确到yyyy-MM 
  293.      * @param endDateStr 结束日期，至少精确到yyyy-MM 
  294.      * @return yyyy-MM日期集合 
  295.      */    
  296.     public static List<String> getMonthListOfDate(String beginDateStr, String endDateStr) {    
  297.         // 指定要解析的时间格式    
  298.         SimpleDateFormat f = new SimpleDateFormat("yyyy-MM");    
  299.         // 返回的月份列表    
  300.         String sRet = "";    
  301.     
  302.         // 定义一些变量    
  303.         Date beginDate = null;    
  304.         Date endDate = null;    
  305.     
  306.         GregorianCalendar beginGC = null;    
  307.         GregorianCalendar endGC = null;    
  308.         List<String> list = new ArrayList<String>();    
  309.     
  310.         try {    
  311.             // 将字符串parse成日期    
  312.             beginDate = f.parse(beginDateStr);    
  313.             endDate = f.parse(endDateStr);    
  314.     
  315.             // 设置日历    
  316.             beginGC = new GregorianCalendar();    
  317.             beginGC.setTime(beginDate);    
  318.     
  319.             endGC = new GregorianCalendar();    
  320.             endGC.setTime(endDate);    
  321.     
  322.             // 直到两个时间相同    
  323.             while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {    
  324.                 sRet = beginGC.get(Calendar.YEAR) + "-"    
  325.                         + (beginGC.get(Calendar.MONTH) + 1);    
  326.                 list.add(sRet);    
  327.                 // 以月为单位，增加时间    
  328.                 beginGC.add(Calendar.MONTH, 1);    
  329.             }    
  330.             return list;    
  331.         } catch (Exception e) {    
  332.             e.printStackTrace();    
  333.             return null;    
  334.         }    
  335.     }    
  336.     
  337.     /**  
  338.      * 解析两个日期段之间的所有日期 
  339.      * @param beginDateStr 开始日期  ，至少精确到yyyy-MM-dd 
  340.      * @param endDateStr 结束日期  ，至少精确到yyyy-MM-dd 
  341.      * @return yyyy-MM-dd日期集合 
  342.      */    
  343.     public static List<String> getDayListOfDate(String beginDateStr, String endDateStr) {    
  344.         // 指定要解析的时间格式    
  345.         SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");    
  346.     
  347.         // 定义一些变量    
  348.         Date beginDate = null;    
  349.         Date endDate = null;    
  350.     
  351.         Calendar beginGC = null;    
  352.         Calendar endGC = null;    
  353.         List<String> list = new ArrayList<String>();    
  354.     
  355.         try {    
  356.             // 将字符串parse成日期    
  357.             beginDate = f.parse(beginDateStr);    
  358.             endDate = f.parse(endDateStr);    
  359.     
  360.             // 设置日历    
  361.             beginGC = Calendar.getInstance();    
  362.             beginGC.setTime(beginDate);    
  363.     
  364.             endGC = Calendar.getInstance();    
  365.             endGC.setTime(endDate);    
  366.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");    
  367.     
  368.             // 直到两个时间相同    
  369.             while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {    
  370.     
  371.                 list.add(sdf.format(beginGC.getTime()));    
  372.                 // 以日为单位，增加时间    
  373.                 beginGC.add(Calendar.DAY_OF_MONTH, 1);    
  374.             }    
  375.             return list;    
  376.         } catch (Exception e) {    
  377.             e.printStackTrace();    
  378.             return null;    
  379.         }    
  380.     }    
  381.     
  382.     /** 
  383.      * 获取当下年份指定前后数量的年份集合 
  384.      * @param before 当下年份前年数 
  385.      * @param behind 当下年份后年数 
  386.      * @return 集合 
  387.      */  
  388.     public static List<Integer> getYearListOfYears(int before,int behind) {  
  389.         if (before<0 || behind<0) {  
  390.             return null;  
  391.         }  
  392.         List<Integer> list = new ArrayList<Integer>();    
  393.         Calendar c = null;    
  394.         c = Calendar.getInstance();    
  395.         c.setTime(new Date());    
  396.         int currYear = Calendar.getInstance().get(Calendar.YEAR);    
  397.     
  398.         int startYear = currYear - before;    
  399.         int endYear = currYear + behind;    
  400.         for (int i = startYear; i < endYear; i++) {    
  401.             list.add(Integer.valueOf(i));    
  402.         }    
  403.         return list;    
  404.     }  
  405.       
  406.     /**  
  407.      * 获取当前日期是一年中第几周  
  408.      * @param date  
  409.      * @return  
  410.      */    
  411.     public static Integer getWeekthOfYear(Date date) {    
  412.         Calendar c = new GregorianCalendar();    
  413.         c.setFirstDayOfWeek(Calendar.MONDAY);    
  414.         c.setMinimalDaysInFirstWeek(7);    
  415.         c.setTime(date);    
  416.     
  417.         return c.get(Calendar.WEEK_OF_YEAR);    
  418.     }   
  419.   
  420.     /** 
  421.      * 获取某一年各星期的始终时间 
  422.      * 实例：getWeekList(2016)，第52周(从2016-12-26至2017-01-01) 
  423.      * @param 年份 
  424.      * @return 
  425.      */    
  426.     public static HashMap<Integer,String> getWeekTimeOfYear(int year) {    
  427.         HashMap<Integer,String> map = new LinkedHashMap<Integer,String>();    
  428.         Calendar c = new GregorianCalendar();    
  429.         c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);    
  430.         int count = getWeekthOfYear(c.getTime());    
  431.     
  432.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");    
  433.         String dayOfWeekStart = "";    
  434.         String dayOfWeekEnd = "";    
  435.         for (int i = 1; i <= count; i++) {    
  436.             dayOfWeekStart = sdf.format(getFirstDayOfWeek(year, i));    
  437.             dayOfWeekEnd = sdf.format(getLastDayOfWeek(year, i));    
  438.             map.put(Integer.valueOf(i), "第"+i+"周(从"+dayOfWeekStart + "至" + dayOfWeekEnd+")");    
  439.         }    
  440.         return map;    
  441.     
  442.     }    
  443.         
  444.     /**  
  445.      * 获取某一年的总周数  
  446.      * @param year  
  447.      * @return  
  448.      */    
  449.     public static Integer getWeekCountOfYear(int year){    
  450.         Calendar c = new GregorianCalendar();    
  451.         c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);    
  452.         int count = getWeekthOfYear(c.getTime());    
  453.         return count;    
  454.     }    
  455.       
  456.     /**  
  457.      * 获取指定日期所在周的第一天  
  458.      * @param date  
  459.      * @return  
  460.      */    
  461.     public static Date getFirstDayOfWeek(Date date) {    
  462.         Calendar c = new GregorianCalendar();    
  463.         c.setFirstDayOfWeek(Calendar.MONDAY);    
  464.         c.setTime(date);    
  465.         c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday    
  466.         return c.getTime();    
  467.     }    
  468.     
  469.     /**  
  470.      * 获取指定日期所在周的最后一天  
  471.      * @param date  
  472.      * @return  
  473.      */    
  474.     public static Date getLastDayOfWeek(Date date) {  
  475.         Calendar c = new GregorianCalendar();  
  476.         c.setFirstDayOfWeek(Calendar.MONDAY);  
  477.         c.setTime(date);  
  478.         c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday  
  479.         return c.getTime();  
  480.     }  
  481.     
  482.     /**  
  483.      * 获取某年某周的第一天  
  484.      * @param year 目标年份 
  485.      * @param week 目标周数 
  486.      * @return  
  487.      */    
  488.     public static Date getFirstDayOfWeek(int year, int week) {    
  489.         Calendar c = new GregorianCalendar();    
  490.         c.set(Calendar.YEAR, year);    
  491.         c.set(Calendar.MONTH, Calendar.JANUARY);    
  492.         c.set(Calendar.DATE, 1);    
  493.     
  494.         Calendar cal = (GregorianCalendar) c.clone();  
  495.         cal.add(Calendar.DATE, week * 7);    
  496.     
  497.         return getFirstDayOfWeek(cal.getTime());    
  498.     }    
  499.     
  500.     /**  
  501.      * 获取某年某周的最后一天  
  502.      * @param year 目标年份 
  503.      * @param week 目标周数 
  504.      * @return  
  505.      */    
  506.     public static Date getLastDayOfWeek(int year, int week) {    
  507.         Calendar c = new GregorianCalendar();    
  508.         c.set(Calendar.YEAR, year);    
  509.         c.set(Calendar.MONTH, Calendar.JANUARY);    
  510.         c.set(Calendar.DATE, 1);    
  511.     
  512.         Calendar cal = (GregorianCalendar) c.clone();    
  513.         cal.add(Calendar.DATE, week * 7);    
  514.     
  515.         return getLastDayOfWeek(cal.getTime());    
  516.     }    
  517.         
  518.     /**  
  519.      * 获取某年某月的第一天  
  520.      * @param year 目标年份 
  521.      * @param month 目标月份 
  522.      * @return  
  523.      */    
  524.     public static Date getFirstDayOfMonth(int year,int month){    
  525.         month = month-1;    
  526.         Calendar   c   =   Calendar.getInstance();       
  527.         c.set(Calendar.YEAR, year);    
  528.         c.set(Calendar.MONTH, month);    
  529.             
  530.         int day = c.getActualMinimum(c.DAY_OF_MONTH);    
  531.     
  532.         c.set(Calendar.DAY_OF_MONTH, day);  
  533.         c.set(Calendar.HOUR_OF_DAY, 0);  
  534.         c.set(Calendar.MINUTE, 0);  
  535.         c.set(Calendar.SECOND, 0);  
  536.         c.set(Calendar.MILLISECOND, 0);  
  537.         return c.getTime();  
  538.     }    
  539.         
  540.     /**  
  541.      * 获取某年某月的最后一天  
  542.      * @param year 目标年份 
  543.      * @param month 目标月份 
  544.      * @return  
  545.      */    
  546.     public static Date getLastDayOfMonth(int year,int month){    
  547.         month = month-1;    
  548.         Calendar   c   =   Calendar.getInstance();       
  549.         c.set(Calendar.YEAR, year);    
  550.         c.set(Calendar.MONTH, month);    
  551.         int day = c.getActualMaximum(c.DAY_OF_MONTH);    
  552.         c.set(Calendar.DAY_OF_MONTH, day);  
  553.         c.set(Calendar.HOUR_OF_DAY, 23);  
  554.         c.set(Calendar.MINUTE, 59);  
  555.         c.set(Calendar.SECOND, 59);  
  556.         c.set(Calendar.MILLISECOND, 999);  
  557.         return c.getTime();    
  558.     }    
  559.     
  560.     /**  
  561.      * 获取某个日期为星期几  
  562.      * @param date  
  563.      * @return String "星期*" 
  564.      */    
  565.     public static String getDayWeekOfDate1(Date date) {    
  566.          String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};  
  567.          Calendar cal = Calendar.getInstance();  
  568.          cal.setTime(date);  
  569.   
  570.          int w = cal.get(Calendar.DAY_OF_WEEK) - 1;  
  571.          if (w < 0)  
  572.              w = 0;  
  573.            
  574.          return weekDays[w];  
  575.     }    
  576.       
  577.     /** 
  578.      * 获得指定日期的星期几数 
  579.      * @param date 
  580.      * @return int  
  581.      */   
  582.     public static Integer getDayWeekOfDate2(Date date){    
  583.         Calendar aCalendar = Calendar.getInstance();    
  584.         aCalendar.setTime(date);       
  585.         int weekDay = aCalendar.get(Calendar.DAY_OF_WEEK);       
  586.         return weekDay;  
  587.     }  
  588.       
  589.     /** 
  590.      * 验证字符串是否为日期 
  591.      * 验证格式:YYYYMMDD、YYYY_MM_DD、YYYYMMDDHHMISS、YYYYMMDD_HH_MI、YYYY_MM_DD_HH_MI、YYYYMMDDHHMISSSSS、YYYY_MM_DD_HH_MI_SS 
  592.      * @param strTime 
  593.      * @return null时返回false;true为日期，false不为日期 
  594.      */  
  595.     public static boolean validateIsDate(String strTime) {  
  596.         if (strTime == null || strTime.trim().length() <= 0)  
  597.             return false;  
  598.           
  599.         Date date = null;  
  600.         List<String> list = new ArrayList<String>(0);  
  601.           
  602.         list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);  
  603.         list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISSSSS);  
  604.         list.add(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI);  
  605.         list.add(DATE_TIME_FORMAT_YYYYMMDD_HH_MI);  
  606.         list.add(DATE_TIME_FORMAT_YYYYMMDDHHMISS);  
  607.         list.add(DATE_FORMAT_YYYY_MM_DD);  
  608.         //list.add(DATE_FORMAT_YY_MM_DD);  
  609.         list.add(DATE_FORMAT_YYYYMMDD);  
  610.         //list.add(DATE_FORMAT_YYYY_MM);  
  611.         //list.add(DATE_FORMAT_YYYYMM);  
  612.         //list.add(DATE_FORMAT_YYYY);  
  613.           
  614.         for (Iterator iter = list.iterator(); iter.hasNext();) {  
  615.             String format = (String) iter.next();  
  616.             if(strTime.indexOf("-")>0 && format.indexOf("-")<0)  
  617.                 continue;  
  618.             if(strTime.indexOf("-")<0 && format.indexOf("-")>0)  
  619.                 continue;  
  620.             if(strTime.length()>format.length())  
  621.                 continue;  
  622.             date = parseStrToDate(strTime.trim(), format);  
  623.             if (date != null)  
  624.                 break;  
  625.         }  
  626.           
  627.         if (date != null) {  
  628.             System.out.println("生成的日期:"+DateUtil.parseDateToStr(date, DateUtil.DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS, "--null--"));  
  629.             return true;  
  630.         }  
  631.         return false;  
  632.     }  
  633.       
  634.     /** 
  635.      * 将指定日期的时分秒格式为零 
  636.      * @param date 
  637.      * @return 
  638.      */  
  639.     public static Date formatHhMmSsOfDate(Date date) {  
  640.         Calendar cal = Calendar.getInstance();  
  641.         cal.setTime(date);  
  642.         cal.set(Calendar.HOUR_OF_DAY, 0);  
  643.         cal.set(Calendar.MINUTE, 0);  
  644.         cal.set(Calendar.SECOND, 0);  
  645.         cal.set(Calendar.MILLISECOND, 0);  
  646.         return cal.getTime();  
  647.     }  
  648.       
  649.     /** 
  650.      * 获得指定时间加减参数后的日期(不计算则输入0)  
  651.      * @param date 指定日期 
  652.      * @param year 年数，可正可负 
  653.      * @param month 月数，可正可负 
  654.      * @param day 天数，可正可负 
  655.      * @param hour 小时数，可正可负 
  656.      * @param minute 分钟数，可正可负 
  657.      * @param second 秒数，可正可负 
  658.      * @param millisecond 毫秒数，可正可负 
  659.      * @return 计算后的日期 
  660.      */  
  661.     public static Date addDate(Date date,int year,int month,int day,int hour,int minute,int second,int millisecond){  
  662.         Calendar c = Calendar.getInstance();  
  663.         c.setTime(date);  
  664.         c.add(Calendar.YEAR, year);//加减年数  
  665.         c.add(Calendar.MONTH, month);//加减月数  
  666.         c.add(Calendar.DATE, day);//加减天数  
  667.         c.add(Calendar.HOUR,hour);//加减小时数  
  668.         c.add(Calendar.MINUTE, minute);//加减分钟数  
  669.         c.add(Calendar.SECOND, second);//加减秒  
  670.         c.add(Calendar.MILLISECOND, millisecond);//加减毫秒数  
  671.           
  672.         return c.getTime();  
  673.     }  
  674.       
  675.     /** 
  676.      * 获得两个日期的时间戳之差 
  677.      * @param startDate 
  678.      * @param endDate 
  679.      * @return 
  680.      */  
  681.     public static Long getDistanceTimestamp(Date startDate,Date endDate){  
  682.         long daysBetween=(endDate.getTime()-startDate.getTime()+1000000)/(3600*24*1000);  
  683.         return daysBetween;  
  684.     }  
  685.       
  686.     /** 
  687.      * 判断二个时间是否为同年同月 
  688.      * @param date1 
  689.      * @param date2 
  690.      * @return 
  691.      */  
  692.     public static Boolean compareIsSameMonth(Date date1,Date date2){  
  693.         boolean flag = false;  
  694.         int year1  = getYear(date1);  
  695.         int year2 = getYear(date2);  
  696.         if(year1 == year2){  
  697.             int month1 = getMonth(date1);  
  698.             int month2 = getMonth(date2);  
  699.             if(month1 == month2)flag = true;  
  700.         }  
  701.         return flag;  
  702.     }  
  703.       
  704.      /**  
  705.      * 获得两个时间相差距离多少天多少小时多少分多少秒  
  706.      * @param str1 时间参数 1 格式：1990-01-01 12:00:00  
  707.      * @param str2 时间参数 2 格式：2009-01-01 12:00:00  
  708.      * @return long[] 返回值为：{天, 时, 分, 秒}  
  709.      */   
  710.     public static long[] getDistanceTime(Date one, Date two) {   
  711.         long day = 0;   
  712.         long hour = 0;   
  713.         long min = 0;   
  714.         long sec = 0;   
  715.         try {   
  716.              
  717.             long time1 = one.getTime();   
  718.             long time2 = two.getTime();   
  719.             long diff ;   
  720.             if(time1<time2) {   
  721.                 diff = time2 - time1;   
  722.             } else {   
  723.                 diff = time1 - time2;   
  724.             }   
  725.             day = diff / (24 * 60 * 60 * 1000);   
  726.             hour = (diff / (60 * 60 * 1000) - day * 24);   
  727.             min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);   
  728.             sec = (diff/1000-day*24*60*60-hour*60*60-min*60);   
  729.         } catch (Exception e) {   
  730.             e.printStackTrace();   
  731.         }  
  732.         long[] times = {day, hour, min, sec};   
  733.         return times;   
  734.     }   
  735.       
  736.     /**  
  737.      * 两个时间相差距离多少天多少小时多少分多少秒  
  738.      * @param str1 时间参数 1 格式：1990-01-01 12:00:00  
  739.      * @param str2 时间参数 2 格式：2009-01-01 12:00:00  
  740.      * @return String 返回值为：{天, 时, 分, 秒} 
  741.      */   
  742.     public static long[] getDistanceTime(String str1, String str2) {   
  743.         DateFormat df = new SimpleDateFormat(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);   
  744.         Date one;   
  745.         Date two;   
  746.         long day = 0;   
  747.         long hour = 0;   
  748.         long min = 0;   
  749.         long sec = 0;   
  750.         try {   
  751.             one = df.parse(str1);   
  752.             two = df.parse(str2);   
  753.             long time1 = one.getTime();   
  754.             long time2 = two.getTime();   
  755.             long diff ;   
  756.             if(time1<time2) {   
  757.                 diff = time2 - time1;   
  758.             } else {   
  759.                 diff = time1 - time2;   
  760.             }   
  761.             day = diff / (24 * 60 * 60 * 1000);   
  762.             hour = (diff / (60 * 60 * 1000) - day * 24);   
  763.             min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);   
  764.             sec = (diff/1000-day*24*60*60-hour*60*60-min*60);   
  765.         } catch (ParseException e) {   
  766.             e.printStackTrace();   
  767.         }   
  768.         long[] times = {day, hour, min, sec};   
  769.         return times;   
  770.     }   
  771.       
  772.     /**  
  773.      * 两个时间之间相差距离多少天  
  774.      * @param one 时间参数 1：  
  775.      * @param two 时间参数 2：  
  776.      * @return 相差天数  
  777.      */   
  778.     public static Long getDistanceDays(String str1, String str2) throws Exception{   
  779.         DateFormat df = new SimpleDateFormat(DATE_TIME_FORMAT_YYYY_MM_DD_HH_MI_SS);   
  780.         Date one;   
  781.         Date two;   
  782.         long days=0;   
  783.         try {   
  784.             one = df.parse(str1);   
  785.             two = df.parse(str2);   
  786.             long time1 = one.getTime();   
  787.             long time2 = two.getTime();   
  788.             long diff ;   
  789.             if(time1<time2) {   
  790.                 diff = time2 - time1;   
  791.             } else {   
  792.                 diff = time1 - time2;   
  793.             }   
  794.             days = diff / (1000 * 60 * 60 * 24);   
  795.         } catch (ParseException e) {   
  796.             e.printStackTrace();   
  797.         }   
  798.         return days;   
  799.     }   
  800.       
  801.     /** 
  802.      * 获取指定时间的那天 00:00:00.000 的时间 
  803.      * @param date 
  804.      * @return 
  805.      */  
  806.     public static Date getDayBeginTime(final Date date) {  
  807.             Calendar c = Calendar.getInstance();  
  808.             c.setTime(date);  
  809.             c.set(Calendar.HOUR_OF_DAY, 0);  
  810.             c.set(Calendar.MINUTE, 0);  
  811.             c.set(Calendar.SECOND, 0);  
  812.             c.set(Calendar.MILLISECOND, 0);  
  813.             return c.getTime();  
  814.     }  
  815.       
  816.     /** 
  817.      * 获取指定时间的那天 23:59:59.999 的时间 
  818.      * @param date 
  819.      * @return 
  820.      */  
  821.     public static Date getDayEndTime(final Date date) {  
  822.             Calendar c = Calendar.getInstance();  
  823.             c.setTime(date);  
  824.             c.set(Calendar.HOUR_OF_DAY, 23);  
  825.             c.set(Calendar.MINUTE, 59);  
  826.             c.set(Calendar.SECOND, 59);  
  827.             c.set(Calendar.MILLISECOND, 999);  
  828.             return c.getTime();  
  829.     }  
  830.      
  831.       
  832.     public static void main(String [] args){  
  833.         try {  
  834.             DateUtil dateUtil = new DateUtil();  
  835.             System.out.println();  
  836.               
  837.         } catch (Exception e) {  
  838.             // TODO: handle exception  
  839.         }  
  840.           
  841.     }  
  842.       
  843. } 

http://blog.csdn.net/w410589502/article/details/54342192

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/smallfa/p/8321682.html