码迷，mamicode.com
首页 > 编程语言 > 详细

java 常用日期函数总结

时间：2017-03-14 22:37:30      阅读：350      评论：0      收藏：0      [点我收藏+]

标签：不能   char   情况   max   gen   大于   lda   eth   between   

计算某一月份的最大天数 

Java代码  技术分享
  1. Calendar time=Calendar.getInstance();   
  2. //time.clear();   
  3. //time.set(Calendar.YEAR,year);   
  4. //time.set(Calendar.MONTH,month-1); //注意,Calendar对象默认一月为0               
  5. int day=time.getActualMaximum(Calendar.DAY_OF_MONTH);//本月份的天数  


注：在使用set方法之前，必须先clear一下，否则很多信息会继承自系统当前时间 
2.Calendar和Date的转化 
(1) Calendar转化为Date 

Java代码  技术分享
  1. Calendar cal=Calendar.getInstance();  
  2. Date date=cal.getTime();  


(2) Date转化为Calendar 

Java代码  技术分享
  1. Date date=new Date();  
  2. Calendar cal=Calendar.getInstance();  
  3. cal.setTime(date);  


3.格式化输出日期时间 

Java代码  技术分享
  1. import java.util.Date;  
  2. Date date=new Date();  
  3. SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");  
  4. System.out.println(df.format(date));  


4.计算一年中的第几星期 
(1)计算某一天是一年中的第几星期 

Java代码  技术分享
  1. Calendar cal=Calendar.getInstance();  
  2. cal.set(Calendar.YEAR, 2006);  
  3. cal.set(Calendar.MONTH, 8);  
  4. cal.set(Calendar.DAY_OF_MONTH, 3);  
  5. int weekno=cal.get(Calendar.WEEK_OF_YEAR);  


(2)计算一年中的第几星期是几号 

Java代码  技术分享
  1. SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");  
  2. Calendar cal=Calendar.getInstance();  
  3. cal.set(Calendar.YEAR, 2006);  
  4. cal.set(Calendar.WEEK_OF_YEAR, 1);  
  5. cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);  
  6. System.out.println(df.format(cal.getTime()));  


输出: 
2006-01-02 
5.add()和roll()的用法 
(1)add()方法 

Java代码  技术分享
  1. SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");  
  2. Calendar cal=Calendar.getInstance();  
  3. cal.set(Calendar.YEAR, 2006);  
  4. cal.set(Calendar.MONTH, 8);  
  5. cal.set(Calendar.DAY_OF_MONTH, 3);  
  6. cal.add(Calendar.DATE, -4);  
  7. Date date=cal.getTime();  
  8. System.out.println(df.format(date));  
  9. cal.add(Calendar.DATE, 4);  
  10. date=cal.getTime();  
  11. System.out.println(df.format(date));  


输出： 
    2006-08-30 
    2006-09-03 
(2)roll方法 

Java代码  技术分享
  1. cal.set(Calendar.YEAR, 2006);  
  2. cal.set(Calendar.MONTH, 8);  
  3. cal.set(Calendar.DAY_OF_MONTH, 3);  
  4. cal.roll(Calendar.DATE, -4);  
  5. date=cal.getTime();  
  6. System.out.println(df.format(date));  
  7. cal.roll(Calendar.DATE, 4);  
  8. date=cal.getTime();  
  9. System.out.println(df.format(date));  


输出： 
    2006-09-29 
    2006-09-03 
可见，roll()方法在本月内循环，一般使用add()方法； 
6.计算两个任意时间中间的间隔天数 
(1)传进Calendar对象 

Java代码  技术分享
  1. /** *//**计算两个时间之间相隔天数 
  2.      * @param startday  开始时间 
  3.      * @param endday 结束时间 
  4.      * @return 
  5.      */  
  6.     public int getIntervalDays(Calendar startday,Calendar endday)...{  
  7.         //确保startday在endday之前  
  8.         if(startday.after(endday))...{  
  9.             Calendar cal=startday;  
  10.             startday=endday;  
  11.             endday=cal;  
  12.         }  
  13.         //分别得到两个时间的毫秒数  
  14.         long sl=startday.getTimeInMillis();  
  15.         long el=endday.getTimeInMillis();  
  16.           
  17.         long ei=el-sl;      
  18.         //根据毫秒数计算间隔天数  
  19.         return (int)(ei/(1000*60*60*24));   }  


(2)传进Date对象 

Java代码  技术分享
  1. /** *//**计算两个时间之间相隔天数 
  2.      * @param startday  开始时间 
  3.      * @param endday 结束时间 
  4.      * @return 
  5.      */  
  6.     public int getIntervalDays(Date startday,Date endday)...{  
  7.         //确保startday在endday之前  
  8.         if(startday.after(endday))...{  
  9.             Date cal=startday;  
  10.             startday=endday;  
  11.             endday=cal;  
  12.         }  
  13.         //分别得到两个时间的毫秒数  
  14.         long sl=startday.getTime();  
  15.         long el=endday.getTime();  
  16.           
  17.         long ei=el-sl;      
  18.         //根据毫秒数计算间隔天数  
  19.         return (int)(ei/(1000*60*60*24));  
  20.     }  


同理，可以用相同的方法计算出任意两个时间相隔的小时数，分钟数，秒钟数等 
注：以上方法是完全按时间计算，有时并不能令人满意，如： 
startday="2006-10-11 20:00:00" 
endday="2006-10-12 8:00:00" 

Java代码  技术分享
  1. //只要格式正确，直接比较字符串就可以了呀，精确到秒的也一样     
  2.   String   s1   =   "2003-12-12   11:30:24";     
  3.   String   s2   =   "2004-04-01   13:31:40";     
  4.   int   res   =   s1.compareTo(s2);     
  5.       
  6.   //求日期差：     
  7.   SimpleDateFormat   df   =   new   SimpleDateFormat("yyyy-MM-dd   HH:mm:ss");     
  8.   Date   begin=df.parse("2004-01-02   11:30:24");     
  9.   Date   end   =   df.parse("2004-03-26   13:31:40");     
  10.   long   between=(end.getTime()-begin.getTime())/1000;//除以1000是为了转换成秒     
  11.   int   day=between/(24*3600);     
  12.   int   hour=between%(24*3600)/3600;     
  13.   int   minute=between%3600/60;     
  14.   int   second=between%60/60;  


计算结果为0，但是我们也许相让计算结果变为1，此时可以用如下方法实现： 
在传参之前，先设定endday的时间，如： 
        endday.set(Calendar.HOUR_OF_DAY, 23); 
         endday.set(Calendar.MINUTE, 59); 
        endday.set(Calendar.SECOND, 59); 
        endday.set(Calendar.MILLISECOND, 59); 
这样再传进去startday,endday，则结果就如我们所愿了。不过，如果嫌以上方法麻烦，可以参考以下方法： 
(3)改进精确计算相隔天数的方法 
   

Java代码  技术分享
  1. public int getDaysBetween (Calendar d1, Calendar d2) ...{  
  2.         if (d1.after(d2)) ...{  // swap dates so that d1 is start and d2 is end  
  3.             java.util.Calendar swap = d1;  
  4.             d1 = d2;  
  5.             d2 = swap;  
  6.         }  
  7.         int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR);  
  8.         int y2 = d2.get(Calendar.YEAR);  
  9.         if (d1.get(Calendar.YEAR) != y2) ...{  
  10.             d1 = (Calendar) d1.clone();  
  11.             do ...{  
  12.                 days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);//得到当年的实际天数  
  13.                 d1.add(Calendar.YEAR, 1);  
  14.             } while (d1.get(Calendar.YEAR) != y2);  
  15.         }  
  16.         return days;  
  17.     }  



得到明天的算法 

Java代码  技术分享
  1. GregorianCalendar   gc   =   new   GregorianCalendar();   
  2.                 gc.add(GregorianCalendar.DATE,1);   
  3.                 SimpleDateFormat   ymdf       =   new   SimpleDateFormat( "yyyy-MM-dd ");   
  4.                 System.out.println(ymdf.format(new   Date(gc.getTimeInMillis())));  




Java代码  技术分享
  1. /** 
  2.      * 传入的时间减去分钟 
  3.      * @param startday 传入的时间 
  4.      * @param time 需要减去的分钟数 
  5.      * @return 
  6.      */  
  7.     public String subDate(Date startday,int time){  
  8.         long Time1=startday.getTime()/1000-60*time;  
  9.         startday.setTime(Time1*1000);  
  10.         return CommonFunc.ConvertDateToStr(startday,Constants.YYYYMMDDHHMMSS);  
  11.     }  




【代码实现】：两个日期之间的工作日时间差（精确到毫秒） 

【代码特点】： 

1.支持跨年。 

2.获取的是精确到毫秒的时间差。 

3.国家法定假日未计算在内（像阴历这种的只有通过加入LIST的方法了=。=）。 

Java代码  技术分享
    1. package com.wednesday.tools.timetools;    
    2.     
    3. import java.text.ParseException;    
    4. import java.text.SimpleDateFormat;    
    5. import java.util.Calendar;    
    6. import java.util.Date;    
    7.     
    8. public class GetWorkDayTimeMillisecond {    
    9.     
    10.     /**  
    11.      * @param args  
    12.      */    
    13.     public static void main(String[] args) {    
    14.         // TODO Auto-generated method stub    
    15.         GetWorkDayTimeMillisecond a = new GetWorkDayTimeMillisecond();    
    16.         Long b=a.getWorkdayTimeInMillis("2010-05-17 8-00-00", "2010-05-18 9-00-00", "yyyy-MM-dd HH-mm-ss");    
    17.         System.out.println(b);    
    18.     }    
    19.     /**  
    20.      * 获取两个时间之内的工作日时间（只去掉两个日期之间的周末时间，法定节假日未去掉）  
    21.      * @param start -起始时间，共有3个重载方法，可以传入long型，Long型，与Date型  
    22.      * @param end -结束时间，共有3个重载方法，可以传入long型，Long型，与Date型  
    23.      * @return Long型时间差对象  
    24.      */    
    25.     public Long getWorkdayTimeInMillis(long start, long end){    
    26.         //如果起始时间大于结束时间，将二者交换    
    27.         if(start>end){    
    28.             long temp = start;    
    29.             start = end;    
    30.             end = temp;    
    31.         }    
    32.         //根据参数获取起始时间与结束时间的日历类型对象    
    33.         Calendar sdate = Calendar.getInstance();    
    34.         Calendar edate = Calendar.getInstance();    
    35.         sdate.setTimeInMillis(start);    
    36.         edate.setTimeInMillis(end);    
    37.         //如果两个时间在同一周并且都不是周末日期，则直接返回时间差，增加执行效率    
    38.         if(sdate.get(Calendar.YEAR)==edate.get(Calendar.YEAR)    
    39.                 && sdate.get(Calendar.WEEK_OF_YEAR)==edate.get(Calendar.WEEK_OF_YEAR)    
    40.                 && sdate.get(Calendar.DAY_OF_WEEK)!=1 && sdate.get(Calendar.DAY_OF_WEEK)!=7    
    41.                 && edate.get(Calendar.DAY_OF_WEEK)!=1 && edate.get(Calendar.DAY_OF_WEEK)!=7){    
    42.             return new Long(end-start);    
    43.         }    
    44.         //首先取得起始日期与结束日期的下个周一的日期    
    45.         Calendar snextM = getNextMonday(sdate);    
    46.         Calendar enextM = getNextMonday(edate);    
    47.         //获取这两个周一之间的实际天数    
    48.         int days = getDaysBetween(snextM, enextM);    
    49.         //获取这两个周一之间的工作日数(两个周一之间的天数肯定能被7整除，并且工作日数量占其中的5/7)    
    50.         int workdays = days/7*5;    
    51.         //获取开始时间的偏移量    
    52.         long scharge = 0;    
    53.         if(sdate.get(Calendar.DAY_OF_WEEK)!=1 && sdate.get(Calendar.DAY_OF_WEEK)!=7){    
    54.             //只有在开始时间为非周末的时候才计算偏移量    
    55.             scharge += (7-sdate.get(Calendar.DAY_OF_WEEK))*24*3600000;    
    56.             scharge -= sdate.get(Calendar.HOUR_OF_DAY)*3600000;    
    57.             scharge -= sdate.get(Calendar.MINUTE)*60000;    
    58.             scharge -= sdate.get(Calendar.SECOND)*1000;    
    59.             scharge -= sdate.get(Calendar.MILLISECOND);    
    60.         }    
    61.         //获取结束时间的偏移量    
    62.         long echarge = 0;    
    63.         if(edate.get(Calendar.DAY_OF_WEEK)!=1 && edate.get(Calendar.DAY_OF_WEEK)!=7){    
    64.             //只有在结束时间为非周末的时候才计算偏移量    
    65.             echarge += (7-edate.get(Calendar.DAY_OF_WEEK))*24*3600000;    
    66.             echarge -= edate.get(Calendar.HOUR_OF_DAY)*3600000;    
    67.             echarge -= edate.get(Calendar.MINUTE)*60000;    
    68.             echarge -= edate.get(Calendar.SECOND)*1000;    
    69.             echarge -= edate.get(Calendar.MILLISECOND);    
    70.         }    
    71.         //计算最终结果，具体为：workdays加上开始时间的时间偏移量，减去结束时间的时间偏移量    
    72.         return workdays*24*3600000+scharge-echarge;    
    73.     }    
    74.     public Long getWorkdayTimeInMillis(Long start, Long end){    
    75.         return getWorkdayTimeInMillis(start.longValue(), end.longValue());    
    76.     }    
    77.     public Long getWorkdayTimeInMillis(Date start, Date end){    
    78.         return getWorkdayTimeInMillis(start.getTime(), end.getTime());    
    79.     }    
    80.     public Long getWorkdayTimeInMillis(String start, String end, String format){    
    81.         SimpleDateFormat sdf = new SimpleDateFormat(format);    
    82.         Date sdate;    
    83.         Date edate;    
    84.         try {    
    85.             sdate = sdf.parse(start);    
    86.             edate = sdf.parse(end);    
    87.             return getWorkdayTimeInMillis(sdate, edate);    
    88.         } catch (ParseException e) {    
    89.             e.printStackTrace();    
    90.             return new Long(0);    
    91.         }    
    92.     }    
    93.     private Calendar getNextMonday(Calendar cal){    
    94.         int addnum=9-cal.get(Calendar.DAY_OF_WEEK);    
    95.         if(addnum==8)addnum=1;//周日的情况    
    96.         cal.add(Calendar.DATE, addnum);    
    97.         return cal;    
    98.     }    
    99.     /**  
    100.      * 获取两个日期之间的实际天数，支持跨年  
    101.      */    
    102.     public int getDaysBetween(Calendar start, Calendar end){    
    103.         if(start.after(end)){    
    104.             Calendar swap = start;    
    105.             start = end;    
    106.             end = swap;    
    107.         }    
    108.         int days = end.get(Calendar.DAY_OF_YEAR)- start.get(Calendar.DAY_OF_YEAR);    
    109.         int y2 = end.get(Calendar.YEAR);    
    110.         if (start.get(Calendar.YEAR) != y2) {    
    111.             start = (Calendar) start.clone();    
    112.             do {    
    113.                 days += start.getActualMaximum(Calendar.DAY_OF_YEAR);    
    114.                 start.add(Calendar.YEAR, 1);    
    115.             }while(start.get(Calendar.YEAR) != y2);    
    116.         }    
    117.         return days;    
    118.     }    
    119.     
    120. }

java 常用日期函数总结

标签：不能   char   情况   max   gen   大于   lda   eth   between   

原文地址：http://www.cnblogs.com/mfc-itblog/p/6551116.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！