devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

日历 农历算法_chineselunarcalendar库

作者：你好赵伟 | 2024-08-22 17:17:41

赞

踩

chineselunarcalendar库
  1. package com.microdu.common;
  2.  
  3.  
  4. /**
  5.  * ChineseCalendarGB.java Copyright (c) 1997-2002 by Dr. Herong Yang 中国农历算法 -
  6.  * 实用于公历 1901 年至 2100 年之间的 200 年
  7.  */
  8. public class CalendarUtil {
  9.         private int gregorianYear;
  10.         private int gregorianMonth;
  11.         private int gregorianDate;
  12.         private boolean isGregorianLeap;
  13.         private int dayOfYear;
  14.         private int dayOfWeek; // 周日一星期的第一天
  15.         private int chineseYear;
  16.         private int chineseMonth; // 负数表示闰月
  17.         private int chineseDate;
  18.         private int sectionalTerm;
  19.         private int principleTerm;
  20.         private static char[] daysInGregorianMonth = { 31, 28, 31, 30, 31, 30, 31,
  21.                         31, 30, 31, 30, 31 };
  22.         private static String[] stemNames = { "甲", "乙", "丙", "丁", "戊", "己", "庚",
  23.                         "辛", "壬", "癸" };
  24.         private static String[] branchNames = { "子", "丑", "寅", "卯", "辰", "巳", "午",
  25.                         "未", "申", "酉", "戌", "亥" };
  26.         private static String[] animalNames = { "鼠", "牛", "虎", "兔", "龙", "蛇", "马",
  27.                         "羊", "猴", "鸡", "狗", "猪" };
  28.  
  29.         public static final String[] daysOfMonth = { "1", "2", "3", "4", "5", "6",
  30.                         "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17",
  31.                         "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28",
  32.                         "29", "30", "31" };
  33.  
  34.         private String monthOfAlmanac[] = {"正月","二月","三月","四月","五月","六月","七月","八月","九月","十月","冬月","腊月"};
  35.         private String daysOfAlmanac[] = { "初一", "初二", "初三", "初四", "初五", "初六",
  36.                         "初七", "初八", "初九", "初十", "十一", "十二", "十三", "十四", "十五", "十六", "十七",
  37.                         "十八", "十九", "二十", "廿一", "廿二", "廿三", "廿四", "廿五", "廿六", "廿七", "廿八",
  38.                         "廿九", "三十" }; // 农历的天数
  39.  
  40.         public CalendarUtil() {
  41.                 setGregorian(1901, 1, 1);
  42.         }
  43.  
  44.         /**
  45.          * 得到对应天的农历 要判断闰月 月初 月末         * 
  46.          * @param y
  47.          * @param m
  48.          * @param d
  49.          * @return String
  50.          */
  51.         public String getChineseDay(int y, int m, int d) {
  52.  
  53.                 CalendarUtil c = new CalendarUtil();
  54.  
  55.                 c.setGregorian(y, m, d);
  56.                 c.computeChineseFields();
  57.                 c.computeSolarTerms();
  58.  
  59.                 int cd = c.getChineseDate();
  60.  
  61.                 return daysOfAlmanac[cd - 1];
  62.         }
  63.  
  64.         /**
  65.      *  得到对应天的农历
  66.      *  要判断闰月 月初 月末
  67.      * @param y
  68.      * @param m
  69.      * @param d
  70.      * @return
  71.      */
  72.         public String getChineseMonth(int y, int m, int d) {
  73.                 setGregorian(y,m,d);
  74.                 computeChineseFields();
  75.                 computeSolarTerms();
  76.                 
  77.                 int cd = getChineseMonth();
  78.                 if(cd < 1 || cd > 29)
  79.                         cd = 1;
  80.                 return monthOfAlmanac[cd -1];
  81.         }
  82.         
  83.         public void setGregorian(int y, int m, int d) {
  84.                 gregorianYear = y;
  85.                 gregorianMonth = m;
  86.                 gregorianDate = d;
  87.                 isGregorianLeap = isGregorianLeapYear(y);
  88.                 dayOfYear = dayOfYear(y, m, d);
  89.                 dayOfWeek = dayOfWeek(y, m, d);
  90.                 chineseYear = 0;
  91.                 chineseMonth = 0;
  92.                 chineseDate = 0;
  93.                 sectionalTerm = 0;
  94.                 principleTerm = 0;
  95.         }
  96.  
  97.         // 判断是否是闰年
  98.         public static boolean isGregorianLeapYear(int year) {
  99.                 boolean isLeap = false;
  100.                 if (year % 4 == 0)
  101.                         isLeap = true;
  102.                 if (year % 100 == 0)
  103.                         isLeap = false;
  104.                 if (year % 400 == 0)
  105.                         isLeap = true;
  106.                 return isLeap;
  107.         }
  108.  
  109.         // 返回一个月有几天
  110.         public static int daysInGregorianMonth(int y, int m) {
  111.                 int d = daysInGregorianMonth[m - 1];
  112.                 if (m == 2 && isGregorianLeapYear(y))
  113.                         d++; // 公历闰年二月多一天
  114.                 return d;
  115.         }
  116.  
  117.         // 计算当前天在本年中是第几天
  118.         public static int dayOfYear(int y, int m, int d) {
  119.                 int c = 0;
  120.                 for (int i = 1; i < m; i++) {
  121.                         c = c + daysInGregorianMonth(y, i);
  122.                 }
  123.                 c = c + d;
  124.                 return c;
  125.         }
  126.  
  127.         // 当前天是本周的第几天 ， 从星期天开始算
  128.         public static int dayOfWeek(int y, int m, int d) {
  129.                 int w = 1; // 公历一年一月一日是星期一，所以起始值为星期日
  130.                 y = (y - 1) % 400 + 1; // 公历星期值分部 400 年循环一次
  131.                 int ly = (y - 1) / 4; // 闰年次数
  132.                 ly = ly - (y - 1) / 100;
  133.                 ly = ly + (y - 1) / 400;
  134.                 int ry = y - 1 - ly; // 常年次数
  135.                 w = w + ry; // 常年星期值增一
  136.                 w = w + 2 * ly; // 闰年星期值增二
  137.                 w = w + dayOfYear(y, m, d);
  138.                 w = (w - 1) % 7 + 1;
  139.                 return w;
  140.         }
  141.  
  142.         // 农历月份大小压缩表，两个字节表示一年。两个字节共十六个二进制位数，
  143.         // 前四个位数表示闰月月份，后十二个位数表示十二个农历月份的大小。
  144.         private static char[] chineseMonths = { 0x00, 0x04, 0xad, 0x08, 0x5a, 0x01,
  145.                         0xd5, 0x54, 0xb4, 0x09, 0x64, 0x05, 0x59, 0x45, 0x95, 0x0a, 0xa6,
  146.                         0x04, 0x55, 0x24, 0xad, 0x08, 0x5a, 0x62, 0xda, 0x04, 0xb4, 0x05,
  147.                         0xb4, 0x55, 0x52, 0x0d, 0x94, 0x0a, 0x4a, 0x2a, 0x56, 0x02, 0x6d,
  148.                         0x71, 0x6d, 0x01, 0xda, 0x02, 0xd2, 0x52, 0xa9, 0x05, 0x49, 0x0d,
  149.                         0x2a, 0x45, 0x2b, 0x09, 0x56, 0x01, 0xb5, 0x20, 0x6d, 0x01, 0x59,
  150.                         0x69, 0xd4, 0x0a, 0xa8, 0x05, 0xa9, 0x56, 0xa5, 0x04, 0x2b, 0x09,
  151.                         0x9e, 0x38, 0xb6, 0x08, 0xec, 0x74, 0x6c, 0x05, 0xd4, 0x0a, 0xe4,
  152.                         0x6a, 0x52, 0x05, 0x95, 0x0a, 0x5a, 0x42, 0x5b, 0x04, 0xb6, 0x04,
  153.                         0xb4, 0x22, 0x6a, 0x05, 0x52, 0x75, 0xc9, 0x0a, 0x52, 0x05, 0x35,
  154.                         0x55, 0x4d, 0x0a, 0x5a, 0x02, 0x5d, 0x31, 0xb5, 0x02, 0x6a, 0x8a,
  155.                         0x68, 0x05, 0xa9, 0x0a, 0x8a, 0x6a, 0x2a, 0x05, 0x2d, 0x09, 0xaa,
  156.                         0x48, 0x5a, 0x01, 0xb5, 0x09, 0xb0, 0x39, 0x64, 0x05, 0x25, 0x75,
  157.                         0x95, 0x0a, 0x96, 0x04, 0x4d, 0x54, 0xad, 0x04, 0xda, 0x04, 0xd4,
  158.                         0x44, 0xb4, 0x05, 0x54, 0x85, 0x52, 0x0d, 0x92, 0x0a, 0x56, 0x6a,
  159.                         0x56, 0x02, 0x6d, 0x02, 0x6a, 0x41, 0xda, 0x02, 0xb2, 0xa1, 0xa9,
  160.                         0x05, 0x49, 0x0d, 0x0a, 0x6d, 0x2a, 0x09, 0x56, 0x01, 0xad, 0x50,
  161.                         0x6d, 0x01, 0xd9, 0x02, 0xd1, 0x3a, 0xa8, 0x05, 0x29, 0x85, 0xa5,
  162.                         0x0c, 0x2a, 0x09, 0x96, 0x54, 0xb6, 0x08, 0x6c, 0x09, 0x64, 0x45,
  163.                         0xd4, 0x0a, 0xa4, 0x05, 0x51, 0x25, 0x95, 0x0a, 0x2a, 0x72, 0x5b,
  164.                         0x04, 0xb6, 0x04, 0xac, 0x52, 0x6a, 0x05, 0xd2, 0x0a, 0xa2, 0x4a,
  165.                         0x4a, 0x05, 0x55, 0x94, 0x2d, 0x0a, 0x5a, 0x02, 0x75, 0x61, 0xb5,
  166.                         0x02, 0x6a, 0x03, 0x61, 0x45, 0xa9, 0x0a, 0x4a, 0x05, 0x25, 0x25,
  167.                         0x2d, 0x09, 0x9a, 0x68, 0xda, 0x08, 0xb4, 0x09, 0xa8, 0x59, 0x54,
  168.                         0x03, 0xa5, 0x0a, 0x91, 0x3a, 0x96, 0x04, 0xad, 0xb0, 0xad, 0x04,
  169.                         0xda, 0x04, 0xf4, 0x62, 0xb4, 0x05, 0x54, 0x0b, 0x44, 0x5d, 0x52,
  170.                         0x0a, 0x95, 0x04, 0x55, 0x22, 0x6d, 0x02, 0x5a, 0x71, 0xda, 0x02,
  171.                         0xaa, 0x05, 0xb2, 0x55, 0x49, 0x0b, 0x4a, 0x0a, 0x2d, 0x39, 0x36,
  172.                         0x01, 0x6d, 0x80, 0x6d, 0x01, 0xd9, 0x02, 0xe9, 0x6a, 0xa8, 0x05,
  173.                         0x29, 0x0b, 0x9a, 0x4c, 0xaa, 0x08, 0xb6, 0x08, 0xb4, 0x38, 0x6c,
  174.                         0x09, 0x54, 0x75, 0xd4, 0x0a, 0xa4, 0x05, 0x45, 0x55, 0x95, 0x0a,
  175.                         0x9a, 0x04, 0x55, 0x44, 0xb5, 0x04, 0x6a, 0x82, 0x6a, 0x05, 0xd2,
  176.                         0x0a, 0x92, 0x6a, 0x4a, 0x05, 0x55, 0x0a, 0x2a, 0x4a, 0x5a, 0x02,
  177.                         0xb5, 0x02, 0xb2, 0x31, 0x69, 0x03, 0x31, 0x73, 0xa9, 0x0a, 0x4a,
  178.                         0x05, 0x2d, 0x55, 0x2d, 0x09, 0x5a, 0x01, 0xd5, 0x48, 0xb4, 0x09,
  179.                         0x68, 0x89, 0x54, 0x0b, 0xa4, 0x0a, 0xa5, 0x6a, 0x95, 0x04, 0xad,
  180.                         0x08, 0x6a, 0x44, 0xda, 0x04, 0x74, 0x05, 0xb0, 0x25, 0x54, 0x03 };
  181.  
  182.         // 初始日，公历农历对应日期：
  183.         // 公历 1901 年 1 月 1 日，对应农历 4598 年 11 月 11 日
  184.         private static int baseYear = 1901;
  185.         private static int baseMonth = 1;
  186.         private static int baseDate = 1;
  187.         private static int baseIndex = 0;
  188.         private static int baseChineseYear = 4598 - 1;
  189.         private static int baseChineseMonth = 11;
  190.         private static int baseChineseDate = 11;
  191.  
  192.         public int computeChineseFields() {
  193.                 if (gregorianYear < 1901 || gregorianYear > 2100)
  194.                         return 1;
  195.                 int startYear = baseYear;
  196.                 int startMonth = baseMonth;
  197.                 int startDate = baseDate;
  198.                 chineseYear = baseChineseYear;
  199.                 chineseMonth = baseChineseMonth;
  200.                 chineseDate = baseChineseDate;
  201.                 // 第二个对应日，用以提高计算效率
  202.                 // 公历 2000 年 1 月 1 日，对应农历 4697 年 11 月 25 日
  203.                 if (gregorianYear >= 2000) {
  204.                         startYear = baseYear + 99;
  205.                         startMonth = 1;
  206.                         startDate = 1;
  207.                         chineseYear = baseChineseYear + 99;
  208.                         chineseMonth = 11;
  209.                         chineseDate = 25;
  210.                 }
  211.                 int daysDiff = 0;
  212.                 for (int i = startYear; i < gregorianYear; i++) {
  213.                         daysDiff += 365;
  214.                         if (isGregorianLeapYear(i))
  215.                                 daysDiff += 1; // leap year
  216.                 }
  217.                 for (int i = startMonth; i < gregorianMonth; i++) {
  218.                         daysDiff += daysInGregorianMonth(gregorianYear, i);
  219.                 }
  220.                 daysDiff += gregorianDate - startDate;
  221.  
  222.                 chineseDate += daysDiff;
  223.                 int lastDate = daysInChineseMonth(chineseYear, chineseMonth);
  224.                 int nextMonth = nextChineseMonth(chineseYear, chineseMonth);
  225.                 while (chineseDate > lastDate) {
  226.                         if (Math.abs(nextMonth) < Math.abs(chineseMonth))
  227.                                 chineseYear++;
  228.                         chineseMonth = nextMonth;
  229.                         chineseDate -= lastDate;
  230.                         lastDate = daysInChineseMonth(chineseYear, chineseMonth);
  231.                         nextMonth = nextChineseMonth(chineseYear, chineseMonth);
  232.                 }
  233.                 return 0;
  234.         }
  235.  
  236.         private static int[] bigLeapMonthYears = {
  237.                         // 大闰月的闰年年份
  238.                         6, 14, 19, 25, 33, 36, 38, 41, 44, 52, 55, 79, 117, 136, 147, 150,
  239.                         155, 158, 185, 193 };
  240.  
  241.         public static int daysInChineseMonth(int y, int m) {
  242.                 // 注意：闰月 m < 0
  243.                 int index = y - baseChineseYear + baseIndex;
  244.                 int v = 0;
  245.                 int l = 0;
  246.                 int d = 30;
  247.                 if (1 <= m && m <= 8) {
  248.                         v = chineseMonths[2 * index];
  249.                         l = m - 1;
  250.                         if (((v >> l) & 0x01) == 1)
  251.                                 d = 29;
  252.                 } else if (9 <= m && m <= 12) {
  253.                         v = chineseMonths[2 * index + 1];
  254.                         l = m - 9;
  255.                         if (((v >> l) & 0x01) == 1)
  256.                                 d = 29;
  257.                 } else {
  258.                         v = chineseMonths[2 * index + 1];
  259.                         v = (v >> 4) & 0x0F;
  260.                         if (v != Math.abs(m)) {
  261.                                 d = 0;
  262.                         } else {
  263.                                 d = 29;
  264.                                 for (int i = 0; i < bigLeapMonthYears.length; i++) {
  265.                                         if (bigLeapMonthYears[i] == index) {
  266.                                                 d = 30;
  267.                                                 break;
  268.                                         }
  269.                                 }
  270.                         }
  271.                 }
  272.                 return d;
  273.         }
  274.  
  275.         public static int nextChineseMonth(int y, int m) {
  276.                 int n = Math.abs(m) + 1;
  277.                 if (m > 0) {
  278.                         int index = y - baseChineseYear + baseIndex;
  279.                         int v = chineseMonths[2 * index + 1];
  280.                         v = (v >> 4) & 0x0F;
  281.                         if (v == m)
  282.                                 n = -m;
  283.                 }
  284.                 if (n == 13)
  285.                         n = 1;
  286.                 return n;
  287.         }
  288.  
  289.         private static char[][] sectionalTermMap = {
  290.                         { 7, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 6, 6, 5, 5, 6, 6, 5, 5, 5, 5, 5,
  291.                                         5, 5, 5, 4, 5, 5 },
  292.                         { 5, 4, 5, 5, 5, 4, 4, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 4, 4, 4, 3,
  293.                                         3, 4, 4, 3, 3, 3 },
  294.                         { 6, 6, 6, 7, 6, 6, 6, 6, 5, 6, 6, 6, 5, 5, 6, 6, 5, 5, 5, 6, 5, 5,
  295.                                         5, 5, 4, 5, 5, 5, 5 },
  296.                         { 5, 5, 6, 6, 5, 5, 5, 6, 5, 5, 5, 5, 4, 5, 5, 5, 4, 4, 5, 5, 4, 4,
  297.                                         4, 5, 4, 4, 4, 4, 5 },
  298.                         { 6, 6, 6, 7, 6, 6, 6, 6, 5, 6, 6, 6, 5, 5, 6, 6, 5, 5, 5, 6, 5, 5,
  299.                                         5, 5, 4, 5, 5, 5, 5 },
  300.                         { 6, 6, 7, 7, 6, 6, 6, 7, 6, 6, 6, 6, 5, 6, 6, 6, 5, 5, 6, 6, 5, 5,
  301.                                         5, 6, 5, 5, 5, 5, 4, 5, 5, 5, 5 },
  302.                         { 7, 8, 8, 8, 7, 7, 8, 8, 7, 7, 7, 8, 7, 7, 7, 7, 6, 7, 7, 7, 6, 6,
  303.                                         7, 7, 6, 6, 6, 7, 7 },
  304.                         { 8, 8, 8, 9, 8, 8, 8, 8, 7, 8, 8, 8, 7, 7, 8, 8, 7, 7, 7, 8, 7, 7,
  305.                                         7, 7, 6, 7, 7, 7, 6, 6, 7, 7, 7 },
  306.                         { 8, 8, 8, 9, 8, 8, 8, 8, 7, 8, 8, 8, 7, 7, 8, 8, 7, 7, 7, 8, 7, 7,
  307.                                         7, 7, 6, 7, 7, 7, 7 },
  308.                         { 9, 9, 9, 9, 8, 9, 9, 9, 8, 8, 9, 9, 8, 8, 8, 9, 8, 8, 8, 8, 7, 8,
  309.                                         8, 8, 7, 7, 8, 8, 8 },
  310.                         { 8, 8, 8, 8, 7, 8, 8, 8, 7, 7, 8, 8, 7, 7, 7, 8, 7, 7, 7, 7, 6, 7,
  311.                                         7, 7, 6, 6, 7, 7, 7 },
  312.                         { 7, 8, 8, 8, 7, 7, 8, 8, 7, 7, 7, 8, 7, 7, 7, 7, 6, 7, 7, 7, 6, 6,
  313.                                         7, 7, 6, 6, 6, 7, 7 } };
  314.         private static char[][] sectionalTermYear = {
  315.                         { 13, 49, 85, 117, 149, 185, 201, 250, 250 },
  316.                         { 13, 45, 81, 117, 149, 185, 201, 250, 250 },
  317.                         { 13, 48, 84, 112, 148, 184, 200, 201, 250 },
  318.                         { 13, 45, 76, 108, 140, 172, 200, 201, 250 },
  319.                         { 13, 44, 72, 104, 132, 168, 200, 201, 250 },
  320.                         { 5, 33, 68, 96, 124, 152, 188, 200, 201 },
  321.                         { 29, 57, 85, 120, 148, 176, 200, 201, 250 },
  322.                         { 13, 48, 76, 104, 132, 168, 196, 200, 201 },
  323.                         { 25, 60, 88, 120, 148, 184, 200, 201, 250 },
  324.                         { 16, 44, 76, 108, 144, 172, 200, 201, 250 },
  325.                         { 28, 60, 92, 124, 160, 192, 200, 201, 250 },
  326.                         { 17, 53, 85, 124, 156, 188, 200, 201, 250 } };
  327.         private static char[][] principleTermMap = {
  328.                         { 21, 21, 21, 21, 21, 20, 21, 21, 21, 20, 20, 21, 21, 20, 20, 20,
  329.                                         20, 20, 20, 20, 20, 19, 20, 20, 20, 19, 19, 20 },
  330.                         { 20, 19, 19, 20, 20, 19, 19, 19, 19, 19, 19, 19, 19, 18, 19, 19,
  331.                                         19, 18, 18, 19, 19, 18, 18, 18, 18, 18, 18, 18 },
  332.                         { 21, 21, 21, 22, 21, 21, 21, 21, 20, 21, 21, 21, 20, 20, 21, 21,
  333.                                         20, 20, 20, 21, 20, 20, 20, 20, 19, 20, 20, 20, 20 },
  334.                         { 20, 21, 21, 21, 20, 20, 21, 21, 20, 20, 20, 21, 20, 20, 20, 20,
  335.                                         19, 20, 20, 20, 19, 19, 20, 20, 19, 19, 19, 20, 20 },
  336.                         { 21, 22, 22, 22, 21, 21, 22, 22, 21, 21, 21, 22, 21, 21, 21, 21,
  337.                                         20, 21, 21, 21, 20, 20, 21, 21, 20, 20, 20, 21, 21 },
  338.                         { 22, 22, 22, 22, 21, 22, 22, 22, 21, 21, 22, 22, 21, 21, 21, 22,
  339.                                         21, 21, 21, 21, 20, 21, 21, 21, 20, 20, 21, 21, 21 },
  340.                         { 23, 23, 24, 24, 23, 23, 23, 24, 23, 23, 23, 23, 22, 23, 23, 23,
  341.                                         22, 22, 23, 23, 22, 22, 22, 23, 22, 22, 22, 22, 23 },
  342.                         { 23, 24, 24, 24, 23, 23, 24, 24, 23, 23, 23, 24, 23, 23, 23, 23,
  343.                                         22, 23, 23, 23, 22, 22, 23, 23, 22, 22, 22, 23, 23 },
  344.                         { 23, 24, 24, 24, 23, 23, 24, 24, 23, 23, 23, 24, 23, 23, 23, 23,
  345.                                         22, 23, 23, 23, 22, 22, 23, 23, 22, 22, 22, 23, 23 },
  346.                         { 24, 24, 24, 24, 23, 24, 24, 24, 23, 23, 24, 24, 23, 23, 23, 24,
  347.                                         23, 23, 23, 23, 22, 23, 23, 23, 22, 22, 23, 23, 23 },
  348.                         { 23, 23, 23, 23, 22, 23, 23, 23, 22, 22, 23, 23, 22, 22, 22, 23,
  349.                                         22, 22, 22, 22, 21, 22, 22, 22, 21, 21, 22, 22, 22 },
  350.                         { 22, 22, 23, 23, 22, 22, 22, 23, 22, 22, 22, 22, 21, 22, 22, 22,
  351.                                         21, 21, 22, 22, 21, 21, 21, 22, 21, 21, 21, 21, 22 } };
  352.         private static char[][] principleTermYear = {
  353.                         { 13, 45, 81, 113, 149, 185, 201 },
  354.                         { 21, 57, 93, 125, 161, 193, 201 },
  355.                         { 21, 56, 88, 120, 152, 188, 200, 201 },
  356.                         { 21, 49, 81, 116, 144, 176, 200, 201 },
  357.                         { 17, 49, 77, 112, 140, 168, 200, 201 },
  358.                         { 28, 60, 88, 116, 148, 180, 200, 201 },
  359.                         { 25, 53, 84, 112, 144, 172, 200, 201 },
  360.                         { 29, 57, 89, 120, 148, 180, 200, 201 },
  361.                         { 17, 45, 73, 108, 140, 168, 200, 201 },
  362.                         { 28, 60, 92, 124, 160, 192, 200, 201 },
  363.                         { 16, 44, 80, 112, 148, 180, 200, 201 },
  364.                         { 17, 53, 88, 120, 156, 188, 200, 201 } };
  365.  
  366.         public int computeSolarTerms() {
  367.                 if (gregorianYear < 1901 || gregorianYear > 2100)
  368.                         return 1;
  369.                 sectionalTerm = sectionalTerm(gregorianYear, gregorianMonth);
  370.                 principleTerm = principleTerm(gregorianYear, gregorianMonth);
  371.                 return 0;
  372.         }
  373.  
  374.         public static int sectionalTerm(int y, int m) {
  375.                 if (y < 1901 || y > 2100)
  376.                         return 0;
  377.                 int index = 0;
  378.                 int ry = y - baseYear + 1;
  379.                 while (ry >= sectionalTermYear[m - 1][index])
  380.                         index++;
  381.                 int term = sectionalTermMap[m - 1][4 * index + ry % 4];
  382.                 if ((ry == 121) && (m == 4))
  383.                         term = 5;
  384.                 if ((ry == 132) && (m == 4))
  385.                         term = 5;
  386.                 if ((ry == 194) && (m == 6))
  387.                         term = 6;
  388.                 return term;
  389.         }
  390.  
  391.         public static int principleTerm(int y, int m) {
  392.                 if (y < 1901 || y > 2100)
  393.                         return 0;
  394.                 int index = 0;
  395.                 int ry = y - baseYear + 1;
  396.                 while (ry >= principleTermYear[m - 1][index])
  397.                         index++;
  398.                 int term = principleTermMap[m - 1][4 * index + ry % 4];
  399.                 if ((ry == 171) && (m == 3))
  400.                         term = 21;
  401.                 if ((ry == 181) && (m == 5))
  402.                         term = 21;
  403.                 return term;
  404.         }
  405.  
  406.         public String toString() {
  407.                 StringBuffer buf = new StringBuffer();
  408.                 buf.append("Gregorian Year: " + gregorianYear + "\n");
  409.                 buf.append("Gregorian Month: " + gregorianMonth + "\n");
  410.                 buf.append("Gregorian Date: " + gregorianDate + "\n");
  411.                 buf.append("Is Leap Year: " + isGregorianLeap + "\n");
  412.                 buf.append("Day of Year: " + dayOfYear + "\n");
  413.                 buf.append("Day of Week: " + dayOfWeek + "\n");
  414.                 buf.append("Chinese Year: " + chineseYear + "\n");
  415.                 buf.append("Heavenly Stem: " + ((chineseYear - 1) % 10) + "\n");
  416.                 buf.append("Earthly Branch: " + ((chineseYear - 1) % 12) + "\n");
  417.                 buf.append("Chinese Month: " + chineseMonth + "\n");
  418.                 buf.append("Chinese Date: " + chineseDate + "\n");
  419.                 buf.append("Sectional Term: " + sectionalTerm + "\n");
  420.                 buf.append("Principle Term: " + principleTerm + "\n");
  421.                 return buf.toString();
  422.         }
  423.  
  424.         public String[] getYearTable() {
  425.                 setGregorian(gregorianYear, 1, 1);
  426.                 computeChineseFields();
  427.                 computeSolarTerms();
  428.                 String[] table = new String[58]; // 6*9 + 4
  429.                 table[0] = getTextLine(27, "公历年历：" + gregorianYear);
  430.                 table[1] = getTextLine(27, "农历年历：" + (chineseYear + 1) + " ("
  431.                                 + stemNames[(chineseYear + 1 - 1) % 10]
  432.                                 + branchNames[(chineseYear + 1 - 1) % 12] + " - "
  433.                                 + animalNames[(chineseYear + 1 - 1) % 12] + "年)");
  434.                 int ln = 2;
  435.                 String blank = "                                         " + "  "
  436.                                 + "                                         ";
  437.                 String[] mLeft = null;
  438.                 String[] mRight = null;
  439.                 for (int i = 1; i <= 6; i++) {
  440.                         table[ln] = blank;
  441.                         ln++;
  442.                         mLeft = getMonthTable();
  443.                         mRight = getMonthTable();
  444.                         for (int j = 0; j < mLeft.length; j++) {
  445.                                 String line = mLeft[j] + "  " + mRight[j];
  446.                                 table[ln] = line;
  447.                                 ln++;
  448.                         }
  449.                 }
  450.                 table[ln] = blank;
  451.                 ln++;
  452.                 table[ln] = getTextLine(0, "##/## - 公历日期/农历日期，(*)#月 - (闰)农历月第一天");
  453.                 ln++;
  454.                 return table;
  455.         }
  456.  
  457.         public static String getTextLine(int s, String t) {
  458.                 String str = "                                         " + "  "
  459.                                 + "                                         ";
  460.                 if (t != null && s < str.length() && s + t.length() < str.length())
  461.                         str = str.substring(0, s) + t + str.substring(s + t.length());
  462.                 return str;
  463.         }
  464.  
  465.         private static String[] monthNames = { "一", "二", "三", "四", "五", "六", "七",
  466.                         "八", "九", "十", "十一", "十二" };
  467.  
  468.         public String[] getMonthTable() {
  469.                 setGregorian(gregorianYear, gregorianMonth, 1);
  470.                 computeChineseFields();
  471.                 computeSolarTerms();
  472.                 String[] table = new String[8];
  473.                 String title = null;
  474.                 if (gregorianMonth < 11)
  475.                         title = "                   ";
  476.                 else
  477.                         title = "                 ";
  478.                 title = title + monthNames[gregorianMonth - 1] + "月"
  479.                                 + "                   ";
  480.                 String header = "   日    一    二    三    四    五    六 ";
  481.                 String blank = "                                          ";
  482.                 table[0] = title;
  483.                 table[1] = header;
  484.                 int wk = 2;
  485.                 String line = "";
  486.                 for (int i = 1; i < dayOfWeek; i++) {
  487.                         line += "     " + ' ';
  488.                 }
  489.                 int days = daysInGregorianMonth(gregorianYear, gregorianMonth);
  490.                 for (int i = gregorianDate; i <= days; i++) {
  491.                         line += getDateString() + ' ';
  492.                         rollUpOneDay();
  493.                         if (dayOfWeek == 1) {
  494.                                 table[wk] = line;
  495.                                 line = "";
  496.                                 wk++;
  497.                         }
  498.                 }
  499.                 for (int i = dayOfWeek; i <= 7; i++) {
  500.                         line += "     " + ' ';
  501.                 }
  502.                 table[wk] = line;
  503.                 for (int i = wk + 1; i < table.length; i++) {
  504.                         table[i] = blank;
  505.                 }
  506.                 for (int i = 0; i < table.length; i++) {
  507.                         table[i] = table[i].substring(0, table[i].length() - 1);
  508.                 }
  509.  
  510.                 return table;
  511.         }
  512.  
  513.         private static String[] chineseMonthNames = { "正", "二", "三", "四", "五", "六",
  514.                         "七", "八", "九", "十", "冬", "腊" };
  515.         private static String[] principleTermNames = { "雨水", "春分", "谷雨", "夏满",
  516.                         "夏至", "大暑", "处暑", "秋分", "霜降", "小雪", "冬至", "大寒" };
  517.         private static String[] sectionalTermNames = { "立春", "惊蛰", "清明", "立夏",
  518.                         "芒种", "小暑", "立秋", "白露", "寒露", "立冬", "大雪", "小寒" };
  519.  
  520.         public String getDateString() {
  521.                 String str = "*  /  ";
  522.                 String gm = String.valueOf(gregorianMonth);
  523.                 if (gm.length() == 1)
  524.                         gm = ' ' + gm;
  525.                 String cm = String.valueOf(Math.abs(chineseMonth));
  526.                 if (cm.length() == 1)
  527.                         cm = ' ' + cm;
  528.                 String gd = String.valueOf(gregorianDate);
  529.                 if (gd.length() == 1)
  530.                         gd = ' ' + gd;
  531.                 String cd = String.valueOf(chineseDate);
  532.                 if (cd.length() == 1)
  533.                         cd = ' ' + cd;
  534.                 if (gregorianDate == sectionalTerm) {
  535.                         str = " " + sectionalTermNames[gregorianMonth - 1];
  536.                 } else if (gregorianDate == principleTerm) {
  537.                         str = " " + principleTermNames[gregorianMonth - 1];
  538.                 } else if (chineseDate == 1 && chineseMonth > 0) {
  539.                         str = " " + chineseMonthNames[chineseMonth - 1] + "月";
  540.                 } else if (chineseDate == 1 && chineseMonth < 0) {
  541.                         str = "*" + chineseMonthNames[-chineseMonth - 1] + "月";
  542.                 } else {
  543.                         str = gd + '/' + cd;
  544.                 }
  545.                 return str;
  546.         }
  547.  
  548.         public int rollUpOneDay() {
  549.                 dayOfWeek = dayOfWeek % 7 + 1;
  550.                 dayOfYear++;
  551.                 gregorianDate++;
  552.                 int days = daysInGregorianMonth(gregorianYear, gregorianMonth);
  553.                 if (gregorianDate > days) {
  554.                         gregorianDate = 1;
  555.                         gregorianMonth++;
  556.                         if (gregorianMonth > 12) {
  557.                                 gregorianMonth = 1;
  558.                                 gregorianYear++;
  559.                                 dayOfYear = 1;
  560.                                 isGregorianLeap = isGregorianLeapYear(gregorianYear);
  561.                         }
  562.                         sectionalTerm = sectionalTerm(gregorianYear, gregorianMonth);
  563.                         principleTerm = principleTerm(gregorianYear, gregorianMonth);
  564.                 }
  565.                 chineseDate++;
  566.                 days = daysInChineseMonth(chineseYear, chineseMonth);
  567.                 if (chineseDate > days) {
  568.                         chineseDate = 1;
  569.                         chineseMonth = nextChineseMonth(chineseYear, chineseMonth);
  570.                         if (chineseMonth == 1)
  571.                                 chineseYear++;
  572.                 }
  573.                 return 0;
  574.         }
  575.  
  576.         public int getGregorianYear() {
  577.                 return gregorianYear;
  578.         }
  579.  
  580.         public void setGregorianYear(int gregorianYear) {
  581.                 this.gregorianYear = gregorianYear;
  582.         }
  583.  
  584.         public int getGregorianMonth() {
  585.                 return gregorianMonth;
  586.         }
  587.  
  588.         public void setGregorianMonth(int gregorianMonth) {
  589.                 this.gregorianMonth = gregorianMonth;
  590.         }
  591.  
  592.         public int getGregorianDate() {
  593.                 return gregorianDate;
  594.         }
  595.  
  596.         public void setGregorianDate(int gregorianDate) {
  597.                 this.gregorianDate = gregorianDate;
  598.         }
  599.  
  600.         public boolean isGregorianLeap() {
  601.                 return isGregorianLeap;
  602.         }
  603.  
  604.         public void setGregorianLeap(boolean isGregorianLeap) {
  605.                 this.isGregorianLeap = isGregorianLeap;
  606.         }
  607.  
  608.         public int getDayOfYear() {
  609.                 return dayOfYear;
  610.         }
  611.  
  612.         public void setDayOfYear(int dayOfYear) {
  613.                 this.dayOfYear = dayOfYear;
  614.         }
  615.  
  616.         public int getDayOfWeek() {
  617.                 return dayOfWeek;
  618.         }
  619.  
  620.         public void setDayOfWeek(int dayOfWeek) {
  621.                 this.dayOfWeek = dayOfWeek;
  622.         }
  623.  
  624.         public int getChineseYear() {
  625.                 return chineseYear;
  626.         }
  627.  
  628.         public void setChineseYear(int chineseYear) {
  629.                 this.chineseYear = chineseYear;
  630.         }
  631.  
  632.         public int getChineseMonth() {
  633.                 return chineseMonth;
  634.         }
  635.  
  636.         public void setChineseMonth(int chineseMonth) {
  637.                 this.chineseMonth = chineseMonth;
  638.         }
  639.  
  640.         public int getChineseDate() {
  641.                 return chineseDate;
  642.         }
  643.  
  644.         public void setChineseDate(int chineseDate) {
  645.                 this.chineseDate = chineseDate;
  646.         }
  647.  
  648.         public int getSectionalTerm() {
  649.                 return sectionalTerm;
  650.         }
  651.  
  652.         public void setSectionalTerm(int sectionalTerm) {
  653.                 this.sectionalTerm = sectionalTerm;
  654.         }
  655.  
  656.         public int getPrincipleTerm() {
  657.                 return principleTerm;
  658.         }
  659.  
  660.         public void setPrincipleTerm(int principleTerm) {
  661.                 this.principleTerm = principleTerm;
  662.         }
  663.  
  664.         public static char[] getDaysInGregorianMonth() {
  665.                 return daysInGregorianMonth;
  666.         }
  667.  
  668.         public static void setDaysInGregorianMonth(char[] daysInGregorianMonth) {
  669.                 CalendarUtil.daysInGregorianMonth = daysInGregorianMonth;
  670.         }
  671.  
  672.         public static String[] getStemNames() {
  673.                 return stemNames;
  674.         }
  675.  
  676.         public static void setStemNames(String[] stemNames) {
  677.                 CalendarUtil.stemNames = stemNames;
  678.         }
  679.  
  680.         public static String[] getBranchNames() {
  681.                 return branchNames;
  682.         }
  683.  
  684.         public static void setBranchNames(String[] branchNames) {
  685.                 CalendarUtil.branchNames = branchNames;
  686.         }
  687.  
  688.         public static String[] getAnimalNames() {
  689.                 return animalNames;
  690.         }
  691.  
  692.         public static void setAnimalNames(String[] animalNames) {
  693.                 CalendarUtil.animalNames = animalNames;
  694.         }
  695.  
  696.         public static char[] getChineseMonths() {
  697.                 return chineseMonths;
  698.         }
  699.  
  700.         public static void setChineseMonths(char[] chineseMonths) {
  701.                 CalendarUtil.chineseMonths = chineseMonths;
  702.         }
  703.  
  704.         public static int getBaseYear() {
  705.                 return baseYear;
  706.         }
  707.  
  708.         public static void setBaseYear(int baseYear) {
  709.                 CalendarUtil.baseYear = baseYear;
  710.         }
  711.  
  712.         public static int getBaseMonth() {
  713.                 return baseMonth;
  714.         }
  715.  
  716.         public static void setBaseMonth(int baseMonth) {
  717.                 CalendarUtil.baseMonth = baseMonth;
  718.         }
  719.  
  720.         public static int getBaseDate() {
  721.                 return baseDate;
  722.         }
  723.  
  724.         public static void setBaseDate(int baseDate) {
  725.                 CalendarUtil.baseDate = baseDate;
  726.         }
  727.  
  728.         public static int getBaseIndex() {
  729.                 return baseIndex;
  730.         }
  731.  
  732.         public static void setBaseIndex(int baseIndex) {
  733.                 CalendarUtil.baseIndex = baseIndex;
  734.         }
  735.  
  736.         public static int getBaseChineseYear() {
  737.                 return baseChineseYear;
  738.         }
  739.  
  740.         public static void setBaseChineseYear(int baseChineseYear) {
  741.                 CalendarUtil.baseChineseYear = baseChineseYear;
  742.         }
  743.  
  744.         public static int getBaseChineseMonth() {
  745.                 return baseChineseMonth;
  746.         }
  747.  
  748.         public static void setBaseChineseMonth(int baseChineseMonth) {
  749.                 CalendarUtil.baseChineseMonth = baseChineseMonth;
  750.         }
  751.  
  752.         public static int getBaseChineseDate() {
  753.                 return baseChineseDate;
  754.         }
  755.  
  756.         public static void setBaseChineseDate(int baseChineseDate) {
  757.                 CalendarUtil.baseChineseDate = baseChineseDate;
  758.         }
  759.  
  760.         public static int[] getBigLeapMonthYears() {
  761.                 return bigLeapMonthYears;
  762.         }
  763.  
  764.         public static void setBigLeapMonthYears(int[] bigLeapMonthYears) {
  765.                 CalendarUtil.bigLeapMonthYears = bigLeapMonthYears;
  766.         }
  767.  
  768.         public static char[][] getSectionalTermMap() {
  769.                 return sectionalTermMap;
  770.         }
  771.  
  772.         public static void setSectionalTermMap(char[][] sectionalTermMap) {
  773.                 CalendarUtil.sectionalTermMap = sectionalTermMap;
  774.         }
  775.  
  776.         public static char[][] getSectionalTermYear() {
  777.                 return sectionalTermYear;
  778.         }
  779.  
  780.         public static void setSectionalTermYear(char[][] sectionalTermYear) {
  781.                 CalendarUtil.sectionalTermYear = sectionalTermYear;
  782.         }
  783.  
  784.         public static char[][] getPrincipleTermMap() {
  785.                 return principleTermMap;
  786.         }
  787.  
  788.         public static void setPrincipleTermMap(char[][] principleTermMap) {
  789.                 CalendarUtil.principleTermMap = principleTermMap;
  790.         }
  791.  
  792.         public static char[][] getPrincipleTermYear() {
  793.                 return principleTermYear;
  794.         }
  795.  
  796.         public static void setPrincipleTermYear(char[][] principleTermYear) {
  797.                 CalendarUtil.principleTermYear = principleTermYear;
  798.         }
  799.  
  800.         public static String[] getMonthNames() {
  801.                 return monthNames;
  802.         }
  803.  
  804.         public static void setMonthNames(String[] monthNames) {
  805.                 CalendarUtil.monthNames = monthNames;
  806.         }
  807.  
  808.         public static String[] getChineseMonthNames() {
  809.                 return chineseMonthNames;
  810.         }
  811.  
  812.         public static void setChineseMonthNames(String[] chineseMonthNames) {
  813.                 CalendarUtil.chineseMonthNames = chineseMonthNames;
  814.         }
  815.  
  816.         public static String[] getPrincipleTermNames() {
  817.                 return principleTermNames;
  818.         }
  819.  
  820.         public static void setPrincipleTermNames(String[] principleTermNames) {
  821.                 CalendarUtil.principleTermNames = principleTermNames;
  822.         }
  823.  
  824.         public static String[] getSectionalTermNames() {
  825.                 return sectionalTermNames;
  826.         }
  827.  
  828.         public static void setSectionalTermNames(String[] sectionalTermNames) {
  829.                 CalendarUtil.sectionalTermNames = sectionalTermNames;
  830.         }
  831.  
  832.         public static void main(String[] arg) {
  833.                 CalendarUtil c = new CalendarUtil();
  834.                 String cmd = "day";
  835.                 int y = 2010;
  836.                 int m = 8;
  837.                 int d = 11;
  838.  
  839.                 c.setGregorian(y, m, d);
  840.                 c.computeChineseFields();
  841.                 c.computeSolarTerms();
  842.  
  843.                 if (cmd.equalsIgnoreCase("year")) {
  844.                         String[] t = c.getYearTable();
  845.                         for (int i = 0; i < t.length; i++)
  846.                                 System.out.println(t[i]);
  847.                 } else if (cmd.equalsIgnoreCase("month")) {
  848.                         String[] t = c.getMonthTable();
  849.                         for (int i = 0; i < t.length; i++)
  850.                                 System.out.println(t[i]);
  851.                 } else {
  852.                         System.out.println(c.toString());
  853.                 }
  854.                 System.out.println(c.getDateString());
  855.  
  856.         }
  857.  
  858. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/1017301
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号