java 常用日期函数总结

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java 常用日期函数总结相关的知识,希望对你有一定的参考价值。

计算某一月份的最大天数 

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 常用日期函数总结的主要内容,如果未能解决你的问题,请参考以下文章

Java8新特性函数式编程API新时间日期处理APIOptional容器类总结

Java8新特性函数式编程API新时间日期处理APIOptional容器类总结

Java8新特性函数式编程API新时间日期处理APIOptional容器类总结

Java8新特性函数式编程API新时间日期处理APIOptional容器类总结

mysql 常用的时间日期函数小结

PHP 中日期时间函数 date() 用法总结