用JAVA计算星期几的算法

转载 2013年12月04日 22:01:50

由于我们现在的实际时间,是有相关机构不停的调整,所以JAVA默认用的Calendar对象算出来的时间老是不对,即使你修正过参数,可能过一段时间,你就会发现算出来的结果又不对了,所以真正想要处理这个问题,要么求助于数据库,要么自己写算法。


下面就写一个算法来解决这个问题:

先把算法贴出来,有心情看推理过程的同学可以往下看,不想看的就把算法贴出来直接用就可以了。

    public static int getWeek(int y, int m, int d) {
        if (m < 3) {
            m += 12;
            --y;
        }
        int w = (d + 1 + 2 * m + 3 * (m + 1) / 5 + y + (y >> 2) - y / 100 + y / 400) % 7;
        return w;
    }


  

       计算给定日期星期几好象是编程都会遇到的问题,最近论坛里也有人提到这个问题,并给出了一个公式:   
          W=  (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)   mod   7  
 
          (要求将12月当作上一年的1314月来计算)   
   
 
          去看了看这个公式的原帖                       http://blog.csdn.net/ycrao/archive/2000/11/24/3825.aspx   
         
其讲述的过程并不清楚,便想怎样自己推导出一个公式来,花了几个小时,总算是弄出来了,结果跟上面的公式一样:)   
 ========================================================  
 
    
  下面我们完全按自己的思路由简单到复杂一步步进行推导……   
   
 
  推导之前,先作两项规定:   
 
  y,   m,   d,   w 分别表示      星期(w=0-6  代表星期日-星期六   
 
我们从  公元011日星期日   开始   
   
 
    
  一、只考虑最开始的   7   天,即   d   =   1---7   变换到   w   =   0---6   
         
很直观的得到:   
          w   =  d-1  
 
    
  二、扩展到整个1月份   
         
7的概念大家都知道了,也没什么好多说的。不过也可以从我们平常用的日历中看出来,在周历里边每列都是一个按7增长的等差数列,如181522的星期都是相同的。所以得到整个1月的公式如下:   
          w   =  (d-1)   %   7     ---------  
公式   
   
 
  三、按年扩展   
         
由于按月扩展比较麻烦,所以将年扩展放在前面说   
   
 
            我们不考虑闰年,假设每一年都是   365  天。由于365752倍多1天,所以每一年的第一天和最后一天星期是相同的。   
         
也就是说下一年的第一天与上一年的第一天星期滞后一天。这是个重要的结论,每过一年,公式会有一天的误差,由于我们是从0年开始的,所以只须要简单的加上年就可以修正扩展年引起的误差,得到公式如下:   
          w   =  (d-1   +   y)   %   7    
 
    
            将闰年考虑进去   
         
每个闰年会多出一天,会使后面的年份产生一天的误差。如我们要计算200511日星期几,就要考虑前面的已经过的2004年中有多少个闰年,将这个误差加上就可以正确的计算了。   
         
根据闰年的定义(能被4整但不能被100整除或能被400),得到计算闰年的个数的算式:y/4   -   y/100   +  y/400  
         
由于我们要计算的是当前要计算的年之前的闰年数,所以要将年减1,得到了如下的公式:   
          w   =  [d-1+y   +   (y-1)/4-(y-1)/100+(y-1)/400]   %   7  -----
公式   
   
 
          现在,我们得到了按年扩展的公式,用这个公式可以计算任一年的1月份的星期   
   
 
  四、扩展到其它月   
         
考虑这个问题颇费了一翻脑筋,后来还是按前面的方法大胆假才找到突破口。   
   
 
          现在我们假设每个月都是28天,且不考虑闰年   
         
有了这个假设,计算星期就太简单了,因为28正好是7的整数倍,每个月的星期都是一样的,公式对任一个月都适用   )   
   
 
          但假设终究是假设,首先1月就不是28天,这将会造成2月份的计算误差。1月份比28天要多出3天,就是说公式的基础上,2月份的星期应该推后3天。   
         
而对3月份来说,推后也是3(2月正好28天,对3月的计算没有影响)   
         
依此类推,每个月的计算要将前面几个月的累计误差加上。   
         
要注意的是误差只影响后面月的计算,因为12月已是最后一个月,所以不用考虑12月的误差天数,同理,1月份的误差天数是0,因为前面没有月份影响它。   
   
 
          由此,想到建立一个误差表来修正每个月的计算。   
 ==================================================  
 
      误差  累计     7   
  1       3        0           0  
 
  2       0        3           3   
  3       3        3           3   
  4       2        6           6   
  5       3        8           1   
  6       2        11         4   
  7       3        13         6   
  8       3        16         2   
  9       2        19         5   
  10     3        21         0   
  11     2        24         3   
  12     -        26         5   
          (闰年时2月会有一天的误差,但我们现在不考虑)   
 ==================================================  
 
    
          我们将最后的误差表用一个数组存放   
         
在公式的基础上可以得到扩展到其它月的公式   
   
 
          e[]   =  {0,3,3,6,1,4,6,2,5,0,3,5}   
          w   =  [d-1+y   +   e[m-1]   +  (y-1)/4-(y-1)/100+(y-1)/400]   %   7   --公式   
   
 
          上面的误差表我们没有考虑闰年,如果是闰年,2月会一天的误差,会对后面的3-12月的计算产生影响,对此,我们暂时在编程时来修正这种情况,增加的限定条件是如果当年是闰年,且计算的月在2月以后,需要加上一天的误差。大概代码是这样的:   
           
 
          w   =  (d-1   +   y   +   e[m-1]   +   (y-1)/4  -   (y-1)/100   +   (y-1)/400);   
          if(m>2  &&   (y%4==0   &&   y%100!=0   ||  y%400==0)   &&   y!=0)   
                 ++w;   
          w   %=  7;   
            
          现在,已经可以正确的计算任一天的星期了。   
         
注意:0年不是闰年,虽然现在大都不用这个条件,但我们因从公元0年开始计算,所以这个条件是不能少的。   
   
 
            改进   
         
公式中,计算闰年数的子项   (y-1)/4-(y-1)/100+(y-1)/400  没有包含当年,如果将当年包含进去,则实现了如果当年是闰年,w  自动加1   
         
由此带来的影响是如果当年是闰年,1,2月份的计算会多一天误差,我们同样在编程时修正。则代码如下   
           
 
          w   =  (d-1   +   y   +   e[m-1]   +   y/4  -   y/100   +   y/400);   ----  公式   
          if(m<3  &&   (y%4==0   &&   y%100!=0   ||  y%400==0)   &&   y!=0)  
 
                 --w;   
          w   %=  7;   
            
          与前一段代码相比,我们简化了   w  的计算部分。   
         
实际上还可以进一步将常数   -1  合并到误差表中,但我们暂时先不这样做。   
           
 
          至此,我们得到了一个阶段性的算法,可以计算任一天的星期了。   
   
 
  public   class   Week   {  
          public  static   void   main(String[]   args){   
                 int   y   =   2005;   
                 int   m   =   4;   
                 int   d   =   25;   
                   
                 int   e[]   =   new  int[]{0,3,3,6,1,4,6,2,5,0,3,5};   
                 int   w   =  (d-1+e[m-1]+y+(y>>2)-y/100+y/400);   
                 if(m<3   &&   ((y&3)==0  &&   y%100!=0   ||   y%400==0)   &&  y!=0){   
                         --w;   
                 }   
                 w   %=   7;   
                   
                 System.out.println(w);   
          }   
  }

五、简化  
         
现在我们推导出了自己的计算星期的算法了,但还不能称之为公式。   
         
所谓公式,应该给定年月日后可以手工算出星期几的,但我们现在的算法需要记住一个误差表才能进行计算,所以只能称为一种算法,还不是公式。   
         
下面,我们试图消掉这个误差表……   
   
 
          =============================  
          消除闰年判断的条件表达式   
         =============================  
 
    
          由于闰年在2月份产生的误差,影响的是后面的月份计算。如果2月是排在一年的最后的话,它就不能对其它月份的计算产生影响了。可能已经有人联想到了文章开头的公式中为什么1,2月转换为上年的13,14月计算了吧   )   
   
 
          就是这个思想了,我们也将1,2月当作上一年的13,14月来看待。   
         
由此会产生两个问题需要解决:   
          1>
一年的第一天是31日了,我们要对   w  的计算公式重新推导   
          2>
误差表也发生了变化,需要得新计算   
   
 
          推导   w  计算式   
             1>  
用前面的算法算出  031日是星期3   
                  
7,   d   =   1---7    ===>     w   =   3----2   
                  
得到   w   =   (d+2)   %  7   
                  
此式同样适用于整个三月份   
             2>  
扩展到每一年的三月份  
                   [d   +   2   +   y   +  (y-1)/4   -   (y-1)/100   +   (y-1)/400]   %   7 
 
    
          误差表   
 ==================================================  
 
      误差  累计     7   
  3       3        0           0  
 
  4       2        3           3   
  5       3        5           5   
  6       2        8           1   
  7       3        10         3   
  8       3        13         6   
  9       2        16         2   
  10     3        18         4   
  11     2        21         0   
  12     3        23         2   
  13     3        26         5   
  14     -        29         1   
 ==================================================   
    
          得到扩展到其它月的公式   
          e[]   =  {0,3,5,1,3,6,2,4,0,2,5,1}  
 
          w   =  [d+2   +   e[m-3]   +y+(y-1)/4-(y-1)/100+(y-1)/400]  %   7   
          (3   <=  m   <=   14)   
    
          我们还是将   y-1  的式子进行简化   
          w   =  [d+2   +   e[m-3]   +y+y/4-y/100+y/400]   %   7 
 
          (3   <=  m   <=   14)   
    
          这个式子如果当年是闰年,会告成多1的误差   
         
但我们将1,2月变换到上一年的13,14月,年份要减1,所以这个误差会自动消除,所以得到下面的算法:   
   
 
          int   e[]  =   new   int[]{0,3,5,1,3,6,2,4,0,2,5,1};   
          if(m  <   3)   {   
                 m   +=   12;   
                 --y;   
          }   
          int   w  =   (d+2   +   e[m-3]   +y+(y/4)-y/100+y/400)  %   7;   -----公式   
   
 
          我们可以看到公式与公式几乎是一样的,仅仅是误差天和一个常数的差别   
         
常数的区别是由起始日期的星期不同引起的,011日星期日,031日星期三,有三天的差别,所以常数也从   -1   变成了   2   
   
 
          现在,我们成功的消除了繁琐的闰年条件判断。   
   
 
    
         =============================   
          消除误差表   
         =============================  
 
          假如存在一种me的函数映射关系,使得   
                 e[m-3]   =   f(m)  
 
          则我们就可以用   f(m)  取代公式中的子项   e[m-3],也就消除了误差表。   
   
 
          由于误差表只有12个项,且每一项都可以加减   7n  进行调整,这个函数关系是可以拼凑出来的。但是这个过程可能是极其枯燥无味的,我现在不想自己去推导它,我要利用前人的成果。所谓前人栽树,后人乘凉嘛  )   
   
 
          文章开头开出的公式中的   2*m+3*(m+1)/5  这个子项引起了我的兴趣   
   
 
          经过多次试试验,我运行下面的代码   
   
 
          for(m=1;  m<=14;   ++m)   
                 System.out.print((-1+2*m+3*(m+1)/5)%7   +   "  ");   
         System.out.println();   
    
          天哪,输出结果与我的误差表不谋而合,成功了,哈哈   
   
 
          2   4  0   3   5   1   3   6   2   4  0   2   5   1   
          Press  any   key   to   continue...   
    
          上面就是输出结果,看它后面的12项,与我的误差表完全吻合!!!   
   
 
          现在就简单的,将   f(m)   =   -1   +  2*m   +   3*(m+1)/5  代入公式,得到   
   
 
          w   =  (d+1+2*m+3*(m+1)/5+y+(y/4)-y/100+y/400)   %   7   ----公式6   
         
约束条件:   m=1,m=2     m=m+12,y=y-1;   
   
 
          现在,我们得到了通用的计算星期的公式,并且完全是按自己的思想推导出来的(那个函数映射关系不算),只要理解了这个推导的步骤,即使有一天忘记了这个公式,也可以重新推导出来!   
   
 
          可能有人会注意到公式与文章开头的公式相差一个常数   1,这是因为原公式使用数字0--6表示星期一到星期日,而我用0--6表示星期日到星期六。实际上是一样,你可以改成任意你喜欢的表示方法,只需改变这个常数就可以了。   
   
 
    
  六、验证公式的正确性。   
   
 
          一个月中的日期是连续的,只要有一天对的,模7的关系就不会错,所以一个月中只须验证一天就可以了,一天需要验12天。由于扩展到年和月只跟是否闰年有关系,就是说至少要验证一个平年和一个闰年,也就是最少得验证24次。   
         
我选择了   2005  年和   2008   年,验证每个月的1号。   
 
测试代码如下:   
   
 
  class   test   {   
          public  int   GetWeek(int   y,   int   m,   int   d)  {   
                 if(m<3)   {   
                         m   +=   12;   
                         --y;   
                 }   
                 int   w   =  (d+1+2*m+3*(m+1)/5+y+(y>>2)-y/100+y/400)   %   7;   
                 return   w;   
          }   
  }   
    
  public   class   Week   {  
          public  static   void   main(String[]   args){   
                 int   y   =   2005;   
                 int   m   =   1;   
                 int   d   =   1;   
                   
                 test   t   =   new   test();   
                 String   week[]   =   new   String[]{   
                         "星期日","星期一","星期二","星期三","星期四","星期五","星期六"   
                 };  
 
                   
                 for(y=2005;   y<=2008;   y+=3)   {   
                         for(m=1;   m<=12;   ++m)  {   
                                 String  str   =   y   +   "-"   +   m  +   "-"   +   d   +   "\t"  +   week[t.GetWeek(y,m,d)];   
                                System.out.println(str);   
                         }   
                 }   
          }   
  }   
  查万年历,检查程序的输出,完全正确。   
   
 
  七、后话   
   
 
          我们这个公式的推导是以031日为基础的,对该日以后的日期都是可以计算的。但是否可以扩展到公元前(1,2已属于公元前1年的13,14月了)呢?   
   
 
          虽然我对01月和2月、以及公元前1(y=-1)12月作了验证是正确的,但我在推导这个公式时并未想到将其扩展到公元前,所以上面的推导过程没有足够理论依据可以证明其适用于公元前。(负数的取模在不同的编译器如C++中好象处理并不完全正确)   
   
 
          另外一有点是对于0年是否存在的争议,一种折中的说法是0年存在,但什么也没有发生,其持续时间为0。还有在罗马的格利戈里历法中有10天是不存的(1582105日至14持续时间为0),英国的历法中有11(175293日至13)是不存在的。感兴趣的朋友可以看看这里:   
         http://www.whtv.com.cn/zhuanti/celebration/when/wz16.htm  
 
    
          但是我们做的是数字计算,不管那一天是否存在,持续的时间是24小时还是23小时甚至是0小时,只要那个号码存在,就有一个星期与之对应。所以这个公式仍然是适用的。   
         
如果要计算的是时间段,就必须考虑这个问题了。


关于时间,日期,星期,月份的算法(Java中Calendar的使用方法)

package cn.outofmemory.codes.Date;      import java.util.Calendar;   import java.util.Date;     ...

关于时间,日期,星期,月份的算法(Java中Calendar的使用方法)

package cn.outofmemory.codes.Date; import java.util.Calendar; import java.util.Date; public class ...

关于时间,日期,星期,月份的算法(Java中Calendar的使用方法)

package cn.outofmemory.codes.Date;      import java.util.Calendar;   import java.util.Date;     ...

关于时间,日期,星期,月份的算法(Java中Calendar的使用方法)(一)

package cn.outofmemory.codes.Date; import java.util.Calendar; import java.util.Date; pub...

(2.1.25)关于时间,日期,星期,月份的算法(Java中Calendar的使用方法)

[java] view plain copy package cn.outofmemory.codes.Date;      import java.util.Cal...

java根据日期计算年龄和星期

  • 2017年10月31日 15:34
  • 5KB
  • 下载

计算某一天是星期几的算法

如何计算某一天是星期几? —— 蔡勒(Zeller)公式  历史上的某一天是星期几?未来的某一天是星期几?关于这个问题,有很多计算公式(两个通用计算公式和一些分段计算公式),其中最著名的是蔡勒(Zel...

根据日期计算星期小算法

根据日期计算星期的公式有很多,下面介绍一个比较著名的——蔡勒(Zeller)公式,即w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1。 公式中的符号含义如下:C是世纪数减一,y是...

算法:计算某年的第一天是星期几

首先,利用你的公式编一简单程序: main()   { int year;/*年份*/     intw;   /*星期几*/     scanf("%d",&year);     w=((...

java常用类练习04(计算天数间隔和周数、输出21世纪的闰年、大小写字母转换、判断输出是否为闰年该月有几天星期几)

1.计算某年、某月、某日和某年、某月、某日之间的天数间隔和周数。 2.计算并输出21世纪的闰年,计算程序的执行时间 3.编写一个程序,设定一个有大小写字母的字符串,先将字符串的大写字符输出,再将字符...
  • fzhwk
  • fzhwk
  • 2017年10月25日 10:10
  • 113
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:用JAVA计算星期几的算法
举报原因:
原因补充:

(最多只允许输入30个字)