日期_日期解析 java - CSDN
精华内容
参与话题
  • JAVA中关于获取时间(日期)的总结大全

    万次阅读 多人点赞 2017-12-25 10:36:42
    在开发过程中,少不了与时间打交道,比如根据两个日期得出相差的时分秒,时间加减,时间累加,前5分钟,前一个月,前一年,等等... 而我最近开发和时间操作的比较频繁,所以记录下,和时间操作有关的代码。 ...

    在开发过程中,少不了与时间打交道,比如根据两个日期得出相差的时分秒,时间加减,时间累加,前5分钟,前一个月,前一年,等等...


    而我最近开发和时间操作的比较频繁,所以记录下,和时间操作有关的代码。


    在JAVA中有六个与时间有关的类:

    1. java.util.Date  
    2. java.sql.Date    
    3. java.sql.Time    
    4. java.sql.Timestamp  
    5. java.text.SimpleDateFormat  
    6. java.util.Calendar  


    常用的也就是下面的几个:

    1. Date:          getTime() 、setTime()  
    2. DateFormat:           getInstance()、getDateInstance()、getDateTimeInstance()、getTimeInstance()  
    3. SimpleDateFormate:    Formate(Date)、 parse(String s)  
    4. Calendar:        getInstance()、set() 、get()、getActualMaximum()、add()、gettime()、setTime(Date)  

    下面分别对他们介绍下:


    (1)、java.util.Date 


    java.util.Date 是java.sqlDate,Time,Timestamp的父类,Java中的时间使用标准类库的java.util.Date,其表示特定的瞬间,精确到毫秒。是用距离一个固定时间点的毫秒数(可正可负,long类型)表达一个特定的时间点。从 JDK 1.1 开始,应该使用 Calendar 类实现日期和时间字段之间转换,使用 DateFormat 类来格式化和分析日期字符串。因为Date的设计具有"千年虫"以及"时区"的问题,所以Date中的大部分方法已经不建议使用了,它们都被java.util.Calendar类所取代


    (2)、java.text.DateFormat(抽象类) 


           DateFormat 是日期/时间格式化子类的抽象类,它以与语言无关的方式格式化并分析日期或时间。日期/时间格式化子类(如 SimpleDateFormat)允许进行格式化(日期 -> 文本)、分析(文本-> 日期)和标准化。将日期表示为 Date 对象,或者表示为从 GMT(格林尼治标准时间)1970 年1 月 1 日 00:00:00 这一刻开始的毫秒数。 不过DateFormat的格式化Date的功能有限,没有SimpleDateFormat强大;但DateFormat是SimpleDateFormat的父类。

    (3)、java.text.SimpleDateFormat  (DateFormat的直接子类) 


     SimpleDateFormat 是一个以与语言环境相关的方式来格式化和分析日期的具体类。


           SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是,仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来新的创建日期-时间格式化程序。 


    日期格式字符串如下:




    常见的转换有两种:


    将Date格式化为String    String format(Date d)
    将String解析为Date    Date   parse(String s)


    (4)、java.util.Calendar(抽象类) 


           java.util.Calendar 类用于封装日历信息,其主要作用在于其方法可以对时间分量进行运算


           Calendar 类是一个抽象类,它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。瞬间可用毫秒值来表示,它是距历元(即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000,格里高利历)的偏移量。

     
           与其他语言环境敏感类一样,Calendar 提供了一个类方法 getInstance,以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象,其日历字段已由当前日期和时间初始化。 
      


    二、示例


    大概可以分为以下五大类:


    (A)、日期取值


    1.1、获取当前系统时间(毫秒数)

    1. //方式一  
    2. Date date = new Date();  
    3. System.out.println(date.getTime());  
    4.   
    5. //方式二  
    6. System.out.println(System.currentTimeMillis());  
    7.   
    8. //转换成指定的格式  
    9. String current = df.format(System.currentTimeMillis());  
    10. System.out.println(current);         
    11.   
    12.   
    13. 输出如下:  
    14. 1513749728479  
    15. 1513749728480  
    16. 2017-12-20 14:02:08   

    (B)、日期转换


    2.1、日期转字符串、字符串转日期

    1. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    2. try {  
    3.     //1、日期转字符串  
    4.     Calendar calendar = Calendar.getInstance();  
    5.     Date date = calendar.getTime();  
    6.     String dateStringParse = sdf.format(date);  
    7.     System.out.println(dateStringParse);  
    8.     //2、字符串转日期  
    9.     String dateString = "2017-12-20 14:02:08";  
    10.     Date dateParse = sdf.parse(dateString);  
    11.     System.out.println(dateParse);  
    12. } catch (ParseException e) {  
    13.     e.printStackTrace();  
    14. }        


    注意:

    -创建 SimpleDateFormat 对象时必须指定转换格式。
    -转换格式区分大小写,yyyy 代表年份,MM 代表月份,dd 代表日期,HH 代表 24 进制的小时,hh 代表 12 进制的小时,mm 代表分钟,ss 代表秒。


    2.2、将日期转换成中文年月日时分秒

    1. SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");  
    2. try {  
    3.     Date date = new Date();  
    4.     String dateStringParse = sdf.format(date);  
    5.     System.out.println(dateStringParse);  
    6. } catch (Exception e) {  
    7.     e.printStackTrace();  
    8. }  


    2.3、将指定日期转换成带周的格式

    1. DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    2. Date d1 = df.parse("2017-12-20 12:19:19");  
    3. //指定日期  
    4. Calendar cal = df.getCalendar();  
    5. //当前时间  
    6. Calendar cas = Calendar.getInstance();  
    7. int year = cal.get(Calendar.YEAR);//获取年份  
    8. int month=cal.get(Calendar.MONTH);//获取月份  
    9. int day=cal.get(Calendar.DATE);//获取日  
    10. int hour=cal.get(Calendar.HOUR);//小时  
    11. int minute=cal.get(Calendar.MINUTE);//分  
    12. int second=cal.get(Calendar.SECOND);//秒  
    13. int WeekOfYear = cal.get(Calendar.DAY_OF_WEEK);//一周的第几天  
    14. System.out.println("现在的时间是:公元"+year+"年"+month+"月"+day+"日      "+hour+"时"+minute+"分"+second+"秒     星期"+WeekOfYear);  

    2.4、获取当前时间显示,上午,下午

    1. Date date = new Date();  
    2. DateFormat df1 = DateFormat.getDateInstance();//日期格式,精确到日  
    3. System.out.println(df1.format(date));  
    4. DateFormat df2 = DateFormat.getDateTimeInstance();//可以精确到时分秒  
    5. System.out.println(df2.format(date));  
    6. DateFormat df3 = DateFormat.getTimeInstance();//只显示出时分秒  
    7. System.out.println("只显示出时分秒:"+df3.format(date));  
    8. DateFormat df4 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL); //显示日期,周,上下午,时间(精确到秒)  
    9. System.out.println("显示日期,周,上下午,时间(精确到秒):"+df4.format(date));  
    10. DateFormat df5 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG); //显示日期,上下午,时间(精确到秒)  
    11. System.out.println("显示日期,上下午,时间(精确到秒):"+df5.format(date));  
    12. DateFormat df6 = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT); //显示日期,上下午,时间(精确到分)  
    13. System.out.println("显示日期,上下午,时间(精确到分):"+df6.format(date));  
    14. DateFormat df7 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM); //显示日期,时间(精确到分)  
    15. System.out.println("显示日期,时间(精确到分):"+df7.format(date));  


    2.5、时间秒转化为多少天小时分秒

    1. /**    
    2.      * 秒转化为天小时分秒字符串    
    3.      *    
    4.      * @param seconds    
    5.      * @return String    
    6.      */      
    7.     public static String formatSeconds(long seconds) {      
    8.         String timeStr = seconds + "秒";      
    9.         if (seconds > 60) {      
    10.             long second = seconds % 60;      
    11.             long min = seconds / 60;      
    12.             timeStr = min + "分" + second + "秒";      
    13.             if (min > 60) {      
    14.                 min = (seconds / 60) % 60;      
    15.                 long hour = (seconds / 60) / 60;      
    16.                 timeStr = hour + "小时" + min + "分" + second + "秒";      
    17.                 if (hour > 24) {      
    18.                     hour = ((seconds / 60) / 60) % 24;      
    19.                     long day = (((seconds / 60) / 60) / 24);      
    20.                     timeStr = day + "天" + hour + "小时" + min + "分" + second + "秒";      
    21.                 }      
    22.             }      
    23.         }      
    24.         return timeStr;      
    25.  }      



    (C)、设置时间


    Calendar.getInstance().getTime()即可获取一个Date对象
    Calendar.getInstance().add(时间的一个部分,正数代表加,负数代表减)


    推荐 使用java.util.Calendar类来进行操作,因为java.util.Date类很多方法都过时了,Calendar 类有很多重载的设置时间的方法,可以针对于某一项进行设置,也可以同时进行很多设置

    1. set(int field, int value) 将给定的日历字段设置为给定值。  
    2. void    set(int year, int month, int date) 设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。  
    3. void    set(int year, int month, int date, int hourOfDay, int minute) 设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值。  
    4. void    set(int year, int month, int date, int hourOfDay, int minute, int second) 设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。  

    第一个就是给特定的字段设值,后面三个就是针对多个字段赋值


    (D)、日期加减


    通常来说,我们会对日期做两种加减操作:

    一、以某个日期为基准,计算其几天前/后、几年前/后,或者其他时间单位前后的日期


    A、获取当前时间的前一年时间

    1. //根据现在时间计算  
    2. Calendar now = Calendar.getInstance();  
    3. now.add(Calendar.YEAR, 1); //现在时间是1年后  
    4. print(now);  
    5. now.add(Calendar.YEAR, -1); //现在时间是1年前  
    6. print(now);  
    7.   
    8. //根据某个特定的时间 date (Date 型) 计算  
    9. Calendar specialDate = Calendar.getInstance();  
    10. specialDate.setTime(new Date()); //注意在此处将 specialDate 的值改为特定日期  
    11. specialDate.add(Calendar.YEAR, 1); //特定时间的1年后  
    12. print(specialDate);  
    13. specialDate.add(Calendar.YEAR, -1); //特定时间的1年前  
    14. print(specialDate);   

    打印Calendar的方法为:

    1. public void print(Calendar specialDate){  
    2.     System.out.println(specialDate.get(Calendar.YEAR)+"年"+(specialDate.get(Calendar.MONTH)+1)+  
    3.             "月"+specialDate.get(Calendar.DAY_OF_MONTH)+"日"+specialDate.get(Calendar.HOUR_OF_DAY)+  
    4.             ":"+specialDate.get(Calendar.MINUTE)+":"+specialDate.get(Calendar.SECOND));  
    5. }        

    使用了 Calendar 对象的 add 方法,可以更改 Calendar.YEAR 为任意时间单位字段,完成各种时间单位下的日期计算。


    B、根据时间然后对小时,分钟,秒数进行相加

    1. //取当前的时分-30  
    2. SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");  
    3. Calendar nowTime2 = Calendar.getInstance();  
    4. nowTime2.add(Calendar.MINUTE, -30);//30分钟前的时间  
    5. String currentTime = df.format(nowTime2.getTime());  
    6. System.out.println("30分钟前的时间" + currentTime);  
    7.   
    8. //取当前小时减一个小时  
    9. Calendar calendar = Calendar.getInstance();  
    10. calendar.set(Calendar.HOUR_OF_DAY, calendar.get(Calendar.HOUR_OF_DAY) - 1);  
    11. SimpleDateFormat dff = new SimpleDateFormat("yyyy-MM-dd HH");  
    12. System.out.println("一个小时前的时间:" + dff.format(calendar.getTime()));  
    13. System.out.println("当前的时间:" + dff.format(new Date()));  
    14.   
    15. //取当前的时分+5  
    16. Calendar nowTime = Calendar.getInstance();  
    17. nowTime.add(Calendar.MINUTE, 5);  
    18. String currentTimes = df.format(nowTime.getTime());  
    19. System.out.println("当前时间加5分钟" +currentTimes);  
    20.   
    21. //前一天的时间  
    22. Date dNow = new Date();   //当前时间  
    23. Calendar calendars = Calendar.getInstance(); //得到日历  
    24. calendars.setTime(dNow);//把当前时间赋给日历  
    25. calendars.add(Calendar.DAY_OF_MONTH, -1);  //设置为前一天  
    26. Date dBefore = calendars.getTime();   //得到前一天的时间  
    27.   
    28. String defaultStartDate = df.format(dBefore);    //格式化前一天  
    29. String defaultEndDate = df.format(dNow); //格式化当前时间  
    30.   
    31. System.out.println("前一天的时间是:" + defaultStartDate);  
    32. System.out.println("生成的时间是:" + defaultEndDate);  

    C、对时分秒进行累计,比如说视频通话,第一次,通了10分钟,第二次就得把上次的时间进行累计。

    1. DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    2. //上次挂断电话时间  
    3. Date d1 = df.parse("2017-12-20 12:19:19");  
    4. //这次通话时长  
    5. Date d2 = df.parse("2017-12-20 11:40:34");  
    6. long nd = 1000 * 24 * 60 * 60;  
    7. long nh = 1000 * 60 * 60;  
    8. long nm = 1000 * 60;  
    9. long ns = 1000;  
    10. // 获得两个时间的毫秒时间差异  
    11. long diff = d1.getTime() - d2.getTime();  
    12. // 计算差多少天  
    13. long day = diff / nd;  
    14. // 计算差多少小时  
    15. long hour = diff % nd / nh;  
    16. // 计算差多少分钟  
    17. long min = diff % nd % nh / nm;  
    18. // 计算差多少秒/输出结果  
    19. long sec = diff % nd % nh % nm / ns;  
    20. //根据上次挂断电话时间然后得出这次通话时长  
    21. System.out.println(day + "天" + hour + "小时" + min + "分钟"+ sec + "秒");  
    22.   
    23. //累计通话时长  
    24. String cur = "10:15:12";  
    25. SimpleDateFormat myFormatter = new SimpleDateFormat("HH:mm:ss");  
    26. Calendar cal = Calendar.getInstance();  
    27. cal.setTime(myFormatter.parse(cur));  
    28. int shi = (int)cal.get(Calendar.HOUR_OF_DAY)+(int)hour;  
    29. int fendo = (int)cal.get(Calendar.MINUTE)+(int)min;  
    30. int miao = (int)cal.get(Calendar.SECOND)+(int)sec;  
    31.   
    32. //以下算法有些问题  
    33. if(miao>60){  
    34.     miao=00;  
    35.     if(fendo>60){  
    36.         fendo = 00;  
    37.         shi = shi+1;  
    38.     }else {  
    39.         fendo = fendo + 1;  
    40.     }  
    41. }  
    42. System.out.println(shi+":"+fendo+":"+miao);  


    二、计算两个时间的间隔


    A、例如计算 2017 年 1 月 1 日距离现在有多少天。  

    1. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    2. String dateString = "2017-01-01 11:11:11";  
    3. Calendar calendar = Calendar.getInstance();  
    4. long nowDate = calendar.getTime().getTime(); //Date.getTime() 获得毫秒型日期  
    5. try {  
    6.     long specialDate = sdf.parse(dateString).getTime();  
    7.     long betweenDate = (specialDate - nowDate) / (1000 * 60 * 60 * 24); //计算间隔多少天,则除以毫秒到天的转换公式  
    8.     System.out.print(betweenDate);  
    9. } catch (ParseException e) {  
    10.     e.printStackTrace();  
    11. }  


    B、求出两个日期相差多少小时,分钟,毫秒

    1. DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    2. Date d1 = df.parse("2017-12-20 12:19:19");  
    3. Date d2 = df.parse("2017-12-20 11:40:34");  
    4. long nd = 1000 * 24 * 60 * 60;  
    5. long nh = 1000 * 60 * 60;  
    6. long nm = 1000 * 60;  
    7. long ns = 1000;  
    8. // 获得两个时间的毫秒时间差异  
    9. long diff = d1.getTime() - d2.getTime();  
    10. // 计算差多少天  
    11. long day = diff / nd;  
    12. // 计算差多少小时  
    13. long hour = diff % nd / nh;  
    14. // 计算差多少分钟  
    15. long min = diff % nd % nh / nm;  
    16. // 计算差多少秒//输出结果  
    17. long sec = diff % nd % nh % nm / ns;  
    18. System.out.println(day + "天" + hour + "小时" + min + "分钟"+ sec + "秒");  


    (E)、日期比较


    日期比较一般有两种方法,对于 java.util.Date 或者 java.util.Calendar 都是通用的。一种是通过 after() 与 before() 方法进行比较,一种是通过 compareTo() 方法进行比较。

    1. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    2. String dateString_01 = "2017-12-20 11:11:11";  
    3. String dateString_02 = "2017-12-21 11:11:11";  
    4. try {  
    5.     Date date_01 = sdf.parse(dateString_01);  
    6.     Date date_02 = sdf.parse(dateString_02);  
    7.     System.out.println(date_01.before(date_02)); //true,当 date_01 小于 date_02 时,为 true,否则为 false  
    8.     System.out.println(date_02.after(date_01)); //true,当 date_02 大于 date_01 时,为 true,否则为 false  
    9.     System.out.println(date_01.compareTo(date_02)); //-1,当 date_01 小于 date_02 时,为 -1  
    10.     System.out.println(date_02.compareTo(date_01)); //1,当 date_02 大于 date_01 时,为 1  
    11.     System.out.println(date_02.compareTo(date_02)); //0,当两个日期相等时,为 0  
    12. } catch (ParseException e) {  
    13.     e.printStackTrace();  
    14. }  


    三、工具类


    网上找的一个工具类:
    1. /**  
    2.  * projectName: xxxx  
    3.  * fileName: DateUtil.java  
    4.  * packageName: test  
    5.  * date: 2017-12-20 15:36  
    6.  * copyright(c) 2017-2020 xxx公司  
    7.  */  
    8. package test;  
    9.   
    10. import java.sql.Timestamp;  
    11. import java.text.ParseException;  
    12. import java.text.ParsePosition;  
    13. import java.text.SimpleDateFormat;  
    14. import java.util.*;  
    15.   
    16. /**  
    17.  * @version: V1.0  
    18.  * @author: fendo  
    19.  * @className: DateUtil  
    20.  * @packageName: test  
    21.  * @description: 时间操作工具类  
    22.  * @data: 2017-12-20 15:36  
    23.  **/  
    24. public class DateUtil {  
    25.   
    26.     public static String pattern="yyyy-MM-dd";  
    27.     public static SimpleDateFormat formatter = new SimpleDateFormat(pattern);  
    28.     public static SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    29.   
    30.     /**  
    31.      * 获取现在时间  
    32.      *  
    33.      * @return 返回时间类型 yyyy-MM-dd HH:mm:ss  
    34.      */  
    35.     public static Date getNowDate() {  
    36.         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    37.         String dateString = formatter.format(new Date());  
    38.         ParsePosition pos = new ParsePosition(8);  
    39.         Date currentTime_2 = formatter.parse(dateString, pos);  
    40.         return currentTime_2;  
    41.     }  
    42.   
    43.     /**  
    44.      * 获取现在时间  
    45.      *  
    46.      * @return返回短时间格式 yyyy-MM-dd  
    47.      */  
    48.     public static Date getNowDateShort() {  
    49.         String dateString = formatter.format(new Date());  
    50.         ParsePosition pos = new ParsePosition(8);  
    51.         Date currentTime_2 = formatter.parse(dateString, pos);  
    52.         return currentTime_2;  
    53.     }  
    54.   
    55.     /**  
    56.      * 获取现在时间  
    57.      *  
    58.      * @return返回字符串格式 yyyy-MM-dd HH:mm:ss  
    59.      */  
    60.     public static String getStringDate() {  
    61.         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    62.         String dateString = formatter.format(new Date());  
    63.         return dateString;  
    64.     }  
    65.     /**  
    66.      * 获取现在时间  
    67.      * @return返回字符串格式 yyyyMMddHHmmss  
    68.      */  
    69.     public static String getStringAllDate() {  
    70.         SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmssSSS");  
    71.         String dateString = formatter.format(new Date());  
    72.         return dateString;  
    73.     }  
    74.     /**  
    75.      * 获取现在时间  
    76.      *  
    77.      * @return 返回短时间字符串格式yyyy-MM-dd  
    78.      */  
    79.     public static String getStringDateShort() {  
    80.         String dateString = formatter.format( new Date());  
    81.         return dateString;  
    82.     }  
    83.   
    84.     /**  
    85.      * 获取时间 小时:分;秒 HH:mm:ss  
    86.      *  
    87.      * @return  
    88.      */  
    89.     public static String getTimeShort() {  
    90.         SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");  
    91.         String dateString = formatter.format(new Date());  
    92.         return dateString;  
    93.     }  
    94.   
    95.     /**  
    96.      * 将长时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss  
    97.      *  
    98.      * @param strDate  
    99.      * @return  
    100.      */  
    101.     public static Date strToDateLong(String strDate) {  
    102.         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    103.         ParsePosition pos = new ParsePosition(0);  
    104.         Date strtodate = formatter.parse(strDate, pos);  
    105.         return strtodate;  
    106.     }  
    107.   
    108.     /**  
    109.      * 将长时间格式时间转换为字符串 yyyy-MM-dd HH:mm:ss  
    110.      *  
    111.      * @param dateDate  
    112.      * @return  
    113.      */  
    114.     public static String dateToStrLong(java.util.Date dateDate) {  
    115.         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    116.         String dateString = formatter.format(dateDate);  
    117.         return dateString;  
    118.     }  
    119.   
    120.     /**  
    121.      * 将短时间格式时间转换为字符串 yyyy-MM-dd  
    122.      *  
    123.      * @param dateDate  
    124.      * @return  
    125.      */  
    126.     public static String dateToStr(Date dateDate) {  
    127.         String dateString = formatter.format(dateDate);  
    128.         return dateString;  
    129.     }  
    130.   
    131.   
    132.     /**  
    133.      * 将短时间格式字符串转换为时间 yyyy-MM-dd  
    134.      *  
    135.      * @param strDate  
    136.      * @return  
    137.      */  
    138.     public static Date strToDate(String strDate) {  
    139.         ParsePosition pos = new ParsePosition(0);  
    140.         Date strtodate = formatter.parse(strDate, pos);  
    141.         return strtodate;  
    142.     }  
    143.   
    144.     /**  
    145.      * 将短时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss  
    146.      *  
    147.      * @param strDate  
    148.      * @return  
    149.      */  
    150.     public static Timestamp strToDateSql(String strDate) {  
    151.         ParsePosition pos = new ParsePosition(0);  
    152.         Date strtodate = formatter2.parse(strDate, pos);  
    153.         return new Timestamp(strtodate.getTime());  
    154.     }  
    155.     /**  
    156.      * 得到现在时间  
    157.      *  
    158.      * @return  
    159.      */  
    160.     public static Date getNow() {  
    161.         Date currentTime = new Date();  
    162.         return currentTime;  
    163.     }  
    164.   
    165.     /**  
    166.      * 提取一个月中的最后一天  
    167.      *  
    168.      * @param day  
    169.      * @return  
    170.      */  
    171.     public static Date getLastDate(long day) {  
    172.         Date date = new Date();  
    173.         long date_3_hm = date.getTime() - 3600000 * 34 * day;  
    174.         Date date_3_hm_date = new Date(date_3_hm);  
    175.         return date_3_hm_date;  
    176.     }  
    177.   
    178.     /**  
    179.      * 得到现在时间  
    180.      *  
    181.      * @return 字符串 yyyyMMdd HHmmss  
    182.      */  
    183.     public static String getStringToday() {  
    184.         Date currentTime = new Date();  
    185.         SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd HHmmss");  
    186.         String dateString = formatter.format(currentTime);  
    187.         return dateString;  
    188.     }  
    189.     /**  
    190.      *  
    191.      * 功能:<br/>  
    192.      *  
    193.      * @author Tony  
    194.      * @version 2016年12月16日 下午4:41:51 <br/>  
    195.      */  
    196.     public static String getTodayShort() {  
    197.         Date currentTime = new Date();  
    198.         SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");  
    199.         String dateString = formatter.format(currentTime);  
    200.         return dateString;  
    201.     }  
    202.     /**  
    203.      *  
    204.      * @Description: 输入一个整数类型的字符串,然后转换成时分秒的形式输出  
    205.      *    例如:输入568  
    206.      *          返回结果为:00:09:28  
    207.      *          输入null或者“”  
    208.      *          返回结果为:00:00:00  
    209.      * @param @param value  
    210.      * @param @return  
    211.      * @return String  
    212.      * @throws  
    213.      * @author Tony 鬼手卡卡  
    214.      * @date 2016-4-20  
    215.      */  
    216.     public static String getHHMMSS(String value){  
    217.         String hour="00";  
    218.         String minute="00";  
    219.         String second="00";  
    220.         if(value!=null&&!value.trim().equals("")){  
    221.             int v_int=Integer.valueOf(value);  
    222.             hour=v_int/3600+"";//获得小时;  
    223.             minute=v_int%3600/60+"";//获得小时;  
    224.             second=v_int%3600%60+"";//获得小时;  
    225.         }  
    226.         return (hour.length()>1?hour:"0"+hour)+":"+(minute.length()>1?minute:"0"+minute)+":"+(second.length()>1?second:"0"+second);  
    227.     }  
    228.     /**  
    229.      * 得到现在小时  
    230.      */  
    231.     public static String getHour() {  
    232.         Date currentTime = new Date();  
    233.         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    234.         String dateString = formatter.format(currentTime);  
    235.         String hour;  
    236.         hour = dateString.substring(11, 13);  
    237.         return hour;  
    238.     }  
    239.   
    240.     /**  
    241.      * 得到现在分钟  
    242.      *  
    243.      * @return  
    244.      */  
    245.     public static String getTime() {  
    246.         Date currentTime = new Date();  
    247.         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    248.         String dateString = formatter.format(currentTime);  
    249.         String min;  
    250.         min = dateString.substring(14, 16);  
    251.         return min;  
    252.     }  
    253.   
    254.     /**  
    255.      * 根据用户传入的时间表示格式,返回当前时间的格式 如果是yyyyMMdd,注意字母y不能大写。  
    256.      *  
    257.      * @param sformat  
    258.      *            yyyyMMddhhmmss  
    259.      * @return  
    260.      */  
    261.     public static String getUserDate(String sformat) {  
    262.         Date currentTime = new Date();  
    263.         SimpleDateFormat formatter = new SimpleDateFormat(sformat);  
    264.         String dateString = formatter.format(currentTime);  
    265.         return dateString;  
    266.     }  
    267.   
    268.     /**  
    269.      * 二个小时时间间的差值,必须保证二个时间都是"HH:MM"的格式,返回字符型的分钟  
    270.      */  
    271.     public static String getTwoHour(String st1, String st2) {  
    272.         String[] kk = null;  
    273.         String[] jj = null;  
    274.         kk = st1.split(":");  
    275.         jj = st2.split(":");  
    276.         if (Integer.parseInt(kk[0]) < Integer.parseInt(jj[0]))  
    277.             return "0";  
    278.         else {  
    279.             double y = Double.parseDouble(kk[0]) + Double.parseDouble(kk[1]) / 60;  
    280.             double u = Double.parseDouble(jj[0]) + Double.parseDouble(jj[1]) / 60;  
    281.             if ((y - u) > 0)  
    282.                 return y - u + "";  
    283.             else  
    284.                 return "0";  
    285.         }  
    286.     }  
    287.   
    288.     /**  
    289.      * 得到二个日期间的间隔天数  
    290.      */  
    291.     public static String getTwoDay(String sj1, String sj2) {  
    292.         long day = 0;  
    293.         try {  
    294.             java.util.Date date = formatter.parse(sj1);  
    295.             java.util.Date mydate = formatter.parse(sj2);  
    296.             day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);  
    297.         } catch (Exception e) {  
    298.             return "";  
    299.         }  
    300.         return day + "";  
    301.     }  
    302.   
    303.     /**  
    304.      * 时间前推或后推分钟,其中JJ表示分钟.  
    305.      */  
    306.     public static String getPreTime(String sj1, String jj) {  
    307.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    308.         String mydate1 = "";  
    309.         try {  
    310.             Date date1 = format.parse(sj1);  
    311.             long Time = (date1.getTime() / 1000) + Integer.parseInt(jj) * 60;  
    312.             date1.setTime(Time * 1000);  
    313.             mydate1 = format.format(date1);  
    314.         } catch (Exception e) {  
    315.         }  
    316.         return mydate1;  
    317.     }  
    318.   
    319.     /**  
    320.      * 得到一个时间延后或前移几天的时间,nowdate(yyyy-mm-dd)为时间,delay为前移或后延的天数  
    321.      */  
    322.     public static String getNextDay(String nowdate, String delay) {  
    323.         try{  
    324.             String mdate = "";  
    325.             Date d = strToDate(nowdate);  
    326.             long myTime = (d.getTime() / 1000) + Integer.parseInt(delay) * 24 * 60 * 60;  
    327.             d.setTime(myTime * 1000);  
    328.             mdate = formatter.format(d);  
    329.             return mdate;  
    330.         }catch(Exception e){  
    331.             return "";  
    332.         }  
    333.     }  
    334.     /**  
    335.      *  
    336.      * 功能:<br/> 距离现在几天的时间是多少  
    337.      * 获得一个时间字符串,格式为:yyyy-MM-dd HH:mm:ss  
    338.      * day  如果为整数,表示未来时间  
    339.      *      如果为负数,表示过去时间  
    340.      * @author Tony  
    341.      * @version 2016年11月29日 上午11:02:56 <br/>  
    342.      */  
    343.     public static String getFromNow(int day) {  
    344.         Date date = new Date();  
    345.         long dateTime = (date.getTime() / 1000) + day * 24 * 60 * 60;  
    346.         date.setTime(dateTime * 1000);  
    347.         return formatter2.format(date);  
    348.     }  
    349.     /**  
    350.      * 判断是否润年  
    351.      *  
    352.      * @param ddate  
    353.      * @return  
    354.      */  
    355.     public static boolean isLeapYear(String ddate) {  
    356.   
    357.         /**  
    358.          * 详细设计: 1.被400整除是闰年,否则: 2.不能被4整除则不是闰年 3.能被4整除同时不能被100整除则是闰年  
    359.          * 3.能被4整除同时能被100整除则不是闰年  
    360.          */  
    361.         Date d = strToDate(ddate);  
    362.         GregorianCalendar gc = (GregorianCalendar) Calendar.getInstance();  
    363.         gc.setTime(d);  
    364.         int year = gc.get(Calendar.YEAR);  
    365.         if ((year % 400) == 0)  
    366.             return true;  
    367.         else if ((year % 4) == 0) {  
    368.             if ((year % 100) == 0)  
    369.                 return false;  
    370.             else  
    371.                 return true;  
    372.         } else  
    373.             return false;  
    374.     }  
    375.   
    376.     /**  
    377.      * 返回美国时间格式 26 Apr 2006  
    378.      *  
    379.      * @param str  
    380.      * @return  
    381.      */  
    382.     public static String getEDate(String str) {  
    383.         ParsePosition pos = new ParsePosition(0);  
    384.         Date strtodate = formatter.parse(str, pos);  
    385.         String j = strtodate.toString();  
    386.         String[] k = j.split(" ");  
    387.         return k[2] + k[1].toUpperCase() + k[5].substring(2, 4);  
    388.     }  
    389.   
    390.     /**  
    391.      * 获取一个月的最后一天  
    392.      *  
    393.      * @param dat  
    394.      * @return  
    395.      */  
    396.     public static String getEndDateOfMonth(String dat) {// yyyy-MM-dd  
    397.         String str = dat.substring(0, 8);  
    398.         String month = dat.substring(5, 7);  
    399.         int mon = Integer.parseInt(month);  
    400.         if (mon == 1 || mon == 3 || mon == 5 || mon == 7 || mon == 8 || mon == 10 || mon == 12) {  
    401.             str += "31";  
    402.         } else if (mon == 4 || mon == 6 || mon == 9 || mon == 11) {  
    403.             str += "30";  
    404.         } else {  
    405.             if (isLeapYear(dat)) {  
    406.                 str += "29";  
    407.             } else {  
    408.                 str += "28";  
    409.             }  
    410.         }  
    411.         return str;  
    412.     }  
    413.   
    414.     /**  
    415.      * 判断二个时间是否在同一个周  
    416.      *  
    417.      * @param date1  
    418.      * @param date2  
    419.      * @return  
    420.      */  
    421.     public static boolean isSameWeekDates(Date date1, Date date2) {  
    422.         Calendar cal1 = Calendar.getInstance();  
    423.         Calendar cal2 = Calendar.getInstance();  
    424.         cal1.setTime(date1);  
    425.         cal2.setTime(date2);  
    426.         int subYear = cal1.get(Calendar.YEAR) - cal2.get(Calendar.YEAR);  
    427.         if (0 == subYear) {  
    428.             if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))  
    429.                 return true;  
    430.         } else if (1 == subYear && 11 == cal2.get(Calendar.MONTH)) {  
    431.             // 如果12月的最后一周横跨来年第一周的话则最后一周即算做来年的第一周  
    432.             if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))  
    433.                 return true;  
    434.         } else if (-1 == subYear && 11 == cal1.get(Calendar.MONTH)) {  
    435.             if (cal1.get(Calendar.WEEK_OF_YEAR) == cal2.get(Calendar.WEEK_OF_YEAR))  
    436.                 return true;  
    437.         }  
    438.         return false;  
    439.     }  
    440.   
    441.     /**  
    442.      * 产生周序列,即得到当前时间所在的年度是第几周  
    443.      *  
    444.      * @return  
    445.      */  
    446.     public static String getSeqWeek() {  
    447.         Calendar c = Calendar.getInstance(Locale.CHINA);  
    448.         String week = Integer.toString(c.get(Calendar.WEEK_OF_YEAR));  
    449.         if (week.length() == 1)  
    450.             week = "0" + week;  
    451.         String year = Integer.toString(c.get(Calendar.YEAR));  
    452.         return year + week;  
    453.     }  
    454.   
    455.     /**  
    456.      * 获得一个日期所在的周的星期几的日期,如要找出2002年2月3日所在周的星期一是几号  
    457.      *  
    458.      * @param sdate  
    459.      * @param num  
    460.      * @return  
    461.      */  
    462.     public static String getWeek(String sdate, String num) {  
    463.         // 再转换为时间  
    464.         Date dd = DateUtil.strToDate(sdate);  
    465.         Calendar c = Calendar.getInstance();  
    466.         c.setTime(dd);  
    467.         if (num.equals("1")) // 返回星期一所在的日期  
    468.             c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);  
    469.         else if (num.equals("2")) // 返回星期二所在的日期  
    470.             c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);  
    471.         else if (num.equals("3")) // 返回星期三所在的日期  
    472.             c.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);  
    473.         else if (num.equals("4")) // 返回星期四所在的日期  
    474.             c.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);  
    475.         else if (num.equals("5")) // 返回星期五所在的日期  
    476.             c.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);  
    477.         else if (num.equals("6")) // 返回星期六所在的日期  
    478.             c.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);  
    479.         else if (num.equals("0")) // 返回星期日所在的日期  
    480.             c.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);  
    481.         return new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());  
    482.     }  
    483.   
    484.     /**  
    485.      * 根据一个日期,返回是星期几的字符串  
    486.      *  
    487.      * @param sdate  
    488.      * @return  
    489.      */  
    490.     public static String getWeek(String sdate) {  
    491.         // 再转换为时间  
    492.         Date date = DateUtil.strToDate(sdate);  
    493.         Calendar c = Calendar.getInstance();  
    494.         c.setTime(date);  
    495.         // int hour=c.get(Calendar.DAY_OF_WEEK);  
    496.         // hour中存的就是星期几了,其范围 1~7  
    497.         // 1=星期日 7=星期六,其他类推  
    498.         return new SimpleDateFormat("EEEE").format(c.getTime());  
    499.     }  
    500.     public static String getWeekStr(String sdate){  
    501.         String str = "";  
    502.         str = DateUtil.getWeek(sdate);  
    503.         if("1".equals(str)){  
    504.             str = "星期日";  
    505.         }else if("2".equals(str)){  
    506.             str = "星期一";  
    507.         }else if("3".equals(str)){  
    508.             str = "星期二";  
    509.         }else if("4".equals(str)){  
    510.             str = "星期三";  
    511.         }else if("5".equals(str)){  
    512.             str = "星期四";  
    513.         }else if("6".equals(str)){  
    514.             str = "星期五";  
    515.         }else if("7".equals(str)){  
    516.             str = "星期六";  
    517.         }  
    518.         return str;  
    519.     }  
    520.   
    521.     /**  
    522.      * 两个时间之间的天数  
    523.      *  
    524.      * @param date1  
    525.      * @param date2  
    526.      * @return  
    527.      */  
    528.     public static long getDays(String date1, String date2) {  
    529.         if (date1 == null || date1.equals(""))  
    530.             return 0;  
    531.         if (date2 == null || date2.equals(""))  
    532.             return 0;  
    533.         // 转换为标准时间  
    534.         java.util.Date date = null;  
    535.         java.util.Date mydate = null;  
    536.         try {  
    537.             date = formatter.parse(date1);  
    538.             mydate = formatter.parse(date2);  
    539.         } catch (Exception e) {  
    540.         }  
    541.         long day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);  
    542.         return day;  
    543.     }  
    544.   
    545.     /**  
    546.      * 形成如下的日历 , 根据传入的一个时间返回一个结构 星期日 星期一 星期二 星期三 星期四 星期五 星期六 下面是当月的各个时间  
    547.      * 此函数返回该日历第一行星期日所在的日期  
    548.      *  
    549.      * @param sdate  
    550.      * @return  
    551.      */  
    552.     public static String getNowMonth(String sdate) {  
    553.         // 取该时间所在月的一号  
    554.         sdate = sdate.substring(0, 8) + "01";  
    555.   
    556.         // 得到这个月的1号是星期几  
    557.         Date date = DateUtil.strToDate(sdate);  
    558.         Calendar c = Calendar.getInstance();  
    559.         c.setTime(date);  
    560.         int u = c.get(Calendar.DAY_OF_WEEK);  
    561.         String newday = DateUtil.getNextDay(sdate, (1 - u) + "");  
    562.         return newday;  
    563.     }  
    564.   
    565.     /**  
    566.      * 取得数据库主键 生成格式为yyyymmddhhmmss+k位随机数  
    567.      *  
    568.      * @param k  
    569.      *            表示是取几位随机数,可以自己定  
    570.      */  
    571.   
    572.     public static String getNo(int k) {  
    573.   
    574.         return getUserDate("yyyyMMddhhmmss") + getRandom(k);  
    575.     }  
    576.   
    577.     /**  
    578.      * 返回一个随机数  
    579.      *  
    580.      * @param i  
    581.      * @return  
    582.      */  
    583.     public static String getRandom(int i) {  
    584.         Random jjj = new Random();  
    585.         if (i == 0)  
    586.             return "";  
    587.         String jj = "";  
    588.         for (int k = 0; k < i; k++) {  
    589.             jj = jj + jjj.nextInt(9);  
    590.         }  
    591.         return jj;  
    592.     }  
    593.   
    594.     public static boolean RightDate(String date) {  
    595.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");  
    596.         if (date == null)  
    597.             return false;  
    598.         if (date.length() > 10) {  
    599.             sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");  
    600.         } else {  
    601.             sdf = new SimpleDateFormat("yyyy-MM-dd");  
    602.         }  
    603.         try {  
    604.             sdf.parse(date);  
    605.         } catch (ParseException pe) {  
    606.             return false;  
    607.         }  
    608.         return true;  
    609.     }  
    610.   
    611.     /***************************************************************************  
    612.      * //nd=1表示返回的值中包含年度 //yf=1表示返回的值中包含月份 //rq=1表示返回的值中包含日期 //format表示返回的格式 1  
    613.      * 以年月日中文返回 2 以横线-返回 // 3 以斜线/返回 4 以缩写不带其它符号形式返回 // 5 以点号.返回  
    614.      **************************************************************************/  
    615.     public static String getStringDateMonth(String sdate, String nd, String yf, String rq, String format) {  
    616.         Date currentTime = new Date();  
    617.         String dateString = formatter.format(currentTime);  
    618.         String s_nd = dateString.substring(0, 4); // 年份  
    619.         String s_yf = dateString.substring(5, 7); // 月份  
    620.         String s_rq = dateString.substring(8, 10); // 日期  
    621.         String sreturn = "";  
    622.         //roc.util.MyChar mc = new roc.util.MyChar();  
    623.         //if (sdate == null || sdate.equals("") || !mc.Isdate(sdate)) { // 处理空值情况  
    624.         if (sdate == null || sdate.equals("")){  
    625.             if (nd.equals("1")) {  
    626.                 sreturn = s_nd;  
    627.                 // 处理间隔符  
    628.                 if (format.equals("1"))  
    629.                     sreturn = sreturn + "年";  
    630.                 else if (format.equals("2"))  
    631.                     sreturn = sreturn + "-";  
    632.                 else if (format.equals("3"))  
    633.                     sreturn = sreturn + "/";  
    634.                 else if (format.equals("5"))  
    635.                     sreturn = sreturn + ".";  
    636.             }  
    637.             // 处理月份  
    638.             if (yf.equals("1")) {  
    639.                 sreturn = sreturn + s_yf;  
    640.                 if (format.equals("1"))  
    641.                     sreturn = sreturn + "月";  
    642.                 else if (format.equals("2"))  
    643.                     sreturn = sreturn + "-";  
    644.                 else if (format.equals("3"))  
    645.                     sreturn = sreturn + "/";  
    646.                 else if (format.equals("5"))  
    647.                     sreturn = sreturn + ".";  
    648.             }  
    649.             // 处理日期  
    650.             if (rq.equals("1")) {  
    651.                 sreturn = sreturn + s_rq;  
    652.                 if (format.equals("1"))  
    653.                     sreturn = sreturn + "日";  
    654.             }  
    655.         } else {  
    656.             // 不是空值,也是一个合法的日期值,则先将其转换为标准的时间格式  
    657.             sdate = getOKDate(sdate);  
    658.             s_nd = sdate.substring(0, 4); // 年份  
    659.             s_yf = sdate.substring(5, 7); // 月份  
    660.             s_rq = sdate.substring(8, 10); // 日期  
    661.             if (nd.equals("1")) {  
    662.                 sreturn = s_nd;  
    663.                 // 处理间隔符  
    664.                 if (format.equals("1"))  
    665.                     sreturn = sreturn + "年";  
    666.                 else if (format.equals("2"))  
    667.                     sreturn = sreturn + "-";  
    668.                 else if (format.equals("3"))  
    669.                     sreturn = sreturn + "/";  
    670.                 else if (format.equals("5"))  
    671.                     sreturn = sreturn + ".";  
    672.             }  
    673.             // 处理月份  
    674.             if (yf.equals("1")) {  
    675.                 sreturn = sreturn + s_yf;  
    676.                 if (format.equals("1"))  
    677.                     sreturn = sreturn + "月";  
    678.                 else if (format.equals("2"))  
    679.                     sreturn = sreturn + "-";  
    680.                 else if (format.equals("3"))  
    681.                     sreturn = sreturn + "/";  
    682.                 else if (format.equals("5"))  
    683.                     sreturn = sreturn + ".";  
    684.             }  
    685.             // 处理日期  
    686.             if (rq.equals("1")) {  
    687.                 sreturn = sreturn + s_rq;  
    688.                 if (format.equals("1"))  
    689.                     sreturn = sreturn + "日";  
    690.             }  
    691.         }  
    692.         return sreturn;  
    693.     }  
    694.   
    695.     public static String getNextMonthDay(String sdate, int m) {  
    696.         sdate = getOKDate(sdate);  
    697.         int year = Integer.parseInt(sdate.substring(0, 4));  
    698.         int month = Integer.parseInt(sdate.substring(5, 7));  
    699.         month = month + m;  
    700.         if (month < 0) {  
    701.             month = month + 12;  
    702.             year = year - 1;  
    703.         } else if (month > 12) {  
    704.             month = month - 12;  
    705.             year = year + 1;  
    706.         }  
    707.         String smonth = "";  
    708.         if (month < 10)  
    709.             smonth = "0" + month;  
    710.         else  
    711.             smonth = "" + month;  
    712.         return year + "-" + smonth + "-10";  
    713.     }  
    714.   
    715.     /**  
    716.      *  
    717.      * 功能:<br/>  
    718.      *  
    719.      * @author Tony  
    720.      * @version 2015-3-31 上午09:29:31 <br/>  
    721.      */  
    722.     public static String getOKDate(String sdate) {  
    723.         if (sdate == null || sdate.equals(""))  
    724.             return getStringDateShort();  
    725.   
    726. //    if (!VeStr.Isdate(sdate)) {  
    727. //     sdate = getStringDateShort();  
    728. //    }  
    729. //    // 将“/”转换为“-”  
    730. //    sdate = VeStr.Replace(sdate, "/", "-");  
    731.         // 如果只有8位长度,则要进行转换  
    732.         if (sdate.length() == 8)  
    733.             sdate = sdate.substring(0, 4) + "-" + sdate.substring(4, 6) + "-" + sdate.substring(6, 8);  
    734.         ParsePosition pos = new ParsePosition(0);  
    735.         Date strtodate = formatter.parse(sdate, pos);  
    736.         String dateString = formatter.format(strtodate);  
    737.         return dateString;  
    738.     }  
    739.     /**  
    740.      * 获取当前时间的前一天时间  
    741.      * @param cl  
    742.      * @return  
    743.      */  
    744.     private static String getBeforeDay(Calendar cl){  
    745.         //使用roll方法进行向前回滚  
    746.         //cl.roll(Calendar.DATE, -1);  
    747.         //使用set方法直接进行设置  
    748.         // int day = cl.get(Calendar.DATE);  
    749.         cl.add(Calendar.DATE, -1);  
    750.         return formatter.format(cl.getTime());  
    751.     }  
    752.   
    753.     /**  
    754.      * 获取当前时间的后一天时间  
    755.      * @param cl  
    756.      * @return  
    757.      */  
    758.     private static String getAfterDay(Calendar cl){  
    759.         //使用roll方法进行回滚到后一天的时间  
    760.         //cl.roll(Calendar.DATE, 1);  
    761.         //使用set方法直接设置时间值  
    762.         //int day = cl.get(Calendar.DATE);  
    763.         cl.add(Calendar.DATE, 1);  
    764.         return formatter.format(cl.getTime());  
    765.     }  
    766.   
    767.     private static String getDateAMPM(){  
    768.         GregorianCalendar ca = new GregorianCalendar();  
    769.         //结果为“0”是上午     结果为“1”是下午  
    770.         int i=ca.get(GregorianCalendar.AM_PM);  
    771.         return i==0?"AM":"PM";  
    772.     }  
    773.     private static int compareToDate(String date1,String date2){  
    774.         return date1.compareTo(date2);  
    775.     }  
    776.     private static int compareToDateString(String date1,String date2){  
    777.         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
    778.         int i=0;  
    779.         try {  
    780.             long ldate1=formatter.parse(date1).getTime();  
    781.             long ldate2=formatter.parse(date2).getTime();  
    782.             if(ldate1>ldate2){  
    783.                 i=1;  
    784.             }else if(ldate1==ldate2){  
    785.                 i=0;  
    786.             }else{  
    787.                 i=-1;  
    788.             }  
    789.   
    790.         } catch (ParseException e) {  
    791.             e.printStackTrace();  
    792.         }  
    793.         return i;  
    794.     }  
    795.   
    796.     public static String[] getFiveDate(){  
    797.         String[] dates=new String[2];  
    798.         Calendar calendar = Calendar.getInstance();  
    799.         calendar.setTime(new Date());  
    800.         String five=" 05:00:00";  
    801.   
    802.         if(getDateAMPM().equals("AM")&&compareToDateString(getStringDate(),getStringDateShort()+five)==-1){  
    803.             dates[0]=getBeforeDay(calendar)+five;  
    804.             dates[1]=getStringDateShort()+five;  
    805.         }else{  
    806.             dates[0]=getStringDateShort()+five;  
    807.             dates[1]=getAfterDay(calendar)+five;  
    808.         }  
    809.   
    810.         return dates;  
    811.     }  
    812.     public static String getFiveDate2(){  
    813.         Calendar calendar = Calendar.getInstance();  
    814.         calendar.setTime(new Date());  
    815.         String five=" 05:00:00";  
    816.         String reStr="";  
    817.         if(getDateAMPM().equals("AM")&&compareToDateString(getStringDate(),getStringDateShort()+five)==-1){  
    818.             reStr=getBeforeDay(calendar);  
    819.         }else{  
    820.             reStr=getStringDateShort();  
    821.         }  
    822.         return reStr;  
    823.     }  

    展开全文
  • 日期和时间格式由 日期和时间模式字符串 指定。在 日期和时间模式字符串 中,未加引号的字母 'A' 到 'Z' 和 'a' 到 'z' 被解释为模式字母,用来表示日期或时间字符串元素。文本可以使用单引号 (') 引起来,以免进行...

    日期和时间格式由 日期和时间模式字符串 指定。在 日期和时间模式字符串 中,未加引号的字母 'A' 到 'Z' 和 'a' 到 'z' 被解释为模式字母,用来表示日期或时间字符串元素。文本可以使用单引号 (') 引起来,以免进行解释。所有其他字符均不解释;只是在格式化时将它们简单复制到输出字符串
    白话文的讲:这些A——Z,a——z这些字母(不被单引号包围的)会被特殊处理替换为对应的日期时间,其他的字符串还是原样输出。

    日期和时间模式(注意大小写,代表的含义是不同的)

    yyyy:年
    MM:月
    dd:日
    hh:1~12小时制(1-12)
    HH:24小时制(0-23)
    mm:分
    ss:秒
    S:毫秒
    E:星期几
    D:一年中的第几天
    F:一月中的第几个星期(会把这个月总共过的天数除以7)
    w:一年中的第几个星期
    W:一月中的第几星期(会根据实际情况来算)
    a:上下午标识
    k:和HH差不多,表示一天24小时制(1-24)。
    K:和hh差不多,表示一天12小时制(0-11)。
    z:表示时区  

    (2017-12-28日,更新)

    因为看到了Java 8 里面对日期的格式化操作的API,回头又看了看这个以前的日期格式化。发现,文中的实例不是很全面。不符合湿胸的性格,特地来完善一下。

        private static void formatDataTest() {
            /*
             * 日期转期望格式的字符串
             */
            //HH 和 hh 的差别:前者是24小时制,后者是12小时制。
            StringBuilder sb = new StringBuilder();
            sb.append("yyyy年MM月dd日 HH:mm:ss")
                    .append(" 上下午标志 a")
                    .append(" E")
                    .append(" 一年中的第D天")
                    .append(" 一月中的第F个星期")
                    .append(" 一年中的第w个星期")
                    .append(" 一月中的第W个星期")
                    .append(" Z")
                    .append(" z");
            SimpleDateFormat sdf = new SimpleDateFormat(sb.toString());
            String dateString = sdf.format(new Date());
            System.out.println(dateString);
            /*
             * 字符串转日期
             */
            Date date;
            try {
                date = sdf.parse(dateString);
                System.out.println(date);
            } catch (ParseException e) {
                System.out.println(e.getMessage());
            }
        }

    运行结果:
    2017年12月28日 18:21:731 上下午标志 下午 星期四 一年中的第362天 一月中的第4个星期 一年中的第52个星期 一月中的第5个星期 +0800 CST
    Thu Dec 28 18:21:00 CST 2017

     

    这里多说一句,一个月中的第几个星期,  F   这个出来的结果,不靠谱,具体我就在这多做测试啦,我是测试过,才这么说的,还是后面的那个  W  靠谱。

    (更新完成)

    具体简单常见的实例:

    package com.lxk.DateFormat;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /**
     * Created by lxk on 2016/11/4
     */
    public class Format {
        public static void main(String[] args) {
            Date ss = new Date();
            System.out.println("一般日期输出:" + ss);
            System.out.println("时间戳:" + ss.getTime());
            //Date aw = Calendar.getInstance().getTime();//获得时间的另一种方式,测试效果一样
            SimpleDateFormat format0 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String time = format0.format(ss.getTime());//这个就是把时间戳经过处理得到期望格式的时间
            System.out.println("格式化结果0:" + time);
            SimpleDateFormat format1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
            time = format1.format(ss.getTime());
            System.out.println("格式化结果1:" + time);
        }
    }
    

    测试结果图:

    需要什么格式,自己拼好字符串,就可以格式化日期啦。授人以渔呀有木有。

    喷子们要是觉得简单呢,就省省唾沫星子吧。我就记个笔记用。

    上面的是:日期转自己想要的字符串格式,下面是字符串转日期类型

        private static void testStringToDate() {
            String s = "2017-05-25";
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date date = null;
            try {
                date = format.parse(s);
            } catch (ParseException e) {
                System.out.println(e.getMessage());
            }
            System.out.println(date);
        }

    下面是运行的debug截图。

    上面的那个  日期和时间模式  是按我们常用的年月日时分秒来放的,下面传个别人的专业的图,供参考。

    定义了以下模式字母(所有其他字符 'A' 到 'Z' 和 'a' 到 'z' 都被保留):

    我写完文章,给自己点个赞,不过分吧,
    不过分,那我可就点啦啊。
    我先点为敬,你们随意。大家随意。不要客气。。。

    展开全文
  • 刚开始我的想法只是通过JS 判断日期的时间戳大小来决定,我就是那个例子,下面我想做的是在用户端限制用户的选择时间。 element-ui 中,提供 picker-options 对当前时间日期选择器特有的选项配置。这里主要使用 ...

    使用场景:当我们的开始时间和结束时间被要求分开输入时,我们如何让开始时间一定在结束时间的时间前面呢?刚开始我的想法只是通过JS 判断日期的时间戳大小来决定,我就是那个例子,下面我想做的是在用户端限制用户的选择时间。

    element-ui 中,提供 picker-options 对当前时间日期选择器特有的选项配置。这里主要使用 disabledDate,其返回值为 Boolean类型。

    这里设定两个时间组件,分别选择开始时间和结束时间。

    <el-form-item label="开始时间">
      <el-date-picker 
        v-model="form.timeBegin" 
        type="date" 
        value-format="timestamp"
        :picker-options="pickerOptionsStart"
        placeholder="选择日期时间"
        style="width: 100%">
      </el-date-picker>
    </el-form-item>
    <el-form-item label="结束时间">
      <el-date-picker 
        v-model="form.timeEnd" 
        type="date" 
        value-format="timestamp"
        :picker-options="pickerOptionsEnd"
        placeholder="选择日期时间"
        style="width: 100%">
      </el-date-picker>
    </el-form-item>

    如何判断开始时间的日期选择器,日期选择器的范围更结束时间有关,(小于结束时间)。当结束时间不为空时,可选时间大于结束时间的,即 disabledData  返回值为 true 的日期都禁止选中。同理判断结束时间选中时间区域。

    // data 中设定
    pickerOptionsStart: {
      disabledDate: time => {
        let endDateVal = this.form.timeEnd;
        if (endDateVal) {
          return time.getTime() > endDateVal;
        }
      }
    },
    pickerOptionsEnd: {
      disabledDate: time => {
        let beginDateVal = this.form.timeBegin;
        if (beginDateVal) {
          return time.getTime() < beginDateVal;
        }
      }
    }

    这里只是个人的见解,更多详情,请详细阅读element-ui 官网,若有不正确的地方,希望大家多多指教。案例

    展开全文
  • JAVA 日期加减计算

    千次阅读 2019-08-01 19:46:55
    1.获取当前系统时间 Date date = new Date(); 2.实现时间的加减的两种方法 第一种:用java.text.SimpleDateFormat来实现 SimpleDateFormat df=new ...System.out.println("今天的日期:"+df.format(date...

    1.获取当前系统时间
        Date date = new Date();

    2.实现时间的加减的两种方法

    第一种:  用java.text.SimpleDateFormat来实现

       SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");  
       System.out.println("今天的日期:"+df.format(date));  
       System.out.println("两天前的日期:" + df.format(new Date(date.getTime() - 2 * 24 * 60 * 60 * 1000)));  
       System.out.println("三天后的日期:" + df.format(new Date(date.getTime() + 3 * 24 * 60 * 60 * 1000)));

    获取当前毫秒值进行加减.

    第二种:用java.util.Calender来实现
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);//设置起时间
        //System.out.println("111111111::::"+cal.getTime());
        cal.add(Calendar.YEAR, 1);//增加一年
        //cd.add(Calendar.DATE, 1);//增加一天  
       //cd.add(Calendar.DATE, -10);//减10天  
        //cd.add(Calendar.MONTH, 1);//增加一个月   
        System.out.println("输出::"+cal.getTime());

    转载:https://blog.csdn.net/z947663039/article/details/81097465 
     

    展开全文
  • 日期例子:SELECT TO_DATE('2006-05-01 19:25:34', 'YYYY-MM-DD HH24:MI:SS') FROM DUAL SELECT TO_DATE('2006-05-01 19:25', 'YYYY-MM-DD HH24:MI') FROM DUAL SELECT TO_DATE('2006-05-01 19', 'YYYY-MM-DD HH24')...
  • [size=medium][b] Java 语言的Calendar(日历),Date(日期), 和DateFormat(日期格式)组成了Java标准的一个基本但是非常重要的部分. 日期是商业逻辑计算一个要害的部分. 所有的开发者都应该能够计算未来的日期, 定制...
  • 日期&日期格式&日历

    2010-07-26 20:16:34
    在项目开发工作中,日期是商业逻辑计算一个要害的部分. 因此,开发者必须能够计算未来的日期, 定制日期的显示格式, 并将文本数据解析成日期对象. 而在Java中,Calendar(日历),Date(日期), 和DateFormat(日期格式...
  • Date日期对象 日期也是个对象,日期对象也是由类产生的java.util.date Date类构造方法 方法名 方法解释 Date() 返回当前系统的日期和时间 Date(long time) 传递毫秒值 日期和时间定位到指定的毫秒值 pub...
  • 日期的格式转换: 计时的方法: nanoTIme与currentTimeMilis() 日历类:星期从周日开始开始,月份也以0为1 获取某年某月有多少天 设置日期 你来到这个世界多少天 转载于:...
  • 日期&日期格式&日历

    2011-08-17 08:57:59
    在项目开发工作中,日期是商业逻辑计算一个要害的部分. 因此,开发者必须能够计算未来的日期, 定制日期的显示格式, 并将文本数据解析成日期对象. 而在java中,calendar(日历),date(日期), 和dateformat(日期格式)...
  • js 给日期加一天或者减一天

    万次阅读 多人点赞 2019-02-13 17:46:56
    首先,我们创建个需要加减的日期变量: var dateTime=new Date(); 一、加一天 dateTime=dateTime.setDate(dateTime.getDate()+1); dateTime=new Date(dateTime); 二、减一天  与上面相似,把setDate方法中...
  • Oracle TO_DATE 日期格式大全

    万次阅读 多人点赞 2018-02-22 14:52:32
    转自http://apps.hi.baidu.com/share/detail/10070907Oracle TO_DATE 日期格式大全Oracle中TO_DATE格式2009-04-14 10:53TO_DATE格式(以时间:2007-11-02 13:45:25为例) Year: yy two digits 两位年 ...
  • 1. 1 计算间隔年/月/日的日期 1.1 EDATE函数 EDATE函数用于指定某个日期N月之后或是N月之前的日期。 用法为:EDATE(开始日期,指定月份) 1.2 具体应用:计算转正日期 如下图,要根据B列的员工入职日期和C列的试用期...
  • Hive中日期处理函数 根据平时项目中使用的日期函数,进行简单的总结: date_format:将日期进行格式化 date_add:对当前日期增加天数 date_sub:对当前日期减少天数 next_day:取当前日期的下一个周几 last_day:...
  • python中获取当前日期

    万次阅读 2018-03-01 11:04:22
    datetime:日期时间模块,提供多种方法操作日期和时间strftime:对日期时间格式化获取今天的日期,昨天的日期,格式化的日期&gt;&gt;&gt; import datetime &gt;&gt;&gt; today=datetime....
  • LaTeX去掉默认显示日期时间

    万次阅读 2016-06-09 09:29:50
    LaTeX默认情况下会显示日期时间,该时间是编译时的日期,有时候我们并不需要显示该日期,该怎么办呢? 方法: 使用\date关键字并将{}里的内容置空即可,即: \date{} 重新编译,这样就不显示时间了。
  • SQL中常用日期函数

    万次阅读 2018-03-26 11:24:40
    --1 GETDATE() 返回当前系统日期 SELECT GETDATE()   --2 DATEADD(日期部分,常数,日期) 返回将日期的指定日期部分加常数后的结果返回 日期部分可以是: --常数为正 SELECT DATEADD(YY,1,GETDATE()) --...
  • excel中日期转换成指定的文本格式

    万次阅读 2013-10-16 09:48:51
    Excel中的日期格式经常不是YYYY-MM-DD这种格式,但是在使用是经常需要转换成这种格式,可以使用如下的方式进行处理。 1、如果只是单纯的显示,不修改具体值的话,可以在B列上点击右键,然后如下图所示,将类型改为”...
  • 在页面上获取input标签中的值为字符型,如果是一个合法的日期字符串需要转换成日期数据。那么在JQuery中可以使用下面的方法: $holdDate = $("input[name='holdDate']").val();//举行时间 $closingDate = $("input...
1 2 3 4 5 ... 20
收藏数 1,297,764
精华内容 519,105
关键字:

日期