Java編寫多功效萬年過程序的實例分享

Java編寫多功效萬年過程序的實例分享。本站提示廣大學習愛好者：（Java編寫多功效萬年過程序的實例分享）文章只能為提供參考，不一定能成為您想要的結果。以下是Java編寫多功效萬年過程序的實例分享正文

 這裡的萬年歷制造重要用到了Calendar類和GregorianCalendar類，我們先往返顧一下基本常識：

基本部門

1、Calendar類。
1，重要字段：
YEAR（年份）、MONTH（月份從0開端）、DATE(一月的某天)、HOUR（指導上午或下晝的小時）、HOUR_F_DAY(指導一天中的小時。)、DAY_OF_WEEK （一個禮拜中的某天）、DAY_OF_MONTH（一個月中的某天）、DAY_OF_YEAR（一年中的某天）、DAY_OF_WEEK _IN_MONTH（一個月中的第幾個禮拜）、WEEK_OF_MONTH  (指導以後月中的禮拜數)、WEEK_OF_YEAR(指導以後年中的禮拜數)
2，得Calendar類對象。

//經由過程 Calendar類的靜態辦法getInstance取得。
Calendar ca = Calendar.getInstance();

3，重要辦法

void set(int field,int value)//field日歷類的參數，好比YEAR MONTH DATE 等...
void set(int year,int month,int date)//設置年代日。
void set(int year, int month, int date, int hourOfDay, int minute)//設置年代日時分
void set(int year, int month, int date, int hourOfDay, int minute, int second)//設置年代日時分秒
void setTime(Date date);//應用給定的 Date 設置此 Calendar 的時光。
 
int get(int field)//前往給定日歷字段的值。如：int month = acobj.get(Calendar.MONTH);
Date getTime()//前往一個表現此 Calendar 時光值的 Date 對象。
long getTimeInMillis()//前往從1970.1.1 00：00：00到該日歷的毫秒數。
 
void add(int field,amont);//依據日歷的規矩，為給定的日歷字段添加或減去指定的時光量。可加減。如：caobj.add(Calendar.MONTH,1)下一個月。

2、GregorianCalendar類。
1,取得該類對象

Calendar ca = new GregorianCalendar()//默許以後的時辰。
Calendar ca = new GregorianCanlendar(int year,int month,int dayOfMonth)//初始具有指定年代日的公歷類對象。
Calendar ca = new GregorianCanlendar(int year,int month,int dayOfMonth,int hourOfDay,int minute)初始具有指定年代日的公歷類對象。
Calendar ca = new GregorianCanlendar(int year,int month,int dayOfMonth,int hourOfDay,int minute,int second)//初始具有指定年代日的公歷類對象。
上邊的都是取得默許的說話情況，和默許的時區 對象。

2，用法
用法重要繼續去父類Calendar。

實例部門
3、萬年歷代碼

package com.via.mce.monthcalendar.utils;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;

/**
 * 陰歷日歷。<br>
 * 將陰歷從1901年到2100年之間各年、月的年夜小和積年骨氣保留，然後基於這些數據停止盤算。<br>
 * <br>
 * 新增了幾個用於陰歷的常量屬性字段，可使用get()辦法獲得日歷對應的值；<br>
 * 陰歷年、月、日還可使用set()/add()/roll()辦法設置，其他陰歷屬性主動盤算；<br>
 * 別的，還供給了getChinese(int field)辦法用於取得陰歷的中文文字（僅實用於陰歷屬性和禮拜）。<br>
 * <ul>
 * <li>CHINESE_YEAR - 陰歷年</li>
 * <li>CHINESE_MONTH - 陰歷月</li>
 * <li>CHINESE_DATE - 陰歷日</li>
 * <li>CHINESE_SECTIONAL_TERM - 當月的骨氣</li>
 * <li>CHINESE_PRINCIPLE_TERM - 當月的中氣</li>
 * <li>CHINESE_HEAVENLY_STEM - 陰歷年的天干</li>
 * <li>CHINESE_EARTHLY_BRANCH - 陰歷年的地支</li>
 * <li>CHINESE_ZODIAC - 陰歷年的屬相</li>
 * <li>CHINESE_TERM_OR_DATE - 假如當天存在一個骨氣則指導骨氣，不然假如當天是初一則指導陰歷月，不然指導陰歷日</li>
 * </ul>
 * 留意：<br>
 * 因為Calendar類的設定，公歷月份從0肇端。一切辦法都遵守了這一商定。<br>
 * 但一切的陰歷屬性從1肇端。即便是在Calendar供給的辦法中，陰歷月也是從1肇端的，並以正數表現閏月。<br>
 * clear()辦法在某些情形下會招致陰歷和公歷日期纰謬應或是不克不及到達預期的重置後果，應盡可能防止應用。<br>
 * 應用getSimpleDateString()取得公歷日期字符串時，公歷月曾經修改；<br>
 * 應用getSimpleChineseDateString()取得陰歷日期字符串時，陰歷閏月以*表現。<br>
 * 
 * @version 0.12 2011-9-5 <br>
 *   <blockquote>修復一個當應用陰歷正月日期初始化日用時墮入逝世輪回的成績。</blockquote>
 * @version 0.11 2009-12-27 <br>
 *   <blockquote>修復了獲得中文陰歷時未盤算陰歷日期的成績；<br>
 *   參加一個字段CHINESE_TERM_OR_DATE用於模擬台歷的顯示方法：假如當天有骨氣則指導骨氣，假如是初一指導陰歷月，
 *   不然指導陰歷日。</blockquote>
 * @version 0.10 2009-12-22
 */
public final class ChineseCalendar extends GregorianCalendar {
 private static final long serialVersionUID = 8L;

 /** 陰歷年 */
 public static final int CHINESE_YEAR = 801;
 /** 陰歷月 */
 public static final int CHINESE_MONTH = 802;
 /** 陰歷日 */
 public static final int CHINESE_DATE = 803;
 /** 當月的骨氣對應的公歷日(前一個骨氣) */
 public static final int CHINESE_SECTIONAL_TERM = 804;
 /** 當月的中氣對應的公歷日(後一個骨氣) */
 public static final int CHINESE_PRINCIPLE_TERM = 805;
 /** 天干 */
 public static final int CHINESE_HEAVENLY_STEM = 806;
 /** 地支 */
 public static final int CHINESE_EARTHLY_BRANCH = 807;
 /** 陰歷年的屬相(生肖) */
 public static final int CHINESE_ZODIAC = 808;
 /** 骨氣或許陰歷日 */
 public static final int CHINESE_TERM_OR_DATE = 888;


 // add by skywang
 /** 陰歷節日 */
 public static final int LUNAR_FESTIVAL = 809;
 /** 陽歷節日 */
 public static final int SOLAR_FESTIVAL = 810;
 /** 骨氣 */
 public static final int CHINESE_TERM = 811;
 /** 月或許陰歷日 */
 public static final int CHINESE_MONTH_OR_DATE = 812;
 /** 節日 或 骨氣 或 陰歷日 */
 public static final int FESTIVAL_OR_TERM_OR_DATE = 813;

 private int chineseYear;
 private int chineseMonth; // 1肇端，正數表現閏月
 private int chineseDate;
 private int sectionalTerm; // 當月骨氣的公歷日
 private int principleTerm; // 當月中氣的公歷日

 private boolean areChineseFieldsComputed; // 陰歷日期能否曾經經由盤算確認
 private boolean areSolarTermsComputed; // 骨氣能否曾經經由盤算確認
 private boolean lastSetChinese; // 最初設置的是否是陰歷屬性

 /** 應用以後時光結構一個實例。 */
 public ChineseCalendar() {
  super();
 }

 /** 應用指准時間結構一個實例。 */
 public ChineseCalendar(Date d) {
  super.setTime(d);
 }

 /** 應用指准時間結構一個實例。 */
 public ChineseCalendar(Calendar c) {
  this(c.getTime());
 }

 /** 應用指定公歷日期結構一個實例。 */
 public ChineseCalendar(int y, int m, int d) {
  super(y, m, d);
 }

 /**
  * 應用指定日期結構一個實例。
  * 
  * @param isChinese
  *   能否為陰歷日期
  * @param y
  * @param m
  * @param d
  */
 public ChineseCalendar(boolean isChinese, int y, int m, int d) {
  if (isChinese) {
   set(CHINESE_YEAR, y);
   set(CHINESE_MONTH, m);
   set(CHINESE_DATE, d);
  } else {
   set(y, m, d);
  }
 }

 public void set(int field, int value) {
  computeIfNeed(field);

  if (isChineseField(field)) {
   // 陰歷屬性
   switch (field) {
   case CHINESE_YEAR:
    chineseYear = value;
    break;
   case CHINESE_MONTH:
    chineseMonth = value;
    break;
   case CHINESE_DATE:
    chineseDate = value;
    break;
   default:
    throw new IllegalArgumentException("不支撐的field設置：" + field);
   }
   lastSetChinese = true;
  } else {
   // 非陰歷屬性
   super.set(field, value);
   lastSetChinese = false;
  }
  areFieldsSet = false;
  areChineseFieldsComputed = false;
  areSolarTermsComputed = false;
 }

 public int get(int field) {
  computeIfNeed(field);

  if (!isChineseField(field)) {
   return super.get(field);
  }

  switch (field) {
  case CHINESE_YEAR:
   return chineseYear;
  case CHINESE_MONTH:
   return chineseMonth;
  case CHINESE_DATE:
   return chineseDate;
  case CHINESE_SECTIONAL_TERM:
   return sectionalTerm;
  case CHINESE_PRINCIPLE_TERM:
   return principleTerm;
  case CHINESE_HEAVENLY_STEM:
   return (chineseYear - 4) % 10 + 1;
  case CHINESE_EARTHLY_BRANCH:
  case CHINESE_ZODIAC:
   return (chineseYear - 4) % 12 + 1;
  case CHINESE_MONTH_OR_DATE: 
   if (get(CHINESE_DATE) == 1) {
    return CHINESE_MONTH;
   } else {
    return CHINESE_DATE;
   }
  case CHINESE_TERM_OR_DATE:
   int option;
   if (get(Calendar.DATE) == get(CHINESE_SECTIONAL_TERM)) {
    option = CHINESE_SECTIONAL_TERM;
   } else if (get(Calendar.DATE) == get(CHINESE_PRINCIPLE_TERM)) {
    option = CHINESE_PRINCIPLE_TERM;
   } else if (get(CHINESE_DATE) == 1) {
    option = CHINESE_MONTH;
   } else {
    option = CHINESE_DATE;
   }
   return option;
  default:
   throw new IllegalArgumentException("不支撐的field獲得：" + field);
  }
 }

 public void add(int field, int amount) {
  computeIfNeed(field);

  if (!isChineseField(field)) {
   super.add(field, amount);
   lastSetChinese = false;
   areChineseFieldsComputed = false;
   areSolarTermsComputed = false;
   return;
  }

  switch (field) {
  case CHINESE_YEAR:
   chineseYear += amount;
   break;
  case CHINESE_MONTH:
   for (int i = 0; i < amount; i++) {
    chineseMonth = nextChineseMonth(chineseYear, chineseMonth);
    if (chineseMonth == 1) {
     chineseYear++;
    }
   }
   break;
  case CHINESE_DATE:
   int maxDate = daysInChineseMonth(chineseYear, chineseMonth);
   for (int i = 0; i < amount; i++) {
    chineseDate++;
    if (chineseDate > maxDate) {
     chineseDate = 1;
     chineseMonth = nextChineseMonth(chineseYear, chineseMonth);
     if (chineseMonth == 1) {
      chineseYear++;
     }
     maxDate = daysInChineseMonth(chineseYear, chineseMonth);
    }
   }
  default:
   throw new IllegalArgumentException("不支撐的field：" + field);
  }

  lastSetChinese = true;
  areFieldsSet = false;
  areChineseFieldsComputed = false;
  areSolarTermsComputed = false;
 }

 public void roll(int field, int amount) {
  computeIfNeed(field);

  if (!isChineseField(field)) {
   super.roll(field, amount);
   lastSetChinese = false;
   areChineseFieldsComputed = false;
   areSolarTermsComputed = false;
   return;
  }

  switch (field) {
  case CHINESE_YEAR:
   chineseYear += amount;
   break;
  case CHINESE_MONTH:
   for (int i = 0; i < amount; i++) {
    chineseMonth = nextChineseMonth(chineseYear, chineseMonth);
   }
   break;
  case CHINESE_DATE:
   int maxDate = daysInChineseMonth(chineseYear, chineseMonth);
   for (int i = 0; i < amount; i++) {
    chineseDate++;
    if (chineseDate > maxDate) {
     chineseDate = 1;
    }
   }
  default:
   throw new IllegalArgumentException("不支撐的field：" + field);
  }

  lastSetChinese = true;
  areFieldsSet = false;
  areChineseFieldsComputed = false;
  areSolarTermsComputed = false;
 }

 /**
  * 取得屬性的中文，可使用的屬性字段為DAY_OF_WEEK和一切陰歷屬性字段。
  * 
  * @param field
  * @return
  */
 public String getChinese(int field) {
  computeIfNeed(field);

  switch (field) {
  case CHINESE_YEAR:
   return getChinese(CHINESE_HEAVENLY_STEM)
     + getChinese(CHINESE_EARTHLY_BRANCH) + "年";
  case CHINESE_MONTH:
   if (chineseMonth > 0)
    return chineseMonthNames[chineseMonth] + "月";
   else
    return "閏" + chineseMonthNames[-chineseMonth] + "月";
  case CHINESE_DATE:
   return chineseDateNames[chineseDate];
  case CHINESE_SECTIONAL_TERM:
   return sectionalTermNames[get(Calendar.MONTH)];
  case CHINESE_PRINCIPLE_TERM:
   return principleTermNames[get(Calendar.MONTH)];
  case CHINESE_HEAVENLY_STEM:
   return stemNames[get(field)];
  case CHINESE_EARTHLY_BRANCH:
   return branchNames[get(field)];
  case CHINESE_ZODIAC:
   return animalNames[get(field)];
  case Calendar.DAY_OF_WEEK:
   return chineseWeekNames[get(field)];
  case CHINESE_TERM_OR_DATE:
   return getChinese(get(CHINESE_TERM_OR_DATE));
  case LUNAR_FESTIVAL:
   return getLunarFestival();
  case SOLAR_FESTIVAL:
   return getSolarFestival();
  case FESTIVAL_OR_TERM_OR_DATE:
   return getFestivalOrTermOrDate();
   // TODO CHECK
  case CHINESE_MONTH_OR_DATE:
   return getChinese(get(CHINESE_MONTH_OR_DATE));
  case CHINESE_TERM:
   return getChineseTerm();
  default:
   throw new IllegalArgumentException("不支撐的field中文獲得：" + field);
  }
 }

 public String getSimpleGregorianDateString() {
  return new StringBuffer().append(get(YEAR)).append("-")
    .append(get(MONTH) + 1).append("-").append(get(DATE))
    .toString();
 }

 public String getSimpleChineseDateString() {
  return new StringBuffer()
    .append(get(CHINESE_YEAR))
    .append("-")
    .append(get(CHINESE_MONTH) > 0 ? "" + get(CHINESE_MONTH) : "*"
      + (-get(CHINESE_MONTH))).append("-")
    .append(get(CHINESE_DATE)).toString();
 }

 public String getChineseDateString() {
  return new StringBuffer().append(getChinese(CHINESE_YEAR))
    .append(getChinese(CHINESE_MONTH))
    .append(getChinese(CHINESE_DATE)).toString();
 }

 public String toString() {
  StringBuffer buf = new StringBuffer();
  buf.append(getSimpleGregorianDateString()).append(" | ")
    .append(getChinese(DAY_OF_WEEK)).append(" | [陰歷]")
    .append(getChineseDateString()).append(" ")
    .append(getChinese(CHINESE_ZODIAC)).append("年 ")
    .append(get(CHINESE_SECTIONAL_TERM)).append("日")
    .append(getChinese(CHINESE_SECTIONAL_TERM)).append(" ")
    .append(get(CHINESE_PRINCIPLE_TERM)).append("日")
    .append(getChinese(CHINESE_PRINCIPLE_TERM));
  return buf.toString();
 }

 /**
  * 斷定是否是陰歷屬性
  * 
  * @param field
  * @return
  */
 private boolean isChineseField(int field) {
  switch (field) {
  case CHINESE_YEAR:
  case CHINESE_MONTH:
  case CHINESE_DATE:
  case CHINESE_SECTIONAL_TERM:
  case CHINESE_PRINCIPLE_TERM:
  case CHINESE_HEAVENLY_STEM:
  case CHINESE_EARTHLY_BRANCH:
  case CHINESE_ZODIAC:
  case CHINESE_TERM_OR_DATE:
  case CHINESE_MONTH_OR_DATE:
   return true;
  default:
   return false;
  }
 }

 /**
  * 斷定是否是與骨氣有關的屬性
  * 
  * @param field
  * @return
  */
 private boolean isChineseTermsField(int field) {
  switch (field) {
  case CHINESE_SECTIONAL_TERM:
  case CHINESE_PRINCIPLE_TERM:
  case CHINESE_TERM_OR_DATE:
   return true;
  default:
   return false;
  }
 }

 /**
  * 假如上一次設置的與此次將要設置或獲得的屬性不是統一類（陰歷/公歷），<br>
  * 例如上一次設置的是陰歷而如今要設置或獲得公歷，<br>
  * 則須要先依據之前設置的陰歷日期盤算出公歷日期。
  * 
  * @param field
  */
 private void computeIfNeed(int field) {
  if (isChineseField(field)) {
   if (!lastSetChinese && !areChineseFieldsComputed) {
    super.complete();
    computeChineseFields();
    areFieldsSet = true;
    areChineseFieldsComputed = true;
    areSolarTermsComputed = false;
   }
   if (isChineseTermsField(field) && !areSolarTermsComputed) {
    computeSolarTerms();
    areSolarTermsComputed = true;
   }
  } else {
   if (lastSetChinese && !areFieldsSet) {
    computeGregorianFields();
    super.complete();
    areFieldsSet = true;
    areChineseFieldsComputed = true;
    areSolarTermsComputed = false;
   }
  }
 }

 /**
  * 應用陰歷日期盤算出公歷日期
  */
 private void computeGregorianFields() {
  int y = chineseYear;
  int m = chineseMonth;
  int d = chineseDate;
  areChineseFieldsComputed = true;
  areFieldsSet = true;
  lastSetChinese = false;

  // 調劑日期規模
  if (y < 1900)
   y = 1899;
  else if (y > 2100)
   y = 2101;

  if (m < -12)
   m = -12;
  else if (m > 12)
   m = 12;

  if (d < 1)
   d = 1;
  else if (d > 30)
   d = 30;

  int dateint = y * 10000 + Math.abs(m) * 100 + d;
  if (dateint < 19001111) { // 太小
   set(1901, Calendar.JANUARY, 1);
   super.complete();
  } else if (dateint > 21001201) { // 太年夜
   set(2100, Calendar.DECEMBER, 31);
   super.complete();
  } else {
   if (Math.abs(m) > 12) {
    m = 12;
   }
   int days = ChineseCalendar.daysInChineseMonth(y, m);
   if (days == 0) {
    m = -m;
    days = ChineseCalendar.daysInChineseMonth(y, m);
   }
   if (d > days) {
    d = days;
   }
   set(y, Math.abs(m) - 1, d);
   computeChineseFields();

   int amount = 0;
   while (chineseYear != y || chineseMonth != m) {
    amount += daysInChineseMonth(chineseYear, chineseMonth);
    chineseMonth = nextChineseMonth(chineseYear, chineseMonth);
    if (chineseMonth == 1) {
     chineseYear++;
    }
   }
   amount += d - chineseDate;

   super.add(Calendar.DATE, amount);
  }
  computeChineseFields();
 }

 /**
  * 應用公歷日期盤算出陰歷日期
  */
 private void computeChineseFields() {
  int gregorianYear = internalGet(Calendar.YEAR);
  int gregorianMonth = internalGet(Calendar.MONTH) + 1;
  int gregorianDate = internalGet(Calendar.DATE);

  if (gregorianYear < 1901 || gregorianYear > 2100) {
   return;
  }

  int startYear, startMonth, startDate;
  if (gregorianYear < 2000) {
   startYear = baseYear;
   startMonth = baseMonth;
   startDate = baseDate;
   chineseYear = baseChineseYear;
   chineseMonth = baseChineseMonth;
   chineseDate = baseChineseDate;
  } else {
   // 第二個對應日，用以進步盤算效力
   // 公歷 2000 年 1 月 1 日，對應陰歷 4697(1999) 年 11 月 25 日
   startYear = baseYear + 99;
   startMonth = 1;
   startDate = 1;
   chineseYear = baseChineseYear + 99;
   chineseMonth = 11;
   chineseDate = 25;
  }

  int daysDiff = 0;

  // 年
  for (int i = startYear; i < gregorianYear; i++) {
   if (isGregorianLeapYear(i)) {
    daysDiff += 366; // leap year
   } else {
    daysDiff += 365;
   }
  }

  // 月
  for (int i = startMonth; i < gregorianMonth; i++) {
   daysDiff += daysInGregorianMonth(gregorianYear, i - 1);
  }

  // 日
  daysDiff += gregorianDate - startDate;

  chineseDate += daysDiff;

  int lastDate = daysInChineseMonth(chineseYear, chineseMonth);
  while (chineseDate > lastDate) {
   chineseDate -= lastDate;
   chineseMonth = nextChineseMonth(chineseYear, chineseMonth);
   if (chineseMonth == 1) {
    chineseYear++;
   }
   lastDate = daysInChineseMonth(chineseYear, chineseMonth);
  }

 }

 /**
  * 盤算骨氣
  */
 private void computeSolarTerms() {
  int gregorianYear = internalGet(Calendar.YEAR);
  int gregorianMonth = internalGet(Calendar.MONTH);

  if (gregorianYear < 1901 || gregorianYear > 2100) {
   return;
  }
  sectionalTerm = sectionalTerm(gregorianYear, gregorianMonth);
  principleTerm = principleTerm(gregorianYear, gregorianMonth);
 }

 /* 接上去是靜態辦法~ */
 /**
  * 能否為公歷閏年
  * 
  * @param year
  * @return
  */
 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;
 }

 /**
  * 盤算公積年確當月天數，公歷月從0肇端！
  * 
  * @param y
  * @param m
  * @return
  */
 public static int daysInGregorianMonth(int y, int m) {
  int d = daysInGregorianMonth[m];
  if (m == Calendar.FEBRUARY && isGregorianLeapYear(y)) {
   d++; // 公歷閏年二月多一天
  }
  return d;
 }

 /**
  * 盤算公積年當月的骨氣，公歷月從0肇端！
  * 
  * @param y
  * @param m
  * @return
  */
 public static int sectionalTerm(int y, int m) {
  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;
 }

 /**
  * 盤算公積年當月的中氣，公歷月從0肇端！
  * 
  * @param y
  * @param m
  * @return
  */
 public static int principleTerm(int y, int m) {
  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;
 }

 /**
  * 盤算陰歷年的天數
  * 
  * @param y
  * @param m
  * @return
  */
 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;
 }

 /**
  * 盤算陰歷的下個月
  * 
  * @param y
  * @param m
  * @return
  */
 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 final int baseYear = 1901;
 private static final int baseMonth = 1;
 private static final int baseDate = 1;
 private static final int baseIndex = 0;
 private static final int baseChineseYear = 1900;
 private static final int baseChineseMonth = 11;
 private static final int baseChineseDate = 11;

 /* 中文字符串 */
 private static final String[] chineseWeekNames = { "", "禮拜日", "禮拜一", "禮拜二",
   "禮拜三", "禮拜四", "禮拜五", "禮拜六" };
 private static final String[] chineseMonthNames = { "", "正", "二", "三", "四",
   "五", "六", "七", "八", "九", "十", "十一", "十二" };
 private static final String[] chineseDateNames = { "", "初一", "初二", "初三",
   "初四", "初五", "初六", "初七", "初八", "初九", "初十", "十一", "十二", "十三", "十四",
   "十五", "十六", "十七", "十八", "十九", "二十", "廿一", "廿二", "廿三", "廿四", "廿五",
   "廿六", "廿七", "廿八", "廿九", "三十" };
 private static final String[] principleTermNames = { "年夜寒", "雨水", "春分",
   "谷雨", "夏滿", "夏至", "年夜暑", "處暑", "秋分", "霜降", "小雪", "冬至" };
 private static final String[] sectionalTermNames = { "小寒", "立春", "驚蟄",
   "清明", "立夏", "芒種", "小暑", "立秋", "白露", "寒露", "立冬", "年夜雪" };
 private static final String[] stemNames = { "", "甲", "乙", "丙", "丁", "戊",
   "己", "庚", "辛", "壬", "癸" };
 private static final String[] branchNames = { "", "子", "丑", "寅", "卯", "辰",
   "巳", "午", "未", "申", "酉", "戌", "亥" };
 private static final String[] animalNames = { "", "鼠", "牛", "虎", "兔", "龍",
   "蛇", "馬", "羊", "猴", "雞", "狗", "豬" };

 /* 接上去是數據緊縮表~ */
 private static final int[] bigLeapMonthYears = { 6, 14, 19, 25, 33, 36, 38,
   41, 44, 52, 55, 79, 117, 136, 147, 150, 155, 158, 185, 193 };
 private static final 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 final 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 final 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 final 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 } };

 private static final char[] daysInGregorianMonth = { 31, 28, 31, 30, 31,
   30, 31, 31, 30, 31, 30, 31 };
 private static final 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 };

 private String getChineseTerm() {
  if (get(Calendar.DATE) == get(CHINESE_SECTIONAL_TERM)) {
   return sectionalTermNames[get(Calendar.MONTH)];
  } else if (get(Calendar.DATE) == get(CHINESE_PRINCIPLE_TERM)) {
   return principleTermNames[get(Calendar.MONTH)];
  } else
   return null;
 }
 // add by skywang
 private String getLunarFestival() {
  int day = get(CHINESE_DATE);
  int month = get(CHINESE_MONTH);
  String sToday = day < 10 ? "0" + day:"" + day; 
  String sMonth = month<10 ? "0" +(month):""+(month);

  return lFestival.get(sMonth+sToday);  
 }
 private String getSolarFestival() {
  int day = get(Calendar.DATE); 
  int month = get(Calendar.MONTH); 
  String sToday = day < 10 ? "0" + day:"" + day; 
  String sMonth = month<10 ? "0" +(month+1):""+(month+1);

  return sFestival.get(sMonth+sToday);
 }
 private String getFestivalOrTermOrDate() {
  String ret;
  if ((ret = getSolarFestival()) != null)
   return ret;
  if ((ret = getLunarFestival()) != null)
   return ret;  
  return getChinese(get(CHINESE_TERM_OR_DATE));
 }


 //公歷節日
 private static HashMap<String,String> sFestival =new HashMap<String,String>();
 // 陰歷參與
 private static HashMap<String,String> lFestival =new HashMap<String,String>(); 
 static {
  sFestival.put("0101","除夕"); 
  sFestival.put("0214","戀人節"); 
  sFestival.put("0308","婦女節"); 
  sFestival.put("0312","植樹節"); 
  sFestival.put("0401","哲人節"); 
  sFestival.put("0501","休息節"); 
  sFestival.put("0504","青年節"); 
  sFestival.put("0601","兒童節"); 
  sFestival.put("0701","建黨節"); 
  sFestival.put("0801","建軍節"); 
  sFestival.put("0910","教員節"); 
  sFestival.put("1001","國慶節"); 
  sFestival.put("1031","萬聖節"); 
//  sFestival.put("1112","孫中山生日"); 
  sFestival.put("1225","聖誕節");  

  lFestival.put("0101","春節"); 
//  lFestival.put("0102","年夜歲首年月二"); 
//  lFestival.put("0103","年夜歲首年月三"); 
  lFestival.put("0115","元宵節"); 
  lFestival.put("0505","端五節"); 
  lFestival.put("0707","七夕");
  lFestival.put("0815","中秋節"); 
  lFestival.put("0909","重陽節"); 
  lFestival.put("1208","臘八節"); 
//  lFestival.put("1299","大年節");
 } 
}