java时间轮

A. java时钟设计

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.Toolkit;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.image.BufferedImage;
import java.net.URL;
import java.text.DateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import javax.swing.JFrame;
import javax.swing.JLabel;

/**
* 时钟程序
*/
public class Clock extends JFrame
{
// 今天的日期对象
private GregorianCalendar now = new GregorianCalendar();
// 时钟标签，上面画的是圆形时钟
private ClockLabel clockLabel = new ClockLabel();
// 星期标签，指示星期
private JLabel weekLabel = new JLabel();
// 日期标签，指示日期
private JLabel dateLabel = new JLabel();
// 品牌标签
private JLabel remarkLabel = new JLabel();
// 时间标签，指示时间
private JLabel timeLabel = new JLabel();

public Clock()
{
// 设置主界面属性
setTitle("时钟");
setSize(500, 480);
setLocation(100, 100);
init();
setResizable(false);
}

private void init()
{

// 初始化品牌标签
remarkLabel.setText("MyClock");
remarkLabel.setLocation(225, 80);
remarkLabel.setSize(100, 30);
remarkLabel.setFont(new Font("Bookman Old Style", Font.BOLD, 15));
remarkLabel.setForeground(Color.darkGray);

// 初始化星期标签
weekLabel.setSize(60, 20);
weekLabel.setLocation(315, 190);
weekLabel.setForeground(Color.darkGray);
weekLabel.setFont(new Font("Arial Narrow", Font.BOLD, 12));
// 为星期标签赋值
int week = now.get(Calendar.DAY_OF_WEEK);
switch (week)
{
case 1:
weekLabel.setText("SUNDAY");
break;
case 2:
weekLabel.setText("MONDAY");
break;
case 3:
weekLabel.setText("TUESDAY");
break;
case 4:
weekLabel.setText("WEDNESDAY");
break;
case 5:
weekLabel.setText("THURSDAY");
break;
case 6:
weekLabel.setText("FRIDAY");
break;
case 7:
weekLabel.setText("SATURDAY");
break;
}

// 初始化日期标签
dateLabel.setSize(20, 20);
dateLabel.setLocation(370, 190);
dateLabel.setForeground(Color.darkGray);
dateLabel.setFont(new Font("Fixedsys", Font.BOLD, 12));
// 设置日期标签的值
dateLabel.setText("" + now.get(Calendar.DATE));

// 初始化时间标签
timeLabel.setSize(500, 30);
timeLabel.setLocation(100, 400);
timeLabel.setForeground(new Color(0, 64, 128));
timeLabel.setFont(new Font("Fixedsys", Font.PLAIN, 15));

// 将各组件加入到主窗口中
Container con = getContentPane();
con.setBackground(Color.white);
con.setLayout(null);
con.add(weekLabel);
con.add(dateLabel);
con.add(remarkLabel);
con.add(timeLabel);
con.add(clockLabel);
}

public static void main(String[] args)
{
Clock clock = new Clock();
clock.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
clock.setVisible(true);
}

// 自定义时钟标签，画一个圆形的时钟
class ClockLabel extends JLabel implements Runnable
{
// 时钟标签的宽度和高度
private final int WIDTH = 500;
private final int HEIGHT = 440;

// 圆形时钟的X半径和Y半径
private final int CIRCLE_X_RADIUS = 150;
private final int CIRCLE_Y_RADIUS = 155;

// 圆形时钟的原点
private final int CIRCLE_X = 250;
private final int CIRCLE_Y = 200;

// 圆形时钟指针的长度
private final int HOUR_LENGTH = 50;
private final int MIN_LENGTH = 80;
private final int SEC_LENGTH = 100;

// 当前时针所处的角度
double arcHour = 0;
// 当前分针所处的角度
double arcMin = 0;
// 当前秒针所处的角度
double arcSec = 0;

// 颜色的透明度，
// 当颜色的alpha值为1或者255时，表示不透明，其他值时透明
int alpha = 50;
// 标识颜色透明度变化的方向，
// 为true时表示越来越透明，为false时表示月来越不透明
boolean flag = false;
// 背景图片的id，轮换显示背景图片时使用
int imageID = 0;
// 背景图片对象数组
Image img[] = new Image[5];
// 背景图片URL
URL url[] = new URL[] { ClockLabel.class.getResource("image/1.jpg"), ClockLabel.class.getResource("image/2.jpg"), ClockLabel.class.getResource("image/3.jpg"), ClockLabel.class.getResource("image/4.jpg"), ClockLabel.class.getResource("image/5.jpg"), ClockLabel.class.getResource("image/6.jpg") };

// 一个具有缓冲区的图像对象
BufferedImage bufferedImage = null;
int imageSize = 2 * Math.max(CIRCLE_X_RADIUS, CIRCLE_Y_RADIUS);
// 为bufferedImage创建的Graphics对象，用于在bufferedImage上画图
Graphics bufferedImageGraphics = null;
// 时钟线程，因为时钟每秒钟都要动一次，所以用线程
Thread clockThread = null;

// 构造方法
public ClockLabel()
{

// 设置时钟标签的大小
this.setSize(WIDTH, HEIGHT);

// 获取时针、分针、秒针当前的角度
arcHour = now.get(Calendar.HOUR) * 30; // 一格30度
arcMin = now.get(Calendar.MINUTE) * 6; // 一格6度
arcSec = now.get(Calendar.SECOND) * 6; // 一个6度

// 根据图片URL创建图片对象
Toolkit tk = this.getToolkit();
img[0] = tk.createImage(url[0]);
img[1] = tk.createImage(url[1]);
img[2] = tk.createImage(url[2]);
img[3] = tk.createImage(url[3]);
img[4] = tk.createImage(url[4]);
try
{
// 使用MediaTracker加载图片对象
// MediaTracker 类是一个跟踪多种媒体对象状态的实用工具类,
// 媒体对象可以包括音频剪辑和图像，但目前仅支持图像.
MediaTracker mt = new MediaTracker(this);
mt.addImage(img[0], 0);
mt.addImage(img[1], 0);
mt.addImage(img[2], 0);
mt.addImage(img[3], 0);
mt.addImage(img[4], 0);
// 加载媒体跟踪器中所有的图像。
mt.waitForAll();
}
catch (Exception e)
{
e.printStackTrace();
}

// 创建一个有缓冲的Image对象
bufferedImage = new BufferedImage(imageSize, imageSize, BufferedImage.TYPE_INT_ARGB);
// 为BufferedImage创建Graphics2D对象，
// 以后用该Graphics2D对象画的图都会画在BufferedImage中
bufferedImageGraphics = bufferedImage.createGraphics();

// 启动线程
clockThread = new Thread(this);
clockThread.start();
}

public void paint(Graphics g1)
{
// Graphics2D继承Graphics，比Graphics提供更丰富的方法
Graphics2D g = (Graphics2D) g1;

/** ***画圆形时钟的刻度，每6度便有一个刻度**** */
for (int i = 0; i < 360; i = i + 6)
{
// 设置画笔的颜色为蓝色
g.setColor(Color.blue);
// 设置画笔的宽度为2
g.setStroke(new BasicStroke(2));

if (i % 90 == 0)
{
// 对于0，3，6，9点位置，使用一个大的蓝色刻度
g.setStroke(new BasicStroke(5));// 画笔宽度为5
// 当起点和终点一样时，画的就是点
g.drawLine(CIRCLE_X + (int) (Math.cos(i * Math.PI / 180) * CIRCLE_X_RADIUS), CIRCLE_Y + (int) (Math.sin(i * Math.PI / 180) * CIRCLE_Y_RADIUS), CIRCLE_X + (int) (Math.cos(i * Math.PI / 180) * CIRCLE_X_RADIUS), CIRCLE_Y + (int) (Math.sin(i * Math.PI / 180) * CIRCLE_Y_RADIUS));
}
else if (i % 30 == 0)
{
// 如果角度处于小时的位置，而且还不在0，3，6，9点时，画红色的小刻度
g.setColor(Color.red);
g.drawLine(CIRCLE_X + (int) (Math.cos(i * Math.PI / 180) * CIRCLE_X_RADIUS), CIRCLE_Y + (int) (Math.sin(i * Math.PI / 180) * CIRCLE_Y_RADIUS), CIRCLE_X + (int) (Math.cos(i * Math.PI / 180) * CIRCLE_X_RADIUS), CIRCLE_Y + (int) (Math.sin(i * Math.PI / 180) * CIRCLE_Y_RADIUS));
}
else
{
// 其他位置就画蓝色的小刻度
g.drawLine(CIRCLE_X + (int) (Math.cos(i * Math.PI / 180) * CIRCLE_X_RADIUS), CIRCLE_Y + (int) (Math.sin(i * Math.PI / 180) * CIRCLE_Y_RADIUS), CIRCLE_X + (int) (Math.cos(i * Math.PI / 180) * CIRCLE_X_RADIUS), CIRCLE_Y + (int) (Math.sin(i * Math.PI / 180) * CIRCLE_Y_RADIUS));
}
}

/** ****** 画时钟的指针 ******** */
// 画时针
Line2D.Double lh = new Line2D.Double(CIRCLE_X, CIRCLE_Y, CIRCLE_X + Math.cos((arcHour - 90) * Math.PI / 180) * HOUR_LENGTH, CIRCLE_Y + Math.sin((arcHour - 90) * Math.PI / 180) * HOUR_LENGTH);
// 设置画笔宽度和颜色
g.setStroke(new BasicStroke(6));
g.setColor(new Color(0, 128, 0));
// 利用Graphics2D的draw方法画线
g.draw(lh);

// 画分针
Line2D.Double lm = new Line2D.Double(CIRCLE_X, CIRCLE_Y, CIRCLE_X + Math.cos((arcMin - 90) * Math.PI / 180) * MIN_LENGTH, CIRCLE_Y + Math.sin((arcMin - 90) * Math.PI / 180) * MIN_LENGTH);
g.setStroke(new BasicStroke(3));
g.setColor(new Color(0, 128, 192));
g.draw(lm);

// 画秒针
Line2D.Double ls = new Line2D.Double(CIRCLE_X, CIRCLE_Y, CIRCLE_X + Math.cos((arcSec - 90) * Math.PI / 180) * SEC_LENGTH, CIRCLE_Y + Math.sin((arcSec - 90) * Math.PI / 180) * SEC_LENGTH);
g.setStroke(new BasicStroke(1));
// 秒针的颜色随机，使动画效果明显。
g.setColor(new Color((int) (Math.random() * 255), (int) (Math.random() * 255), (int) (Math.random() * 255)));
g.draw(ls);

/** **** 画时钟背景，并将其透明处理 ******* */
// 所有使用bufferedImageGraphics画的图像，都画在bufferedImage上，
// drawImage方法的参数含义分别是：背景图片对象、目标位置第一个角的X、Y坐标、目标位置第二个角的X、Y坐标、
// 源位置第一个角的X、Y坐标、源位置第二个角的X、Y坐标、图像对象改变时的通知接受者
bufferedImageGraphics.drawImage(img[imageID], 0, 0, imageSize, imageSize, 0, 0, imageSize + 10, imageSize + 10, this);
// 将背景图片透明化
for (int j = 0; j < imageSize; j++)
{
for (int i = 0; i < imageSize; i++)
{
// 获得背景图像中(i, j)坐标的颜色值
int pix = bufferedImage.getRGB(i, j);
Color c = new Color(pix);
int r = c.getRed();
int gr = c.getGreen();
int b = c.getBlue();
// 通过Color对象的alpha，使颜色透明。
int newpix = new Color(r, gr, b, alpha).getRGB();
// 重新设置背景图像该象素点的颜色
bufferedImage.setRGB(i, j, newpix);
}
}

/** 以上画背景操作都是画在bufferedImage上的，这里要将bufferedImage画在ClockLabel **/
// 将当前用户剪贴区 Clip 与椭圆区域相交，并将 Clip 设置为所得的交集
g.clip(new Ellipse2D.Double(95, 45, imageSize, imageSize));
g.setColor(Color.white);
// 在用户剪贴区画bufferedImage
g.drawImage(bufferedImage, 95, 45, this);
}

public void run()
{
try
{
//
while (clockThread != null)
{
// 获得完整的日期格式
DateFormat df = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
// 格式化当前时间
String s = df.format(new Date());
timeLabel.setText(s);
// 每动一次对时钟指针的角度进行调整
arcSec += 6;
arcMin += 0.1;
arcHour += 0.1 / 60;
// 当角度满一圈时，归0
if (arcSec >= 360)
{
arcSec = 0;
}
if (arcMin >= 360)
{
arcMin = 0;
}
if (arcHour >= 360)
{
arcHour = 0;
}
// 实现背景透明度渐变
// 从浅入深，再由深入浅。
if (flag)
{
alpha += 10;
if (alpha == 50)
{
flag = !flag;
}
}
else
{
alpha -= 10;
if (alpha == 0)
{
flag = !flag;
// 当透明度变化一个轮回时，换一张背景图
imageID++;
if (imageID == 4)
{
imageID = 0;
}
}
}
// 重画时钟标签
repaint();
// 等待1秒钟
Thread.sleep(1000);
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}

B. 线程的调度分为几种模型,在java中是使用哪种调度模型

Java程序属于抢占式调度，哪个线程的优先级高，哪个线程抢到的CPU时间片的概率就高；如果两个线程同一个优先级，则CPU随机选择一个执行。

C. java万年历

别人写的 借花献佛

万年历的 但是不实现农历

如何计算某一天是星期几?
slowtiger 发表于 2005-10-11 21:43:00
如何计算某一天是星期几?
—— 蔡勒（Zeller）公式
历史上的某一天是星期几？未来的某一天是星期几？关于这个问题，有很多计算公式（两个通用计算公式和一些分段计算公式），其中最着名的是蔡勒（Zeller）公式。
即w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1

公式中的符号含义如下，w：星期；c：世纪-1；y：年（两位数）；m：月（m大于等于3，小于等于14，即在蔡勒公式中，某年的1、2月要看作上一年的13、14月来计算，比如2003年1月1日要看作2002年的13月1日来计算）；d：日；[ ]代表取整，即只要整数部分。(C是世纪数减一，y是年份后两位，M是月份，d是日数。

1月和2月要按上一年的13月和 14月来算，这时C和y均按上一年取值。)

算出来的W除以7，余数是几就是星期几。如果余数是0，则为星期日。

以2049年10月1日（100周年国庆）为例，用蔡勒（Zeller）公式进行计算，过程如下：
蔡勒（Zeller）公式：w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1
=49+[49/4]+[20/4]-2×20+[26× (10+1)/10]+1-1
=49+[12.25]+5-40+[28.6]
=49+12+5-40+28
=54 (除以7余5)
即2049年10月1日（100周年国庆）是星期5。

你的生日（出生时、今年、明年）是星期几？不妨试一试。

不过，以上公式只适合于1582年10月15日之后的情形（当时的罗马教皇将恺撒大帝制订的儒略历修改成格里历，即今天使用的公历）。

过程的推导:(对推理不感兴趣的可略过不看)

星期制度是一种有古老传统的制度。据说因为《圣经·创世纪》中规定上帝用了六
天时间创世纪，第七天休息，所以人们也就以七天为一个周期来安排自己的工作和生
活，而星期日是休息日。从实际的角度来讲，以七天为一个周期，长短也比较合适。所
以尽管中国的传统工作周期是十天（比如王勃《滕王阁序》中说的“十旬休暇”，即是
指官员的工作每十日为一个周期，第十日休假），但后来也采取了西方的星期制度。

在日常生活中，我们常常遇到要知道某一天是星期几的问题。有时候，我们还想知
道历史上某一天是星期几。通常，解决这个方法的有效办法是看日历，但是我们总不会
随时随身带着日历，更不可能随时随身带着几千年的万年历。假如是想在计算机编程中
计算某一天是星期几，预先把一本万年历存进去就更不现实了。这时候是不是有办法通
过什么公式，从年月日推出这一天是星期几呢？

答案是肯定的。其实我们也常常在这样做。我们先举一个简单的例子。比如，知道
了2004年5月1日是星期六，那么2004年5月31日“世界无烟日”是星期几就不难推算出
来。我们可以掰着指头从1日数到31日，同时数星期，最后可以数出5月31日是星期一。
其实运用数学计算，可以不用掰指头。我们知道星期是七天一轮回的，所以5月1日是星
期六，七天之后的5月8日也是星期六。在日期上，8-1=7，正是7的倍数。同样，5月15
日、5月22日和5月29日也是星期六，它们的日期和5月1日的差值分别是14、21和28，也
都是7的倍数。那么5月31日呢？31-1=30，虽然不是7的倍数，但是31除以7，余数为2，
这就是说，5月31日的星期，是在5月1日的星期之后两天。星期六之后两天正是星期一。

这个简单的计算告诉我们计算星期的一个基本思路：首先，先要知道在想算的日子
之前的一个确定的日子是星期几，拿这一天做为推算的标准，也就是相当于一个计算的
“原点”。其次，知道想算的日子和这个确定的日子之间相差多少天，用7除这个日期
的差值，余数就表示想算的日子的星期在确定的日子的星期之后多少天。如果余数是
0，就表示这两天的星期相同。显然，如果把这个作为“原点”的日子选为星期日，那
么余数正好就等于星期几，这样计算就更方便了。

但是直接计算两天之间的天数，还是不免繁琐。比如1982年7月29日和2004年5月
1日之间相隔7947天，就不是一下子能算出来的。它包括三段时间：一，1982年7月29
日以后这一年的剩余天数；二，1983-2003这二十一个整年的全部天数；三，从2004年
元旦到5月1日经过的天数。第二段比较好算，它等于21*365+5=7670天，之所以要加
5，是因为这段时间内有5个闰年。第一段和第三段就比较麻烦了，比如第三段，需要把
5月之前的四个月的天数累加起来，再加上日期值，即31+29+31+30+1=122天。同理，第
一段需要把7月之后的五个月的天数累加起来，再加上7月剩下的天数，一共是155天。
所以总共的相隔天数是122+7670+155=7947天。

仔细想想，如果把“原点”日子的日期选为12月31日，那么第一段时间也就是一个
整年，这样一来，第一段时间和第二段时间就可以合并计算，整年的总数正好相当于两
个日子的年份差值减一。如果进一步把“原点”日子选为公元前1年12月31日（或者天文
学家所使用的公元0年12月31日），这个整年的总数就正好是想算的日子的年份减一。这
样简化之后，就只须计算两段时间：一，这么多整年的总天数；二，想算的日子是这一
年的第几天。巧的是，按照公历的年月设置，这样反推回去，公元前1年12月31日正好是
星期日，也就是说，这样算出来的总天数除以7的余数正好是星期几。那么现在的问题就
只有一个：这么多整年里面有多少闰年。这就需要了解公历的置闰规则了。

我们知道，公历的平年是365天，闰年是366天。置闰的方法是能被4整除的年份在
2月加一天，但能被100整除的不闰，能被400整除的又闰。因此，像1600、2000、2400
年都是闰年，而1700、1800、1900、2100年都是平年。公元前1年，按公历也是闰年。

因此，对于从公元前1年（或公元0年）12月31日到某一日子的年份Y之间的所有整年
中的闰年数，就等于

[(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400]，

[...]表示只取整数部分。第一项表示需要加上被4整除的年份数，第二项表示需要去掉
被100整除的年份数，第三项表示需要再加上被400整除的年份数。之所以Y要减一，这
样，我们就得到了第一个计算某一天是星期几的公式：

W = (Y-1)*365 + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] + D． (1)

其中D是这个日子在这一年中的累积天数。算出来的W就是公元前1年（或公元0年）12月
31日到这一天之间的间隔日数。把W用7除，余数是几，这一天就是星期几。比如我们来
算2004年5月1日：

W = (2004-1)*365 + [(2004-1)/4] - [(2004-1)/100] + [(2004-1)/400] +
(31+29+31+30+1)
= 731702，

731702 / 7 = 104528……6，余数为六，说明这一天是星期六。这和事实是符合的。

上面的公式(1)虽然很准确，但是计算出来的数字太大了，使用起来很不方便。仔
细想想，其实这个间隔天数W的用数仅仅是为了得到它除以7之后的余数。这启发我们是
不是可以简化这个W值，只要找一个和它余数相同的较小的数来代替，用数论上的术语
来说，就是找一个和它同余的较小的正整数，照样可以计算出准确的星期数。

显然，W这么大的原因是因为公式中的第一项(Y-1)*365太大了。其实，

(Y-1)*365 = (Y-1) * (364+1)
= (Y-1) * (7*52+1)
= 52 * (Y-1) * 7 + (Y-1)，

这个结果的第一项是一个7的倍数，除以7余数为0，因此(Y-1)*365除以7的余数其实就
等于Y-1除以7的余数。这个关系可以表示为：

(Y-1)*365 ≡ Y-1 (mod 7)．

其中，≡是数论中表示同余的符号，mod 7的意思是指在用7作模数（也就是除数）的情
况下≡号两边的数是同余的。因此，完全可以用(Y-1)代替(Y-1)*365，这样我们就得到
了那个着名的、也是最常见到的计算星期几的公式：

W = (Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] + D． (2)

这个公式虽然好用多了，但还不是最好用的公式，因为累积天数D的计算也比较麻
烦。是不是可以用月份数和日期直接计算呢？答案也是肯定的。我们不妨来观察一下各
个月的日数，列表如下：

月 份：1月 2月 3月 4月 5月 6月 7月 8月 9月 10月 11月 12月
--------------------------------------------------------------------------
天 数： 31 28(29) 31 30 31 30 31 31 30 31 30 31

如果把这个天数都减去28（=4*7），不影响W除以7的余数值。这样我们就得到另一张
表：

月 份：1月 2月 3月 4月 5月 6月 7月 8月 9月 10月 11月 12月
------------------------------------------------------------------------
剩余天数： 3 0(1) 3 2 3 2 3 3 2 3 2 3
平年累积： 3 3 6 8 11 13 16 19 21 24 26 29
闰年累积： 3 4 7 9 12 14 17 20 22 25 27 30

仔细观察的话，我们会发现除去1月和2月，3月到7月这五个月的剩余天数值是3,2,3,2,
3；8月到12月这五个月的天数值也是3,2,3,2,3，正好是一个重复。相应的累积天数中，
后一月的累积天数和前一月的累积天数之差减去28就是这个重复。正是因为这种规律的
存在，平年和闰年的累积天数可以用数学公式很方便地表达：

╭ d； （当M＝1）
D = { 31 + d； （当M＝2） (3)
╰ [ 13 * (M+1) / 5 ] - 7 + (M-1) * 28 + d + i． （当M≥3）

其中[...]仍表示只取整数部分；M和d分别是想算的日子的月份和日数；平年i=0，闰年
i=1。对于M≥3的表达式需要说明一下：[13*(M+1)/5]-7算出来的就是上面第二个表中的
平年累积值，再加上(M-1)*28就是想算的日子的月份之前的所有月份的总天数。这是一
个很巧妙的办法，利用取整运算来实现3,2,3,2,3的循环。比如，对2004年5月1日，有：

D = [ 13 * (5+1) / 5 ] - 7 + (5-1) * 28 + 1 + 1
= 122，

这正是5月1日在2004年的累积天数。

假如，我们再变通一下，把1月和2月当成是上一年的“13月”和“14月”，不仅仍
然符合这个公式，而且因为这样一来，闰日成了上一“年”（一共有14个月）的最后一
天，成了d的一部分，于是平闰年的影响也去掉了，公式就简化成：

D = [ 13 * (M+1) / 5 ] - 7 + (M-1) * 28 + d． （3≤M≤14） (4)

上面计算星期几的公式，也就可以进一步简化成：

W = (Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] + [ 13 * (M+1) / 5 ] - 7
+ (M-1) * 28 + d．

因为其中的-7和(M-1)*28两项都可以被7整除，所以去掉这两项，W除以7的余数不变，
公式变成：

W = (Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] + [ 13 * (M+1) / 5 ] + d．
(5)

当然，要注意1月和2月已经被当成了上一年的13月和14月，因此在计算1月和2月的日子
的星期时，除了M要按13或14算，年份Y也要减一。比如，2004年1月1日是星期四，用这
个公式来算，有：

W = (2003-1) + [(2003-1)/4] - [(2003-1)/100] + [(2003-1)/400] + [13*(13+1)/5]
+ 1
= 2002 + 500 - 20 + 5 + 36 + 1
= 2524；
2524 / 7 = 360……4．这和实际是一致的。

公式(5)已经是从年、月、日来算星期几的公式了，但它还不是最简练的，对于年
份的处理还有改进的方法。我们先来用这个公式算出每个世纪第一年3月1日的星期，列
表如下：

年份： 1(401,801,…,2001) 101(501,901,…,2101)
--------------------------------------------------------------------
星期： 4 2
====================================================================
年份：201(601,1001,…,2201) 301(701,1101,…,2301)
--------------------------------------------------------------------
星期： 0 5

可以看出，每隔四个世纪，这个星期就重复一次。假如我们把301(701,1101,…,2301)
年3月1日的星期数看成是-2（按数论中对余数的定义，-2和5除以7的余数相同，所以可
以做这样的变换），那么这个重复序列正好就是一个4,2,0,-2的等差数列。据此，我们
可以得到下面的计算每个世纪第一年3月1日的星期的公式：

W = (4 - C mod 4) * 2 - 4． (6)

式中，C是该世纪的世纪数减一，mod表示取模运算，即求余数。比如，对于2001年3月
1日，C=20，则：

W = (4 - 20 mod 4) * 2 - 4
= 8 - 4
= 4．

把公式(6)代入公式(5)，经过变换，可得：

(Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] ≡ (4 - C mod 4) * 2 - 1
(mod 7)． (7)

因此，公式(5)中的(Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400]这四项，在计算
每个世纪第一年的日期的星期时，可以用(4 - C mod 4) * 2 - 1来代替。这个公式写
出来就是：

W = (4 - C mod 4) * 2 - 1 + [13 * (M+1) / 5] + d． (8)

有了计算每个世纪第一年的日期星期的公式，计算这个世纪其他各年的日期星期的公式
就很容易得到了。因为在一个世纪里，末尾为00的年份是最后一年，因此就用不着再考
虑“一百年不闰，四百年又闰”的规则，只须考虑“四年一闰”的规则。仿照由公式(1)
简化为公式(2)的方法，我们很容易就可以从式(8)得到一个比公式(5)更简单的计算任意
一天是星期几的公式：

W = (4 - C mod 4) * 2 - 1 + (y-1) + [y/4] + [13 * (M+1) / 5] + d． (9)

式中，y是年份的后两位数字。

如果再考虑到取模运算不是四则运算，我们还可以把(4 - C mod 4) * 2进一步改写
成只含四则运算的表达式。因为世纪数减一C除以4的商数q和余数r之间有如下关系：

4q + r = C，

其中r即是 C mod 4，因此，有：

r = C - 4q
= C - 4 * [C/4]． (10)

则

(4 - C mod 4) * 2 ＝ (4 - C + 4 * [C/4]) * 2
＝ 8 - 2C + 8 * [C/4]
≡ [C/4] - 2C + 1 (mod 7)． (11)

把式(11)代入(9)，得到：

W = [C/4] - 2C + y + [y/4] + [13 * (M+1) / 5] + d - 1． (12)

这个公式由世纪数减一、年份末两位、月份和日数即可算出W，再除以7，得到的余数是
几就表示这一天是星期几，唯一需要变通的是要把1月和2月当成上一年的13月和14月，
C和y都按上一年的年份取值。因此，人们普遍认为这是计算任意一天是星期几的最好的
公式。这个公式最早是由德国数学家克里斯蒂安·蔡勒（Christian Zeller, 1822-
1899）在1886年推导出的，因此通称为蔡勒公式（Zeller’s Formula）。为方便口算，
式中的[13 * (M+1) / 5]也往往写成[26 * (M+1) / 10]。

现在仍然让我们来算2004年5月1日的星期，显然C=20，y=4，M=5，d=1，代入蔡勒
公式，有：

W = [20/4] - 40 + 4 + 1 + [13 * (5+1) / 5] + 1 - 1
= -15．

注意负数不能按习惯的余数的概念求余数，只能按数论中的余数的定义求余。为了方便
计算，我们可以给它加上一个7的整数倍，使它变为一个正数，比如加上70，得到55。
再除以7，余6，说明这一天是星期六。这和实际是一致的，也和公式(2)计算所得的结
果一致。

最后需要说明的是，上面的公式都是基于公历（格里高利历）的置闰规则来考虑
的。对于儒略历，蔡勒也推出了相应的公式是：

W = 5 - C + y + [y/4] + [13 * (M+1) / 5] + d - 1． (13)

========================================
(2005-10-20 22:25:00) --------(4575252)
计算任何一天是星期几的几种算法
近日在论坛上看到有人在问星期算法，特别整理了一下，这些算法都是从网上搜索而来，算法的实现是我在项目中写的。希望对大家有所帮助。
一：常用公式

W = [Y-1] + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] + D

Y是年份数，D是这一天在这一年中的累积天数，也就是这一天在这一年中是第几天。

二：蔡勒（Zeller）公式

w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1

公式中的符号含义如下，w：星期；c：世纪；y：年（两位数）； m：月（m大于等于3，小于等于14，即在蔡勒公式中，某年的1、2月要看作上一年的13、14月来计算，比如2003年1月1日要看作2002年的13月1日来计算）；d：日；[ ]代表取整，即只要整数部分。

相比于通用通用计算公式而言，蔡勒（Zeller）公式大大降低了计算的复杂度。

三：对蔡勒（Zeller）公式的改进

作者：冯思琮
相比于另外一个通用通用计算公式而言，蔡勒（Zeller）公式大大降低了计算的复杂度。不过，笔者给出的通用计算公式似乎更加简洁（包括运算过程）。现将公式列于其下：
W=[y/4]+r (y/7)-2r(c/4)+m’+d

公式中的符号含义如下，r ( )代表取余，即只要余数部分；m’是m的修正数，现给出1至12月的修正数1’至12’如下：（1’，10’）=6；（2’，3’，11’）=2；（4’，7’）=5；5’=0；6’=3；8’=1；（9’，12’）=4（注意：在笔者给出的公式中，y为润年时1’=5；2’=1）。其他符号与蔡勒（Zeller）公式中的含义相同。

四：基姆拉尔森计算公式

这个公式名称是我给命名的，哈哈希望大家不要见怪。

W= (d+2*m+3*(m+1)/5+y+y/4-y/100+y/400) mod 7

在公式中d表示日期中的日数，m表示月份数，y表示年数。

注意：在公式中有个与其他公式不同的地方：

把一月和二月看成是上一年的十三月和十四月，例：如果是2004-1-10则换算成：2003-13-10来代入公式计算。

D. 求解答java Time schele（）方法真能实现线程的精确延时触发吗

如果是要保证的准确性还是考虑一下spring的quartz（所谓的spring定时器org.springframework.scheling.quartz.*工具包）或真直接调用第三方式具类org.quartz。至少你说的那个jdk自带的java.util.* 工具包实现。这两个实现原理都应该是依赖jvm环境与系统时间，但是你所说的按时间片这个概念还真没接触过。本人对这个所谓有的中央控制器对时间咋控的还真不了妥。不过我们是做软件的，只要压力测试都能保证轮询时间与系统是一致的，还要考虑那么远么？

E. 关于java定时器Timer的疑问，当执行时间大于间隔时间会怎样

这个问题，我正好以前研究过
先回答你的问题：是等待第一次任务执行完
然后细说：

如果你用的是 java.util.Timer，那么这个Timer 有两种执行模式：
fixed-rate：对应于 scheleAtFixedRate 方法
fixed-delay：对应于 schele 方法

fixed-rate 模式，如果某次任务超时了，它会智能的缩短下一次任务的执行时间，
比如你 10 秒一次任务，但是任务执行了 15 秒，
那么下一次任务如果没有超时的话，可能也不会分配给他完整的 10 秒，而是 5 秒

目的是尽量让后面的任务可以赶上来
任务执行时间可能是这样一个模式：
第一次任务：15 秒（超时）
第二次任务：8 秒（未超时）
第三次任务：7 秒（未超时）
第四次任务：10 秒（未超时）
……

如果你任务一直都在超时，可能每次任务执行完之后，就会立刻执行下一次任务
其实如果你每次任务都超时，你应该考虑的是，
在程序中，就增加任务的延时

fixed-delay 模式，如果你某次任务超时了，也不会影响下一次任务的执行时间
10 秒周期的任务，执行了 15 秒
那下一次任务依然是分配完整的 10 秒
任务执行时间可能是这样一个模式：
第一次任务：15 秒（超时）
第二次任务：10 秒（未超时）
第三次任务：10 秒（未超时）
第四次任务：15 秒（超时）

如果你用的是 javax.swing.Timer，这个是按固定周期触发的
由于这个 Timer 是在 EDT （Java GUI 的事件指派线程）上执行的
EDT 有智能合并任务的处理

如果你某次任务超时了，那么下一次任务将和下下次任务智能合并成一个任务
比如 10 秒周期的任务，执行了 15 秒
任务执行时间可能是这样一个模式：
第一次任务：20 秒（超时）
第二次任务：合并
第三次任务：10 秒（未超时）
……

其实 javax.swing.Timer 也有 Fixed Rate 模式，
可以通过 setCoalesce(false); 方法开启
但是不建议这样使用

F. Java优势有哪些

JAVA的优势是什么？

Java语言是目前的排行第一的语言，其优势也是非常突出的，那么具体体现在哪里呐？

我来给你说一下Java的优势：

1.java的风格类似C++但不同于C++,从某种意义上讲，java是C++的一个变种；

2.java摒弃了C、C++中的容易引发错误和难以理解的指针，结构，以及内存管理等；

3.java提供了丰富的类库，很方便开发程序；

4.java是完全面向对象的语言，支持 继承，重载，多态等面向对象的特性；

5.C++是面向对象和面向过程的混合语言， C是纯面向过程的语言；

6.java是一种强类型的语言，比C/C++检查还要严格，java区分大小写字母；

7.java提供了自动垃圾回收机制gc，有效避免了C、C++的内存泄漏问题；

8.java禁止非法访问内存，因为java没有指针，内存的申请和释放；

9.跨平台，java的源代码编译成结构中立的中间格式，这种格式与机器无关，只要在安装有JVM（java虚拟机）的电脑上，都能运行这种与机器无关的中间文件；java一次编译，到处运行；

10.对于不同的操作系统，会有不同的java虚拟机，这也就决定了java的可移植性；

11.java支持多线程，简单理解，如果是单核CPU，那么会通过时间片轮转的方式，多线程执行程序，如果是多核CPU，那么就可以理解为，两个或多个线程同时运行。

一、做网站

Java可以用来做网站，很多大型网站都是用Java写的，比如我们熟悉的B站，所以想学习Java的同学还可以负责网站方面的制作，这方面的岗位（网站开发）也比较多，一直以来都相当流行。

二、做安卓软件

安卓是基于Linux的操作系统，其中源代码就是Java，市面上所有的安卓手机都是修改Java运行的，对于更多的开发人员来说，他们更多的时间是花在开发APP上面。你随便打开一个App应用，他们就是用Java语言做的。

三、做游戏

电脑上的大多数游戏也是用Java来开发的，最经典的就是《我的世界》，还有当今世界最具影响力的游戏英雄联盟，吃鸡也是用Java写的

四、写软件

很多编程语言都是可以来写软件的，但Java是现在应用最广泛的，比如：企业级应用开发，还有OA、邮箱、物流、医疗、投票、金融、考试、矿山等信息方面的系统，Java都占有极为重要的地位。现在国内的最热门的就是手机应用，学习Java去做手机应用还是比较吃香的。

说啦这么多那么应该如何学习Java那？

在这个里我使用脑图给大家出一个，Java的学习线路供大家参考：

Java在市场中的占有率是非常之高的，希望大都成为优秀的程序员！！！

G. java怎么写有一个功能,就是它会设置一个时间段,然后到了这个结束时间的时候会修改它的状态

创建个线程监听时间，到时间就修改状态。

H. JAVA 多个线程运行时间问题

我理解，准确的说你这个都不是多线程执行，即使是多线程执行，也有一定的时间差，cpu还要轮片。

符合你要求的写法，你可以试试，实现了Runnable下面的run();在run里休眠

@Override
publicvoidrun(){
try{
Thread.sleep(5000);
System.out.println("done");
}catch(InterruptedExceptione){
e.printStackTrace();
}
}

而你后面的m1.mySleep()和m2.mySleep()相当于在main的主线程中阻塞执行，目测需要10秒多才能看到两个done!!