中国农历算法java实现

/**
　 *　中国农历算法　-　实用于公历　1901　年至　2100　年之间的　200　年
　 */
import　java.text.*;
import　java.util.*;
class　ChineseCalendarGB　{
　　　 private　int　gregorianYear;
　　　 private　int　gregorianMonth;
　　　 private　int　gregorianDate;
　　　 private　boolean　isGregorianLeap;
　　　 private　int　dayOfYear;
　　　 private　int　dayOfWeek;　//　周日一星期的第一天
　　　 private　int　chineseYear;
　　　 private　int　chineseMonth;　//　负数表示闰月
　　　 private　int　chineseDate;
　　　 private　int　sectionalTerm;
　　　 private　int　principleTerm;
　　　 private　static　char[]　daysInGregorianMonth　=
　　　　　　 {31,28,31,30,31,30,31,31,30,31,30,31};
　　　 private　static　String[]　stemNames　=
　　　　　　 {"甲","乙","丙","丁","戊","己","庚","辛","壬","癸"};
　　　 private　static　String[]　branchNames　=
　　　　　　 {"子","丑","寅","卯","辰","巳","午","未","申","酉","戌","亥"};
　　　 private　static　String[]　animalNames　=
　　　　　　 {"鼠","牛","虎","兔","龙","蛇","马","羊","猴","鸡","狗","猪"};
　　　 public　static　void　main(String[]　arg)　{
　　　　　　 ChineseCalendarGB　c　=　new　ChineseCalendarGB();
　　　　　　 String　cmd　=　"day";
　　　　　　 int　y　=　1901;
　　　　　　 int　m　=　1;
　　　　　　 int　d　=　1;
　　　　　　 if　(arg.length>0)　cmd　=　arg[0];
　　　　　　 if　(arg.length>1)　y　=　Integer.parseInt(arg[1]);
　　　　　　 if　(arg.length>2)　m　=　Integer.parseInt(arg[2]);
　　　　　　 if　(arg.length>3)　d　=　Integer.parseInt(arg[3]);
　　　　　　 c.setGregorian(y,m,d);
　　　　　　 c.computeChineseFields();
　　　　　　 c.computeSolarTerms();
　　　　　　 if　(cmd.equalsIgnoreCase("year"))　{
　　　　　　　　　 String[]　t　=　c.getYearTable();
　　　　　　　　　 for　(int　i=0;　i<t.length;　i++)　System.out.println(t[i]);
　　　　　　 }　else　if　(cmd.equalsIgnoreCase("month"))　{
　　　　　　　　　 String[]　t　=　c.getMonthTable();
　　　　　　　　　 for　(int　i=0;　i<t.length;　i++)　System.out.println(t[i]);
　　　　　　 }　else　{
　　　　　　　　　 System.out.println(c.toString());
　　　　　　 }
　　　 }
　　　 public　ChineseCalendarGB()　{
　　　　　　 setGregorian(1901,1,1);
　　　 }
　　　 public　void　setGregorian(int　y,　int　m,　int　d)　{
　　　　　　 gregorianYear　=　y;
　　　　　　 gregorianMonth　=　m;
　　　　　　 gregorianDate　=　d;
　　　　　　 isGregorianLeap　=　isGregorianLeapYear(y);
　　　　　　 dayOfYear　=　dayOfYear(y,m,d);
　　　　　　 dayOfWeek　=　dayOfWeek(y,m,d);
　　　　　　 chineseYear　=　0;
　　　　　　 chineseMonth　=　0;
　　　　　　 chineseDate　=　0;
　　　　　　 sectionalTerm　=　0;
　　　　　　 principleTerm　=　0;
　　　 }
　　　 public　static　boolean　isGregorianLeapYear(int　year)　{
　　　　　　 boolean　isLeap　=　false;
　　　　　　 if　(year%4==0)　isLeap　=　true;
　　　　　　 if　(year%100==0)　isLeap　=　false;
　　　　　　 if　(year%400==0)　isLeap　=　true;
　　　　　　 return　isLeap;
　　　 }
　　　 public　static　int　daysInGregorianMonth(int　y,　int　m)　{
　　　　　　 int　d　=　daysInGregorianMonth[m-1];
　　　　　　 if　(m==2　&&　isGregorianLeapYear(y))　d++;　//　公历闰年二月多一天
　　　　　　 return　d;
　　　 }
　　　 public　static　int　dayOfYear(int　y,　int　m,　int　d)　{
　　　　　　 int　c　=　0;
　　　　　　 for　(int　i=1;　i<m;　i++)　{
　　　　　　　　　 c　=　c　+　daysInGregorianMonth(y,i);
　　　　　　 }
　　　　　　 c　=　c　+　d;
　　　　　　 return　c;
　　　 }
　　　 public　static　int　dayOfWeek(int　y,　int　m,　int　d)　{
　　　　　　 int　w　=　1;　//　公历一年一月一日是星期一，所以起始值为星期日
　　　　　　 y　=　(y-1)%400　+　1;　//　公历星期值分部　400　年循环一次
　　　　　　 int　ly　=　(y-1)/4;　//　闰年次数
　　　　　　 ly　=　ly　-　(y-1)/100;
　　　　　　 ly　=　ly　+　(y-1)/400;
　　　　　　 int　ry　=　y　-　1　-　ly;　//　常年次数
　　　　　　 w　=　w　+　ry;　//　常年星期值增一
　　　　　　 w　=　w　+　2*ly;　//　闰年星期值增二
　　　　　　 w　=　w　+　dayOfYear(y,m,d);
　　　　　　 w　=　(w-1)%7　+　1;
　　　　　　 return　w;
　　　 }
　　　 private　static　char[]　chineseMonths　=　{
　　　 //　农历月份大小压缩表，两个字节表示一年。两个字节共十六个二进制位数，
　　　 //　前四个位数表示闰月月份，后十二个位数表示十二个农历月份的大小。
　　　 0x00,0x04,0xad,0x08,0x5a,0x01,0xd5,0x54,0xb4,0x09,0x64,0x05,0x59,0x45,
　　　 0x95,0x0a,0xa6,0x04,0x55,0x24,0xad,0x08,0x5a,0x62,0xda,0x04,0xb4,0x05,
　　　 0xb4,0x55,0x52,0x0d,0x94,0x0a,0x4a,0x2a,0x56,0x02,0x6d,0x71,0x6d,0x01,
　　　 0xda,0x02,0xd2,0x52,0xa9,0x05,0x49,0x0d,0x2a,0x45,0x2b,0x09,0x56,0x01,
　　　 0xb5,0x20,0x6d,0x01,0x59,0x69,0xd4,0x0a,0xa8,0x05,0xa9,0x56,0xa5,0x04,
　　　 0x2b,0x09,0x9e,0x38,0xb6,0x08,0xec,0x74,0x6c,0x05,0xd4,0x0a,0xe4,0x6a,
　　　 0x52,0x05,0x95,0x0a,0x5a,0x42,0x5b,0x04,0xb6,0x04,0xb4,0x22,0x6a,0x05,
　　　 0x52,0x75,0xc9,0x0a,0x52,0x05,0x35,0x55,0x4d,0x0a,0x5a,0x02,0x5d,0x31,
　　　 0xb5,0x02,0x6a,0x8a,0x68,0x05,0xa9,0x0a,0x8a,0x6a,0x2a,0x05,0x2d,0x09,
　　　 0xaa,0x48,0x5a,0x01,0xb5,0x09,0xb0,0x39,0x64,0x05,0x25,0x75,0x95,0x0a,
　　　 0x96,0x04,0x4d,0x54,0xad,0x04,0xda,0x04,0xd4,0x44,0xb4,0x05,0x54,0x85,
　　　 0x52,0x0d,0x92,0x0a,0x56,0x6a,0x56,0x02,0x6d,0x02,0x6a,0x41,0xda,0x02,
　　　 0xb2,0xa1,0xa9,0x05,0x49,0x0d,0x0a,0x6d,0x2a,0x09,0x56,0x01,0xad,0x50,
　　　 0x6d,0x01,0xd9,0x02,0xd1,0x3a,0xa8,0x05,0x29,0x85,0xa5,0x0c,0x2a,0x09,
　　　 0x96,0x54,0xb6,0x08,0x6c,0x09,0x64,0x45,0xd4,0x0a,0xa4,0x05,0x51,0x25,
　　　 0x95,0x0a,0x2a,0x72,0x5b,0x04,0xb6,0x04,0xac,0x52,0x6a,0x05,0xd2,0x0a,
　　　 0xa2,0x4a,0x4a,0x05,0x55,0x94,0x2d,0x0a,0x5a,0x02,0x75,0x61,0xb5,0x02,
　　　 0x6a,0x03,0x61,0x45,0xa9,0x0a,0x4a,0x05,0x25,0x25,0x2d,0x09,0x9a,0x68,
　　　 0xda,0x08,0xb4,0x09,0xa8,0x59,0x54,0x03,0xa5,0x0a,0x91,0x3a,0x96,0x04,
　　　 0xad,0xb0,0xad,0x04,0xda,0x04,0xf4,0x62,0xb4,0x05,0x54,0x0b,0x44,0x5d,
　　　 0x52,0x0a,0x95,0x04,0x55,0x22,0x6d,0x02,0x5a,0x71,0xda,0x02,0xaa,0x05,
　　　 0xb2,0x55,0x49,0x0b,0x4a,0x0a,0x2d,0x39,0x36,0x01,0x6d,0x80,0x6d,0x01,
　　　 0xd9,0x02,0xe9,0x6a,0xa8,0x05,0x29,0x0b,0x9a,0x4c,0xaa,0x08,0xb6,0x08,
　　　 0xb4,0x38,0x6c,0x09,0x54,0x75,0xd4,0x0a,0xa4,0x05,0x45,0x55,0x95,0x0a,
　　　 0x9a,0x04,0x55,0x44,0xb5,0x04,0x6a,0x82,0x6a,0x05,0xd2,0x0a,0x92,0x6a,
　　　 0x4a,0x05,0x55,0x0a,0x2a,0x4a,0x5a,0x02,0xb5,0x02,0xb2,0x31,0x69,0x03,
　　　 0x31,0x73,0xa9,0x0a,0x4a,0x05,0x2d,0x55,0x2d,0x09,0x5a,0x01,0xd5,0x48,
　　　 0xb4,0x09,0x68,0x89,0x54,0x0b,0xa4,0x0a,0xa5,0x6a,0x95,0x04,0xad,0x08,
　　　 0x6a,0x44,0xda,0x04,0x74,0x05,0xb0,0x25,0x54,0x03
　　　 };
　　　 //　初始日，公历农历对应日期：
　　　 //　公历　1901　年　1　月　1　日，对应农历　4598　年　11　月　11　日
　　　 private　static　int　baseYear　=　1901;
　　　 private　static　int　baseMonth　=　1;
　　　 private　static　int　baseDate　=　1;
　　　 private　static　int　baseIndex　=　0;
　　　 private　static　int　baseChineseYear　=　4598-1;
　　　 private　static　int　baseChineseMonth　=　11;
　　　 private　static　int　baseChineseDate　=　11;
　　　 public　int　computeChineseFields()　{
　　　　　　 if　(gregorianYear<1901　||　gregorianYear>2100)　return　1;
　　　　　　 int　startYear　=　baseYear;
　　　　　　 int　startMonth　=　baseMonth;
　　　　　　 int　startDate　=　baseDate;
　　　　　　 chineseYear　=　baseChineseYear;
　　　　　　 chineseMonth　=　baseChineseMonth;
　　　　　　 chineseDate　=　baseChineseDate;
　　　　　　 //　第二个对应日，用以提高计算效率
　　　　　　 //　公历　2000　年　1　月　1　日，对应农历　4697　年　11　月　25　日
　　　　　　 if　(gregorianYear　>=　2000)　{
　　　　　　　　　 startYear　=　baseYear　+　99;
　　　　　　　　　 startMonth　=　1;
　　　　　　　　　 startDate　=　1;
　　　　　　　　　 chineseYear　=　baseChineseYear　+　99;
　　　　　　　　　 chineseMonth　=　11;
　　　　　　　　　 chineseDate　=　25;
　　　　　　 }
　　　　　　 int　daysDiff　=　0;
　　　　　　 for　(int　i=startYear;　i<gregorianYear;　i++)　{
　　　　　　　　　 daysDiff　+=　365;
　　　　　　　　　 if　(isGregorianLeapYear(i))　daysDiff　+=　1;　//　leap　year
　　　　　　 }
　　　　　　 for　(int　i=startMonth;　i<gregorianMonth;　i++)　{
　　　　　　　　　 daysDiff　+=　daysInGregorianMonth(gregorianYear,i);
　　　　　　 }
　　　　　　 daysDiff　+=　gregorianDate　-　startDate;

　　　　　　 chineseDate　+=　daysDiff;
　　　　　　 int　lastDate　=　daysInChineseMonth(chineseYear,　chineseMonth);
　　　　　　 int　nextMonth　=　nextChineseMonth(chineseYear,　chineseMonth);
　　　　　　 while　(chineseDate>lastDate)　{
　　　　　　　　　 if　(Math.abs(nextMonth)<Math.abs(chineseMonth))　chineseYear++;
　　　　　　　　　 chineseMonth　=　nextMonth;
　　　　　　　　　 chineseDate　-=　lastDate;
　　　　　　　　　 lastDate　=　daysInChineseMonth(chineseYear,　chineseMonth);
　　　　　　　　　 nextMonth　=　nextChineseMonth(chineseYear,　chineseMonth);
　　　　　　 }
　　　　　　 return　0;
　　　 }
　　　 private　static　int[]　bigLeapMonthYears　=　{
　　　　　　 //　大闰月的闰年年份
　　　　　　　　 6,　14,　19,　25,　33,　36,　38,　41,　44,　52,
　　　　　　　 55,　79,117,136,147,150,155,158,185,193
　　　　　　 };
　　　 public　static　int　daysInChineseMonth(int　y,　int　m)　{
　　　　　　 //　注意：闰月　m　<　0
　　　　　　 int　index　=　y　-　baseChineseYear　+　baseIndex;
　　　　　　 int　v　=　0;
　　　　　　 int　l　=　0;
　　　　　　 int　d　=　30;
　　　　　　 if　(1<=m　&&　m<=8)　{
　　　　　　　　　 v　=　chineseMonths[2*index];
　　　　　　　　　 l　=　m　-　1;
　　　　　　　　　 if　(　((v>>l)&0x01)==1　)　d　=　29;
　　　　　　 }　else　if　(9<=m　&&　m<=12)　{
　　　　　　　　　 v　=　chineseMonths[2*index+1];
　　　　　　　　　 l　=　m　-　9;
　　　　　　　　　 if　(　((v>>l)&0x01)==1　)　d　=　29;
　　　　　　 }　else　{
　　　　　　　　　 v　=　chineseMonths[2*index+1];
　　　　　　　　　 v　=　(v>>4)&0x0F;
　　　　　　　　　 if　(v!=Math.abs(m))　{
　　　　　　　　　　　　 d　=　0;
　　　　　　　　　 }　else　{
　　　　　　　　　　　　 d　=　29;
　　　　　　　　　　　　 for　(int　i=0;　i<bigLeapMonthYears.length;　i++)　{
　　　　　　　　　　　　　　　 if　(bigLeapMonthYears[i]==index)　{
　　　　　　　　　　　　　　　　　　 d　=　30;
　　　　　　　　　　　　　　　　　　 break;
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　 }
　　　　　　　　　 }
　　　　　　 }
　　　　　　 return　d;
　　　 }
　　　 public　static　int　nextChineseMonth(int　y,　int　m)　{
　　　　　　 int　n　=　Math.abs(m)　+　1;
　　　　　　 if　(m>0)　{
　　　　　　　　　 int　index　=　y　-　baseChineseYear　+　baseIndex;
　　　　　　　　　 int　v　=　chineseMonths[2*index+1];
　　　　　　　　　 v　=　(v>>4)&0x0F;
　　　　　　　　　 if　(v==m)　n　=　-m;
　　　　　　 }
　　　　　　 if　(n==13)　n　=　1;
　　　　　　 return　n;
　　　 }
　　　 private　static　char[][]　sectionalTermMap　=　{
　　　 {7,6,6,6,6,6,6,6,6,5,6,6,6,5,5,6,6,5,5,5,5,5,5,5,5,4,5,5},　
　　　 {5,4,5,5,5,4,4,5,5,4,4,4,4,4,4,4,4,3,4,4,4,3,3,4,4,3,3,3},　
　　　 {6,6,6,7,6,6,6,6,5,6,6,6,5,5,6,6,5,5,5,6,5,5,5,5,4,5,5,5,5},
　　　 {5,5,6,6,5,5,5,6,5,5,5,5,4,5,5,5,4,4,5,5,4,4,4,5,4,4,4,4,5},
　　　 {6,6,6,7,6,6,6,6,5,6,6,6,5,5,6,6,5,5,5,6,5,5,5,5,4,5,5,5,5},
　　　 {6,6,7,7,6,6,6,7,6,6,6,6,5,6,6,6,5,5,6,6,5,5,5,6,5,5,5,5,4,5,5,5,5},
　　　 {7,8,8,8,7,7,8,8,7,7,7,8,7,7,7,7,6,7,7,7,6,6,7,7,6,6,6,7,7},
　　　 {8,8,8,9,8,8,8,8,7,8,8,8,7,7,8,8,7,7,7,8,7,7,7,7,6,7,7,7,6,6,7,7,7},
　　　 {8,8,8,9,8,8,8,8,7,8,8,8,7,7,8,8,7,7,7,8,7,7,7,7,6,7,7,7,7},
　　　 {9,9,9,9,8,9,9,9,8,8,9,9,8,8,8,9,8,8,8,8,7,8,8,8,7,7,8,8,8},
　　　 {8,8,8,8,7,8,8,8,7,7,8,8,7,7,7,8,7,7,7,7,6,7,7,7,6,6,7,7,7},
　　　 {7,8,8,8,7,7,8,8,7,7,7,8,7,7,7,7,6,7,7,7,6,6,7,7,6,6,6,7,7}
　　　 };
　　　 private　static　char[][]　sectionalTermYear　=　{
　　　 {13,49,85,117,149,185,201,250,250},
　　　 {13,45,81,117,149,185,201,250,250},
　　　 {13,48,84,112,148,184,200,201,250},
　　　 {13,45,76,108,140,172,200,201,250},
　　　 {13,44,72,104,132,168,200,201,250},
　　　 {5　,33,68,96　,124,152,188,200,201},
　　　 {29,57,85,120,148,176,200,201,250},
　　　 {13,48,76,104,132,168,196,200,201},
　　　 {25,60,88,120,148,184,200,201,250},
　　　 {16,44,76,108,144,172,200,201,250},
　　　 {28,60,92,124,160,192,200,201,250},
　　　 {17,53,85,124,156,188,200,201,250}
　　　 };
　　　 private　static　char[][]　principleTermMap　=　{
　　　 {21,21,21,21,21,20,21,21,21,20,20,21,21,20,20,20,20,20,20,20,20,19,
　　　　　　 20,20,20,19,19,20},
　　　 {20,19,19,20,20,19,19,19,19,19,19,19,19,18,19,19,19,18,18,19,19,18,
　　　　　　 18,18,18,18,18,18},
　　　 {21,21,21,22,21,21,21,21,20,21,21,21,20,20,21,21,20,20,20,21,20,20,
　　　　　　 20,20,19,20,20,20,20},
　　　 {20,21,21,21,20,20,21,21,20,20,20,21,20,20,20,20,19,20,20,20,19,19,
　　　　　　 20,20,19,19,19,20,20},
　　　 {21,22,22,22,21,21,22,22,21,21,21,22,21,21,21,21,20,21,21,21,20,20,
　　　　　　 21,21,20,20,20,21,21},
　　　 {22,22,22,22,21,22,22,22,21,21,22,22,21,21,21,22,21,21,21,21,20,21,
　　　　　　 21,21,20,20,21,21,21},
　　　 {23,23,24,24,23,23,23,24,23,23,23,23,22,23,23,23,22,22,23,23,22,22,
　　　　　　 22,23,22,22,22,22,23},
　　　 {23,24,24,24,23,23,24,24,23,23,23,24,23,23,23,23,22,23,23,23,22,22,
　　　　　　 23,23,22,22,22,23,23},
　　　 {23,24,24,24,23,23,24,24,23,23,23,24,23,23,23,23,22,23,23,23,22,22,
　　　　　　 23,23,22,22,22,23,23},
　　　 {24,24,24,24,23,24,24,24,23,23,24,24,23,23,23,24,23,23,23,23,22,23,
　　　　　　 23,23,22,22,23,23,23},
　　　 {23,23,23,23,22,23,23,23,22,22,23,23,22,22,22,23,22,22,22,22,21,22,
　　　　　　 22,22,21,21,22,22,22},
　　　 {22,22,23,23,22,22,22,23,22,22,22,22,21,22,22,22,21,21,22,22,21,21,
　　　　　　 21,22,21,21,21,21,22}
　　　 };
　　　 private　static　char[][]　principleTermYear　=　{
　　　 {13,45,81,113,149,185,201},　　　
　　　 {21,57,93,125,161,193,201},　　　
　　　 {21,56,88,120,152,188,200,201},
　　　 {21,49,81,116,144,176,200,201},
　　　 {17,49,77,112,140,168,200,201},
　　　 {28,60,88,116,148,180,200,201},
　　　 {25,53,84,112,144,172,200,201},
　　　 {29,57,89,120,148,180,200,201},
　　　 {17,45,73,108,140,168,200,201},
　　　 {28,60,92,124,160,192,200,201},
　　　 {16,44,80,112,148,180,200,201},
　　　 {17,53,88,120,156,188,200,201}
　　　 };
　　　 public　int　computeSolarTerms()　{
　　　　　　 if　(gregorianYear<1901　||　gregorianYear>2100)　return　1;
　　　　　　 sectionalTerm　=　sectionalTerm(gregorianYear,　gregorianMonth);
　　　　　　 principleTerm　=　principleTerm(gregorianYear,　gregorianMonth);
　　　　　　 return　0;
　　　 }
　　　 public　static　int　sectionalTerm(int　y,　int　m)　{
　　　　　　 if　(y<1901　||　y>2100)　return　0;
　　　　　　 int　index　=　0;
　　　　　　 int　ry　=　y-baseYear+1;
　　　　　　 while　(ry>=sectionalTermYear[m-1][index])　index++;
　　　　　　 int　term　=　sectionalTermMap[m-1][4*index+ry%4];
　　　　　　 if　((ry　==　121)&&(m　==　4))　term　=　5;
　　　　　　 if　((ry　==　132)&&(m　==　4))　term　=　5;
　　　　　　 if　((ry　==　194)&&(m　==　6))　term　=　6;
　　　　　　 return　term;
　　　 }
　　　 public　static　int　principleTerm(int　y,　int　m)　{
　　　　　　 if　(y<1901　||　y>2100)　return　0;
　　　　　　 int　index　=　0;
　　　　　　 int　ry　=　y-baseYear+1;
　　　　　　 while　(ry>=principleTermYear[m-1][index])　index++;
　　　　　　 int　term　=　principleTermMap[m-1][4*index+ry%4];
　　　　　　 if　((ry　==　171)&&(m　==　3))　term　=　21;
　　　　　　 if　((ry　==　181)&&(m　==　5))　term　=　21;
　　　　　　 return　term;
　　　 }
　　　 public　String　toString()　{
　　　　　　 StringBuffer　buf　=　new　StringBuffer();
　　　　　　 buf.append("Gregorian　Year:　"+gregorianYear+""n");
　　　　　　 buf.append("Gregorian　Month:　"+gregorianMonth+""n");
　　　　　　 buf.append("Gregorian　Date:　"+gregorianDate+""n");
　　　　　　 buf.append("Is　Leap　Year:　"+isGregorianLeap+""n");
　　　　　　 buf.append("Day　of　Year:　"+dayOfYear+""n");
　　　　　　 buf.append("Day　of　Week:　"+dayOfWeek+""n");
　　　　　　 buf.append("Chinese　Year:　"+chineseYear+""n");
　　　　　　 buf.append("Heavenly　Stem:　"+((chineseYear-1)%10)+""n");
　　　　　　 buf.append("Earthly　Branch:　"+((chineseYear-1)%12)+""n");
　　　　　　 buf.append("Chinese　Month:　"+chineseMonth+""n");
　　　　　　 buf.append("Chinese　Date:　"+chineseDate+""n");
　　　　　　 buf.append("Sectional　Term:　"+sectionalTerm+""n");
　　　　　　 buf.append("Principle　Term:　"+principleTerm+""n");
　　　　　　 return　buf.toString();
　　　 }
　　　 public　String[]　getYearTable()　{
　　　　　　 setGregorian(gregorianYear,1,1);
　　　　　　 computeChineseFields();
　　　　　　 computeSolarTerms();
　　　　　　 String[]　table　=　new　String[58];　//　6*9　+　4
　　　　　　 table[0]　=　getTextLine(27,　"公历年历："+gregorianYear);
　　　　　　 table[1]　=　getTextLine(27,　"农历年历："+(chineseYear+1)
　　　　　　　　　 +　"　("+stemNames[(chineseYear+1-1)%10]
　　　　　　　　　 +　branchNames[(chineseYear+1-1)%12]
　　　　　　　　　 +　"　-　"+animalNames[(chineseYear+1-1)%12]+"年)");
　　　　　　 int　ln　=　2;
　　　　　　 String　blank　　=　"　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　"
　　　　　　　　　　　　　　 +"　　"　+　"　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　";
　　　　　　 String[]　mLeft　=　null;
　　　　　　 String[]　mRight　=　null;
　　　　　　 for　(int　i=1;　i<=6;　i++)　{
　　　　　　　　　 table[ln]　=　blank;
　　　　　　　　　 ln++;
　　　　　　　　　 mLeft　=　getMonthTable();
　　　　　　　　　 mRight　=　getMonthTable();
　　　　　　　　　 for　(int　j=0;　j<mLeft.length;　j++)　{
　　　　　　　　　　　　 String　line　=　mLeft[j]　+　"　　"　+　mRight[j];
　　　　　　　　　　　　 table[ln]　=　line;
　　　　　　　　　　　　 ln++;
　　　　　　　　　 }
　　　　　　 }
　　　　　　 table[ln]　=　blank;
　　　　　　 ln++;
　　　　　　 table[ln]　=　getTextLine(0,
　　　　　　　　　 "##/##　-　公历日期/农历日期，(*)#月　-　(闰)农历月第一天");
　　　　　　 ln++;
　　　　　　 return　table;
　　　 }
　　　 public　static　String　getTextLine(int　s,　String　t)　{
　　　　　　 String　str　　=　"　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　"
　　　　　　　　　　　　　　 +"　　"　+　"　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　";
　　　　　　 if　(t!=null　&&　s<str.length()　&&　s+t.length()<str.length())
　　　　　　　　　 str　=　str.substring(0,s)　+　t　+　str.substring(s+t.length());
　　　　　　 return　str;
　　　 }
　　　 private　static　String[]　monthNames　=
　　　　　　 {"一","二","三","四","五","六","七","八","九","十","十一","十二"};
　　　 public　String[]　getMonthTable()　{
　　　　　　 setGregorian(gregorianYear,gregorianMonth,1);
　　　　　　 computeChineseFields();
　　　　　　 computeSolarTerms();
　　　　　　 String[]　table　=　new　String[8];
　　　　　　 String　title　　=　null;
　　　　　　 if　(gregorianMonth<11)　title　　=　"　　　　　　　　　　　　　　　　　　　";
　　　　　　 else　title　　=　"　　　　　　　　　　　　　　　　　";
　　　　　　 title　=　title　+　monthNames[gregorianMonth-1]　+　"月"
　　　　　　　　　　　　　　　　　　　　 +　"　　　　　　　　　　　　　　　　　　　";
　　　　　　 String　header　=　"　　　日　　　　一　　　　二　　　　三　　　　四　　　　五　　　　六　";
　　　　　　 String　blank　　=　"　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　";
　　　　　　 table[0]　=　title;
　　　　　　 table[1]　=　header;
　　　　　　 int　wk　=　2;
　　　　　　 String　line　=　"";
　　　　　　 for　(int　i=1;　i<dayOfWeek;　i++)　{
　　　　　　　　　 line　+=　"　　　　　"　+　'　';
　　　　　　 }
　　　　　　 int　days　=　daysInGregorianMonth(gregorianYear,gregorianMonth);
　　　　　　 for　(int　i=gregorianDate;　i<=days;　i++)　{
　　　　　　　　　 line　+=　getDateString()　+　'　';
　　　　　　　　　 rollUpOneDay();
　　　　　　　　　 if　(dayOfWeek==1)　{
　　　　　　　　　　　　 table[wk]　=　line;
　　　　　　　　　　　　 line　=　"";
　　　　　　　　　　　　 wk++;
　　　　　　　　　 }
　　　　　　 }
　　　　　　 for　(int　i=dayOfWeek;　i<=7;　i++)　{
　　　　　　　　　 line　+=　"　　　　　"　+　'　';
　　　　　　 }
　　　　　　 table[wk]　=　line;
　　　　　　 for　(int　i=wk+1;　i<table.length;　i++)　{
　　　　　　　　　 table[i]　=　blank;
　　　　　　 }
　　　　　　 for　(int　i=0;　i<table.length;　i++)　{
　　　　　　　　　 table[i]　=　table[i].substring(0,table[i].length()-1);
　　　　　　 }

　　　　　　 return　table;
　　　 }
　　　 private　static　String[]　chineseMonthNames　=
　　　　　　 {"正","二","三","四","五","六","七","八","九","十","冬","腊"};
　　　 private　static　String[]　principleTermNames　=
　　　　　　 {"雨水","春分","谷雨","夏满","夏至","大暑","处暑","秋分","霜降",
　　　　　　　 "小雪","冬至","大寒"};
　　　 private　static　String[]　sectionalTermNames　=
　　　　　　 {"立春","惊蛰","清明","立夏","芒种","小暑","立秋","白露","寒露",
　　　　　　　 "立冬","大雪","小寒"};
　　　 public　String　getDateString()　{
　　　　　　 String　str　=　"*　　/　　";
　　　　　　 String　gm　=　String.valueOf(gregorianMonth);
　　　　　　 if　(gm.length()==1)　gm　=　'　'　+　gm;
　　　　　　 String　cm　=　String.valueOf(Math.abs(chineseMonth));
　　　　　　 if　(cm.length()==1)　cm　=　'　'　+　cm;
　　　　　　 String　gd　=　String.valueOf(gregorianDate);
　　　　　　 if　(gd.length()==1)　gd　=　'　'　+　gd;
　　　　　　 String　cd　=　String.valueOf(chineseDate);
　　　　　　 if　(cd.length()==1)　cd　=　'　'　+　cd;
　　　　　　 if　(gregorianDate==sectionalTerm)　{
　　　　　　　　　 str　=　"　"+sectionalTermNames[gregorianMonth-1];
　　　　　　 }　else　if　(gregorianDate==principleTerm)　{
　　　　　　　　　 str　=　"　"+principleTermNames[gregorianMonth-1];
　　　　　　 }　else　if　(chineseDate==1　&&　chineseMonth>0)　{
　　　　　　　　 str　=　"　"+chineseMonthNames[chineseMonth-1]+"月";
　　　　　　 }　else　if　(chineseDate==1　&&　chineseMonth<0)　{
　　　　　　　　 str　=　"*"+chineseMonthNames[-chineseMonth-1]+"月";
　　　　　　 }　else　{
　　　　　　　　 str　=　gd+'/'+cd;
　　　　　　 }
　　　　　　 return　str;
　　　 }
　　　 public　int　rollUpOneDay()　{
　　　　　　 dayOfWeek　=　dayOfWeek%7　+　1;
　　　　　　 dayOfYear++;
　　　　　　 gregorianDate++;
　　　　　　 int　days　=　daysInGregorianMonth(gregorianYear,gregorianMonth);
　　　　　　 if　(gregorianDate>days)　{
　　　　　　　　　 gregorianDate　=　1;
　　　　　　　　　 gregorianMonth++;
　　　　　　　　　 if　(gregorianMonth>12)　{
　　　　　　　　　　　　 gregorianMonth　=　1;
　　　　　　　　　　　　 gregorianYear++;
　　　　　　　　　　　　 dayOfYear　=　1;
　　　　　　　　　　　　 isGregorianLeap　=　isGregorianLeapYear(gregorianYear);
　　　　　　　　　 }
　　　　　　　　　 sectionalTerm　=　sectionalTerm(gregorianYear,gregorianMonth);
　　　　　　　　　 principleTerm　=　principleTerm(gregorianYear,gregorianMonth);
　　　　　　 }
　　　　　　 chineseDate++;
　　　　　　 days　=　daysInChineseMonth(chineseYear,chineseMonth);
　　　　　　 if　(chineseDate>days)　{
　　　　　　　　　 chineseDate　=　1;
　　　　　　　　　 chineseMonth　=　nextChineseMonth(chineseYear,chineseMonth);
　　　　　　　　　 if　(chineseMonth==1)　chineseYear++;
　　　　　　 }
　　　　　　 return　0;
　　　 }
}

时间： 2024-11-08 20:09:35

中国农历算法java实现的相关文章

php实现的农历算法实例_php技巧

本文实例讲述了php实现的农历算法.分享给大家供大家参考.具体如下: <?php function lunarcalendar ($month, $year) { global $lnlunarcalendar; /** * Lunar calendar 博大精深的农历 * 原始数据和算法思路来自 S&S */ /* 农历每月的天数. 每个元素为一年.每个元素中的数据为: [0]是闰月在哪个月,0为无闰月: [1]到[13]是每年12或13个月的每月天数: [14]是当年的天干次序, [15

算法系列（二十） 计算中国农历（一）

世界各国的日历都是以天为最小单位,但是关于年和月的算法却各不相同,大致可以分为三类: 阳历--以天文年作为日历的主要周期,例如:中国公历(格里历) 阴历--以天文月作为日 历的主要周期,例如:伊斯兰历 阴阳历--以天文年和天文月作为日历的主要周期,例如:中国农 历 我国古人很早就开始关注天象,定昼夜交替为"日",月轮盈亏为"月",寒暑交替为"年" ,在总结日月变化规律的基础上制定了兼有阴历月和阳历年性质的历法,称为中国农历.本文将介绍中国 农历的

以前收集的一些资料---使用ASP编写农历算法(一)

农历|算法                  使用ASP编写农历算法              新年将近,呵呵,写了一个阴历和阳历的ASP程序,就当给大家的新年贺礼(呵呵,这下蓝先生满意啦把,就当我送给你的圣诞礼物把...)希望大家能够喜欢...大家可以很方便的将这个农历加入到自己的主页中中国人使用中国人自己的日历,呵呵,希望大家以后能够支持Chinaasp的共同进步...一共两个文件cal.asp和cal2.inc(主要是常量的定义)cal.asp代码如下<!--#include virtua

以前收集的一些资料---使用ASP编写农历算法（二）

农历|算法 不知道大家去过www.renren.com没有,其中的农历其实就可以这样实现的...如果大家自己有兴趣的话,还可以给农历算法填加好多其他的功能...本程序的限制是只能够转换1950年到2050年之间的农历和公历...cal2.inc文件<%    Dim m_minyear    Dim m_maxyear    Dim NongLiDayName    Dim NongLiMonthName        m_minyear        = 1950    m_maxyear  

asp.net2.0的中国农历日期类

asp.net|农历 是2.0的,没有试验过,先保留着,以后还有用 以下是代码片段:using System;using System.Collections.Generic;using System.Globalization; namespace ChineseLunisolarCalendar{ class ChineseAlmanac : System.Globalization.ChineseLunisolarCalendar {  private System.Globalizati

无向图的最短路径算法JAVA实现(转)

一,问题描述 给出一个无向图,指定无向图中某个顶点作为源点.求出图中所有顶点到源点的最短路径. 无向图的最短路径其实是源点到该顶点的最少边的数目. 本文假设图的信息保存在文件中,通过读取文件来构造图.文件内容的格式参考这篇文章第一部分.   二,算法实现思路 无向图的最短路径实现相对于带权的有向图最短路径实现要简单得多. 源点的最短路径距离为0,从源点开始,采用广度优先的顺序,首先将与源点邻接的顶点的路径求出,然后再依次求解图中其他顶点的最短路径. 由于顶点的最短路径的求解顺序 是一个 广度优先

数组大小为2n+1-数组相关算法java，找出需求的数据

问题描述 数组相关算法java,找出需求的数据 存在一个数组,数组大小为2n+2,里面有n对个数,例如:1,2,2,3,4,1.(数组是无序的,考虑排序的话一定会超过限制)这,6个数中的单独的数就是3,4,要你用你能想到的最高效率的方法找出来 解决方案 如果数组是连续的则可以用byte[] b = new byte[n+1];然后遍历一遍原数组,将遍历的值放入b的下标中计数,最后为1的那个下标表示数据是单独的. 这样的话总最多做3n+3次操作就能找全单独的数. 如果数组里面的数是无规律的,那么可

Cocoa公历和中国农历直接的转换

看过某书上面的做法是先生成一个公历的calendar,使用的是: NSCalendar *cal = [NSCalendar currentCalendar]; 然后用它生成一个NSDateComponent,最后再用一个中国农历的calendar将NSDateComponent转换为一个农历的NSDate. 实际执行后发现转换后的日期是错的. 下面是一个正确的转换方法,关键在于:先生成一个农历的calendar,然后再转换为公历的表示: void show_local_date(NSDate

iphone6 plus怎么在日历中添加中国农历?iphone6添加农历

步骤1:在iphone6 plus桌面找到"设置"然后我们再进入到ldquo;邮件.通讯录.日历",在进入界面中我们再点击最下面的"其他历法"进入. 步骤2:然后我们会看到有一个"其他历法"下面会有一个"农历"即完成了设置.退出后再启动iOS8的日历工具,就可以看到农历的显示了. 好了到这里iphone6 plus添加中国农历的方法就到这里了,希望能给各位有帮助.