devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java中的日期转化格式DateUtil工具类_java接收所有日期格式字符串解析成yyyy-mm-dd的工具类

作者：很楠不爱3 | 2024-03-18 05:01:39

赞

踩

java接收所有日期格式字符串解析成yyyy-mm-dd的工具类

最近在项目中经常会遇到各种的日期格式转化。所以，参考一些资料就写了一个工具类DateUtil。

日期格式包括：年（yyyy）、年月（yyyyMM、yyyy-MM）、年月日（yyyyMMdd、yyyy-MM-dd）、年月日时分（yyyyMMddHHmm、yyyy-MM-dd HH:mm）、年月日时分秒（yyyyMMddHHMISS、yyyy-MM-dd HH:MI:SS）等各种格式。


方法：1. 根据Date时间，转化成上面各种日期格式；

          2. 解析两个日期之间的所有月份

          3. 解析两个日期之间的所有日期

          4. 获取当下年份指定前后数量的年份集合

          5. 获取当前日期是一年中的第几周

          6. 获取某一年各星期的始终时间

          7. 获取某一年的总周数

          8. 获取指定日期所在周的第一天或者最后一天

          9. 获取某个日期是星期几

          10. 验证字符串是否是日期

          11. 获得指定日期前后时间段的时间

          12. 获得两个日期的时间戳之差

          13. 判段两个时间是否为同年同月

          14. 判断两个时间的时间差（结果按照格式化输出）


相关代码如下：

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/260512?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号