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. long ei=el-sl;
  17. //根据毫秒数计算间隔天数
  18. 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. long ei=el-sl;
  17. //根据毫秒数计算间隔天数
  18. return (int)(ei/(1000*60*60*24));
  19. }

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

java 常用日期函数总结的相关文章

C# 常用日期函数

我想知道取的时期是几月.几日,然后做一些统计,上网找了一些方法. --DateTime 数字型 System.DateTime currentTime=new System.DateTime(); 1.1 取当前年月日时分秒 currentTime=System.DateTime.Now; 1.2 取当前年 int 年=currentTime.Year; 1.3 取当前月 int 月=currentTime.Month; 1.4 取当前日 int 日=currentTime.Day; 1.5 取

常用日期函数使用结合

static int MthDiff1(date d1, date d2){    int daysDiff = d1 - d2 - 1; if (daysDiff >= 0)        return (year(num2date(daysDiff)) - 1900)*12 + mthofyr(num2date(daysDiff));    else        return -1 * (year(num2date(-1 * daysDiff)) - 1900) * 12 + mthofy

[Java]常用日期处理

最近在复习Java基础,发现Java中关于日期处理的类比较杂乱,新手常常无法找到合适的方法.于是决定写一篇博文介绍一下Java常用的日期处理. Java中常用的日期相关类以及它们之间的关系如下图所示,其中中间的Date是指java.util.Date,左下的Date指java.sql.Date.这几个类几乎包含了所有常用日期处理的方法,下边将分别详细介绍一下它们. 1.Date(java.util.Date) Date类应该是Java中最早用于日期处理的类了,它的无参构造函数可以创建一个表示当前

Oracle SQL日期比较和常用日期函数

一.oracle sql日期比较 在今天之前: select * from up_date where update < to_date('2007-09-07 00:00:00','yyyy-mm-dd hh24:mi:ss') select * from up_date where update <= to_date('2007-09-07 00:00:00','yyyy-mm-dd hh24:mi:ss') 在今天只后: select * from up_date where updat

Java常用日期、时间格式化转换符

常用日期.时间格式化转换符 转换符 说明 %te 一年中的某一天 %tb 指定语言环境的月份简称 %tB 指定语言环境的月份全称 %tA 指定语言环境的星期几全称 %ta 指定语言环境的星期几简称 %tc 包括全部日期和时间信息 %tY 4位年份 %tj 一年中的第几天 %tm 月份 %td 一个月中的第几天 %ty 2位年份 %tH 2位数字的24时制的小时 %tI 2位数字的12时制的小时 %tk 2位数字的24时制的小时 %tl 2位数字的12时制的小时 %tM 2位数字的分钟 %tS 2

Oracle常用日期函数

常用的时间格式掩码如下:掩码元素       含义YYYY           四位数年份 (如:2005)     yearYY             二位数年份(如  05) Q                季度(1-4) MM             月份(01-12)      monthWW           年的星期数(1-53),其中第一星期为年的第一天至第七天 W             月的星期数(1-5),其中第一星期为月的第一天至第七天 DDD          年的

MySql常用日期函数(转载)

/*date_add(date,interval expr type)和date_sub(date,interval expr type)执行日期运算. date 是一个 datetime 或date值,用来指定起始时间. expr 是一个表达式,用来指定从起始日期添加或减去的时间间隔值. expr是一个字符串;对于负值的时间间隔,它可以以一个 ‘-’开头. type 为关键词,它指示了表达式被解释的方式. 关键词interva及 type 分类符均不区分大小写. 日期操作,adddate就是d

java常用日期类型转换

import java.math.BigDecimal; import java.math.RoundingMode; import java.text.DecimalFormat; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import org.apache.commons.lang.StringUtils; import org.joda.time.DateTime

java常用日期操作方法

package com.wujiangpo.test.util; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.regex.Pattern; public class DateUtil { private