La producción de calendario perpetuo aquí utiliza principalmente la clase de calendario y la clase Gregoriancalendar. Primero revisemos los conceptos básicos:
Partes básicas
1. Clase de calendario.
1. Campos principales:
Año (año), mes (mes comienza desde 0), fecha (día de enero), hora (indica la hora de la mañana o de la tarde), Hour_f_day (indica la hora en el día), Day_of_week (indica el número de semanas en la semana), Day_of_month (indica el número de semanas en el año), Day_year (indica el número de semanas en la semana en el día), Day_Of_Of_week_ Número de semanas en el mes), Week_of_year (indica el número de semanas en el año)
2. Obtenga objeto de clase de calendario.
// atraviesa el método estático GetInstance de la clase de calendario. Calendario CA = calendario.getInstance ();
3. Métodos principales
set void (int field, int value) // Los parámetros de la clase de calendario de campo, como la fecha del mes de año, etc .... void set (int año, int mes, int fecha) // establecido año, mes y día. Set Void Set (int Year, Int Month, int Fecha, int Hourofday, int int get (int campo) // Devuelve el valor del campo calendario dado. Por ejemplo: int mes = acobj.get (calendar.month); fecha gettime () // Devuelve un objeto de fecha que representa el valor de tiempo del calendario. Long getTimeInmillis () // Devuelve el número de milisegundos desde 1970.1.1 00:00:00 al calendario. nulo add (int campo, amont); // de acuerdo con las reglas del calendario, agregue o reste la cantidad de tiempo especificada para un campo calendario determinado. Se puede agregar o restarse. Por ejemplo: Caobj.add (calendario. Month, 1) el próximo mes.
2. Clase Gregoriancalendar.
1. Obtenga este objeto de clase
Calendario CA = nuevo Gregoriancalendar () // Momento de corriente predeterminado. Calendario CA = Nuevo Gregoriancanlendar (intane, int mes, int dayofmonth) // Inicialmente, el objeto de clase Gregorian con un año, mes y día especificados. Calendario CA = Nuevo Gregoriancanlendar (Inten Year, Int Month, int Dayofmonth, int Hourofday, int mind) El objeto de clase Gregorian inicialmente tiene un año, mes y día específico. Calendario CA = nuevo Gregoriancanlendar (intane, int mes, int dayofmonth, int Hourofday, int mind, int segundo) // Inicialmente, el objeto de clase Gregorian con un año, mes y día especificados. Los anteriores se obtienen al obtener la configuración regional predeterminada y los objetos de zona horaria predeterminadas.
2. El uso de uso hereda principalmente el calendario de la clase principal.
Sección de ejemplo
3. Código de calendario perpetuo
paquete com.via.mce.monthcalendar.utils; import java.util.calendar; import java.util.date; import java.util.gregoriancalendar; import java.util.hashmap;/*** lunar calendar. <br> * Guarde el tamaño del año, mes y términos solares anteriores entre 1901 y 2100 del calendario lunar, y luego calcule en función de estos datos. <br> * <br> * Se han agregado varios campos de atributos constantes para el calendario lunar, y puede usar el método get () para obtener el valor correspondiente del calendario; <br> * año calendario, mes y día lunar también se puede configurar utilizando el método set ()/add ()/roll (), y otros atributos del calendario lunar se calculan automáticamente; <br> * Además, el método GetChinese (int Field) también se proporciona para obtener el texto chino del calendario lunar (solo aplicable a los atributos del calendario lunar y la semana). <br> * <ul> * <li> chino_year - año lunar </li> * <li> chino_month - mes lunar </li> * <li> chino_date - día lunar </li> * <li> chino_sectional_term - términos solares del mes </li> * * <li> chino_principle_term - Central Qi del mes </li> * * * li> Tallos del año lunar </li> * <li> chino_earthly_branch - ramas terrenales del año lunar </li> * * <li> chino_zodiac - zodiaco del año lunar </li> * <li> chino_ter_or_date - si hay un término solar en el día, indica el término solar. De lo contrario, si el día es el primer día del día, indica el mes lunar, de lo contrario indica el día lunar. * </ul> * Nota: <br> * Debido a la configuración de la clase de calendario, el mes gregoriano comienza a partir de 0. Todos los métodos siguen esta convención. <br> * Pero todos los atributos lunares comienzan desde 1. Incluso en el método proporcionado por el calendario, el mes lunar comienza con 1 y representa el mes salto con un número negativo. <br> * El método Clear () hará que el calendario lunar y las fechas del calendario gregoriano sean inconsistentes o no se puede lograr el efecto de reinicio esperado. Debe evitarse tanto como sea posible. <br> * Cuando se usa GetSimpledateString () para obtener la cadena de fecha del calendario gregoriano, el mes del calendario gregoriano se ha corregido; <br> * Cuando se usa GetSimpLechinesEdateString () para obtener la cadena de fecha del calendario lunar, el mes de lunar lunar está representado por *. <br> * * @Version 0.12 2011-9-5 <br> * <ClockQuote> Se solucionó un problema en el que el calendario estaba atrapado en un ciclo muerto al inicializar el calendario utilizando el primer mes del calendario lunar. </loCLOQUETE> * @VERSION 0.11 2009-12-27 <br> * <LockQuote> Se corrigió el problema donde el calendario lunar no se calculó al obtener el calendario lunar chino; <br> * Agregue un campo chino_term_or_date para imitar el método de visualización del calendario de escritorio: si hay un término solar ese día, indica el término solar, si es el primer día del mes lunar, * de lo contrario indica el día lunar. </blockquote> * @Version 0.10 2009-12-22 */public Final Class Chinesecalendar extiende Gregoriancalendar {Private Static Final Long SerialVersionUid = 8l; / ** Año lunar*/ Public Static Final int chino_year = 801; / ** Mes lunar*/ Public Static Final int chino_month = 802; / ** Día lunar*/ Public Static Final int chino_date = 803; / ** Día gregoriano correspondiente al término solar del mes (el término solar anterior)*/ public static final int chino_sectional_term = 804; / ** Día gregoriano correspondiente al término solar del mes (el próximo término solar)*/ public static final int chino_principle_term = 805; / ** Tallos celestiales*/ Public Static Final int chino_heavenly_stem = 806; / ** Ramas terrenales*/ Public Static Final int chino_earthly_branch = 807; / ** Signos del zodiaco (signos del zodiaco)*/ public static final int chehin_zodiac = 808; / ** Término solar o día lunar*/ Public Static Final Int Chine_term_or_date = 888; // Agregar por Skywang/ ** Lunar Festival*/ public static final int lunar_festival = 809; / ** término solar*/ public static final int solar_festival = 810; / ** Término solar*/ Public Static Final int chino_term = 811; / ** mes o día lunar*/ public static final int chehen_month_or_date = 812; / ** festival o término solar o día lunar*/ public static final int festival_or_term_or_date = 813; privado int chenyear; privado int chinesemonth; // Comience con 1, los números negativos representan un mes de salto privado int chinesedate; privado intesctre de int; // Día Gregoriano Private Int Principleterm; // Día Gregoriano Los booleanos privados son chinos con la civajes. // si la fecha lunar ha sido calculada y confirmada que los aresolarters boolean privados computan; // si el término solar ha sido calculado y confirmado el booleano privado dastsetchinese; // es la última configuración del atributo lunar/** construir una instancia utilizando la hora actual. */ public chinesecalendar () {super (); } /** Construya una instancia utilizando el tiempo especificado. */ public chinesecalendar (fecha d) {super.settime (d); } /** Construya una instancia utilizando el tiempo especificado. */ public chinesecalendar (calendario c) {this (c.gettime ()); } /** Construya una instancia utilizando la fecha gregoriana especificada. */ public chinesecalendar (int y, int m, int d) {super (y, m, d); } /*** Construya una instancia con la fecha especificada. * * @param ischinese * ¿Es la fecha lunar * @param y * @param m * @param d */ public chinesecalendar (boolean ischinese, int y, int m, int d) {if (ischinese) {set (chino_year, y); set (chino_month, m); set (chino_date, d); } else {set (y, m, d); }} public void set (int campo, int value) {computeifNeed (campo); if (ischinesefield (campo)) {// interruptor de atributo de calendario lunar (campo) {case chino_year: chinoyear = valor; romper; Caso chino_month: chinesemonth = valor; romper; Caso chino_date: chinesedate = valor; romper; Valor predeterminado: arroje nuevo IllegalArgumentException ("Configuración de campo no compatible:" + campo); } dastSetchInese = true; } else {// atributo calendario no lunar super.set (campo, valor); dastsetchinese = false; } arfieldsset = false; arechineseFieldsComputed = false; aresolartermsComputed = false; } public int get (int campo) {computeifNeed (campo); if (! IschineseField (Field)) {return super.get (campo); } switch (campo) {case chino_year: return chinoyear; Caso chino_month: return chinesemonth; Caso chino_date: return chinesedate; Caso chino_sectional_term: return sectalterm; Caso chino_principle_term: return principalTleterm; Caso chino_heavenly_stem: return (chinoyear - 4) % 10 + 1; Caso chino_earthly_branch: case chino_zodiac: return (chinoyear - 4) % 12 + 1; Caso chino_month_or_date: if (get (chino_date) == 1) {return chino_month; } else {return chino_date; } case chino_term_or_date: int option; if (get (calendar.date) == get (chino_sectional_term)) {opción = chino_sectional_term; } else if (get (calendar.date) == get (chino_principle_term)) {opción = chino_principle_term; } else if (get (chino_date) == 1) {opción = chino_month; } else {opción = chino_date; } Opción de retorno; predeterminado: tirar nueva ilegalargumentException ("campo no compatible get:" + campo); }} public void add (int field, int if (! IschineseField (Field)) {super.Add (campo, cantidad); dastsetchinese = false; arechineseFieldsComputed = false; aresolartermsComputed = false; devolver; } switch (campo) {case chino_year: chinoyear += cantidad; romper; Caso chino_month: para (int i = 0; i <cantidad; i ++) {chinesemonth = nextChinesemonth (chinoyear, chinesemonherh); if (chinesemonth == 1) {chinoyear ++; } } romper; Caso chino_date: int maxDate = daysinchinesemonth (chinoyear, chinesemonth); para (int i = 0; i <cantidad; i ++) {chinesedate ++; if (chinesedate> maxDate) {chinesedate = 1; chinesemonth = nextChinesemonth (chinoyear, chinesemonemh); if (chinesemonth == 1) {chinoyear ++; } maxDate = daysinchinesemonth (chinoyear, chinesemonth); }} predeterminado: tirar nueva ilegalArgumentException ("Campo no compatible:" + campo); } dastSetchInese = true; arefieldsset = false; arechineseFieldsComputed = false; aresolartermsComputed = false; } public void roll (int campo, intert) {computeIfNeed (campo); if (! IschineseField (Field)) {super.roll (campo, cantidad); dastsetchinese = false; arechineseFieldsComputed = false; aresolartermsComputed = false; devolver; } switch (campo) {case chino_year: chinoyear += cantidad; romper; Caso chino_month: para (int i = 0; i <cantidad; i ++) {chinesemonth = nextChinesemonth (chinoyear, chinesemonherh); } romper; Caso chino_date: int maxDate = daysinchinesemonth (chinoyear, chinesemonth); para (int i = 0; i <cantidad; i ++) {chinesedate ++; if (chinesedate> maxDate) {chinesedate = 1; }} predeterminado: tirar nueva ilegalArgumentException ("Campo no compatible:" + campo); } dastSetchInese = true; arefieldsset = false; arechineseFieldsComputed = false; aresolartermsComputed = false; } /*** Obtenga el idioma chino del atributo, los campos de atributos que se pueden usar son Day_of_Week y todos los campos de atributos lunares. * * @param campo * @return */ public string getChinese (int campo) {computeifNeed (campo); switch (campo) {case chino_year: return getChinese (chino_heavenly_stem) + getChinese (chino_earthly_branch) + "año"; Caso chino_month: if (chinesemonth> 0) return chinesemonthnames [chinesemonher] + "mes"; else return "salto" + chinesemonthnames [-chinesemonherh] + "mes"; case chino_date: return chinesedateNames [chinesedate]; case chino_sectional_term: return sectionterMnames [get (calendar.month)]; Caso chino_principle_term: return principalLetermnames [get (calendar.month)]; case chino_heavenly_stem: return Stemnames [get (campo)]; case chino_earthly_branch: return branchnames [get (campo)]; case chino_zodiac: return animalnames [get (campo)]; case calendar.day_of_week: return chinoweekames [get (campo)]; Caso chino_term_or_date: return getChinese (get (chino_term_or_date)); case lunar_festival: return getLunarfestival (); case solar_festival: return getSolarfestival (); case festival_or_term_or_date: return getFestivalOrterMordate (); // TODO CHECK CASE chino_month_or_date: return getChinese (get (chino_month_or_date)); case chino_term: return getChineseterm (); Valor predeterminado: arroje nuevo IllegalArgumentException ("Campo no compatible chino Get:" + Field); }} cadena pública getSimplegregorInDateString () {return new StringBuffer (). Append (get (año)). Append ("-") .Append (get (mes) + 1) .Append ("-"). Append (get (fecha)) .ToString (); } public String getSimpLechinesEdateString () {return new StringBuffer () .Append (get (chino_year)) .Append ("-") .Append (get (chino_month)> 0? "" + get (chino_month): "*" + (-get (chino_month))). apertifica ("-") .append (get (get (chino)). toString (). } public String getChinesedateString () {return new StringBuffer (). Append (getChinese (chino_year)) .append (getChinese (chino_month) .append (getChinese (chino_date)). toString (); } public string toString () {StringBuffer buf = new StringBuffer (); buf.append (getSimplegregorInDateString ()). append ("|") .Append (getChinese (day_of_week)). append ("| [calendario lunar]") .Append (getChinesedateString ()). Append ("") .Append (getChinese (chino_zodiac)). Append ("año") .Append (get (chino_sectional_term)). append ("día") .append (getChinese (chino_sectional_term)). append ("") .append (get (chino_principle_term)). append ("día") .append (getchinese (chino_principle_term)); return buf.ToString (); } / ** * Determine si es un atributo lunar * * * @param campo * @return * / private boolean ischinesefield (int campo) {switch (campo) {case chino_year: case chino_month: case chino_date: case chino_sectional_term: chein_principle_term: case_heAvenly_Em Chino_term_or_date: case chino_month_or_date: return true; predeterminado: return false; }} / ** * Determine si es un atributo relacionado con el término solar * * @param campo * @return * / private boolean ischinesetermsfield (int campo) {switch (campo) {case chino_sectional_term: case chino_principle_term: case chino_ter_or_date: return true; predeterminado: return false; } } /** * If the attributes that were set last time are not the same as the ones to be set or obtained this time (lunar calendar/gregorian calendar), <br> * For example, the last time I set it was the lunar calendar and now I want to set or obtain the Gregorian calendar, <br> * You need to calculate the Gregorian calendar date based on the previously set lunar calendar fecha. * * @param campo */ private void computeifNeed (int field) {if (ischinesefield (campo)) {if (! dastsetchinese &&! arechinesefieldscomputed) {super.complete (); CompuTechineseFields (); arefieldsset = true; ArechineseFieldsComputed = True; aresolartermsComputed = false; } if (isChinesetermsfield (campo) &&! AesolartermsComputed) {ComponeSolarterms (); aresolartermsComputed = true; }} else {if (dastSetchInese &&! arfieldsset) {ComputeGregorianFields (); super.complete (); arefieldsset = true; ArechineseFieldsComputed = True; aresolartermsComputed = false; }}} / *** Use la fecha lunar para calcular el Gregoriandate* / private void ComputeGregorianFields () {int y = chinoyear; int m = chinesemonth; int d = chinesedate; ArechineseFieldsComputed = True; arefieldsset = true; dastsetchinese = false; // ajustar el rango de fechas si (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) {// Too Small Set (1901, Calendar. enero, 1); super.complete (); } else if (dateInt> 21001201) {// SET demasiado grande (2100, calendar.december, 31); super.complete (); } else {if (math.abs (m)> 12) {m = 12; } int days = chinesecalendar.daysinchinesemonemherh (y, m); if (días == 0) {m = -m; Días = chinesecalendar.daysinchinesemonemh (y, m); } if (d> días) {d = días; } set (y, math.abs (m) - 1, d); CompuTechineseFields (); int la cantidad = 0; while (cheanyear! = y || chinesemonth! = m) {cantidad += daysinchinesemonth (chinoyear, chinesemonth); chinesemonth = nextChinesemonth (chinoyear, chinesemonemh); if (chinesemonth == 1) {chinoyear ++; }} cantidad += d - chinesedate; super.add (calendario.date, cantidad); } CompuTechineseFields (); } / *** Calcule la fecha del calendario lunar usando la fecha de Gregorian* / private void ComputechineseFields () {int gregorianyear = internalget (calendar.year); int gregorianmonth = internalget (calendario.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 = basado; Chineseyear = Basechineseyear; chinesemonth = basechinesemonth; chinesedate = basecinesedate; } else {// El segundo día correspondiente se usa para mejorar la eficiencia informática // 1 de enero de 2000, el calendario lunar correspondiente 4697 (1999), Startyear = Baseyear + 99; startmonth = 1; startDate = 1; Chineseyear = BasechinesSeyear + 99; chinesemonth = 11; chinesedate = 25; } int daysdiff = 0; // año para (int i = startyear; i <gregorianyear; i ++) {if (isGregorianLeapYear (i)) {daysdiff+= 366; // salto año} else {daysdiff += 365; }} // mes para (int i = startmonth; i <gregorianmonth; i ++) {daysdiff+= daysingregorianmonth (gregorianyear, i - 1); } // daydaysdiff += gregoriandate - startDate; chinesedate += daysdiff; int LastDate = DaysinChinesemonth (chinoyear, chinesemonherh); while (chinesedate> lastDate) {chinesedate -= lastdate; chinesemonth = nextChinesemonth (chinoyear, chinesemonemh); if (chinesemonth == 1) {chinoyear ++; } lastDate = daysinchinesemonth (chinoyear, chinesemonth); }} / *** Calcule los términos solar* / private void complenteSolarters () {int gregorianyear = internalget (calendar.year); int gregorianmonth = internalget (calendario.month); if (gregorianyear <1901 || gregorianyear> 2100) {return; } sectAlterm = sectAlterm (Gregorianyear, Gregorianmonth); Principleterm = Principalterm (Gregorianyear, Gregorianmonth); } / * Siguiente es el método estático ~ * / / ** * ¿Es un año bisiesto en el año gregoriano * * @param año * @return * / public static boolean isgregorianLeapyear (intane) {boolean isleap = false; if (año % 4 == 0) {isleap = true; } if (año % 100 == 0) {isleap = false; } if (año % 400 == 0) {isleap = true; } return isleap; } /*** Calcule el número de días en el año gregoriano, ¡y el mes gregoriano comienza a partir de 0! * * @param y * @param m * @return */ public static int daysingregorianmonth (int y, int m) {int d = daysingregerianmonth [m]; if (m == calendar.february && isgregorianLeapyear (y)) {d ++; // un día más en un año bisiesto en el año gregoriano} regreso D; } /*** Calcule los términos solares del mes gregoriano, ¡el mes gregoriano comienza a partir de 0! * * @param y * @param m * @return */ public static int sectalterm (int y, int m) {m ++; if (y <1901 || y> 2100) {return 0; } int index = 0; int ry = y - Baseyear + 1; while (ry> = sectalTermyear [m - 1] [index]) {index ++; } int Term = SectalTermMap [m - 1] [4 * índice + ry % 4]; if ((ry == 121) && (m == 4)) {Term = 5; } if ((ry == 132) && (m == 4)) {Term = 5; } if ((ry == 194) && (m == 6)) {Term = 6; } término de retorno; } /*** Calcule el zhongqi del año gregoriano, ¡y el mes gregoriano comienza a partir de 0! * * @param y * @param m * @return */ public static int principyleterm (int y, int m) {m ++; if (y <1901 || y> 2100) {return 0; } int index = 0; int ry = y - Baseyear + 1; while (ry> = principyletermyear [m - 1] [index]) {index ++; } int Term = PrincipalMapMap [m - 1] [4 * índice + ry % 4]; if ((ry == 171) && (m == 3)) {Term = 21; } if ((ry == 181) && (m == 5)) {Term = 21; } término de retorno; } / ** * Calcule el número de días en el año lunar * * @param y * @param m * @return * / public static int daysInchinesemonTh (int y, int m) {// nota: mes salto m <0 int index = y - basecinesSeyear + 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) y 0x01) == 1) {d = 29; }} else if (9 <= m && m <= 12) {v = chinesemonths [2 * índice + 1]; l = m - 9; if (((v >> l) y 0x01) == 1) {d = 29; }} else {v = chinesemonths [2 * índice + 1]; v = (v >> 4) y 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; romper; }}}} return d; } / ** * Calcule el próximo mes del calendario lunar * * @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 * índice + 1]; v = (v >> 4) y 0x0f; if (v == m) {n = -m; }} if (n == 13) {n = 1; } return n; } /* Fecha del primer día del calendario* / privado estático final int baseyear = 1901; Private static final int basemonth = 1; Private static final int basado = 1; Private static final int baseindex = 0; Private estático final int BASECHINESEYEAR = 1900; Private estático final int BASECHINESEMONTH = 11; Private estático final int basechinesedate = 11; /* Cadena china*/ static final static final [] chinoweeknames = {"", "domingo", "lunes", "martes", "jueves", "viernes", "sábado"}; cadena final estática privada [] chinesemonThnames = {"", "primero", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve", "diez", "diez", "once", "twelve"}; cadena final estática privada [] chinesedataNames = {"", "primero", "primero", "cuarto", "cinco", "sexto", "séptimo", "octavo", "nueve", "nueve", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "", "", "", "" d. "Décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo"}; Cadena final estática privada [] PrincipletermNames = {"Great Cold", "Rain Water", "Spring Equinox", "Green Rain", "Summer Solar", "Green Summer", "Green Summer", "Verde Summer", "Verde Summer", "Summer Solar", "Green Summer", "Starry Equinox", "Equinox de septiembre", "Free Fall", "Light Snow", "Solste de verano". cadena final estática privada [] sectionterMnames = {"Little Cold", "Bird Spring", "Jingzhe", "Qingming", "Comienzo del verano", "semillas de grano", "Little Heat", "Bird Autumn", "White Dew", "Cold Dew", "Breaking Winter", "High Snow"}; cadena final estática privada [] stemnames = {"", "jia", "yi", "bing", "ding", "wu", "ji", "geng", "xin", "ren", "gui"}; cadena final estática privada [] branchnames = {"", "zi", "ug", "yin", "mao", "chen", "si", "wu", "shen", "you", "xu", "hai"}; cadena final estática privada [] animalNames = {"", "rata", "buey", "tigre", "conejo", "dragón", "serpiente", "caballo", "oveja", "mono", "pollo", "perro", "cerdo"}; / * Siguiente es la tabla de compresión de datos ~ */ private estática 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 }, { 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, 200, 250}, {17, 53, 85, 124, 156, 188, 200, 200, 200, 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, 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, 200, 200, 92, 60, 60, 60, 60, 60, 92, 92, 92, 92, 92, 92, 92, 92, 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 [] DayingRregorianmonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31}; private static final char[] chineseMonths = { 0x00, 0x04, 0xad, 0x08, 0x5a, 0x01, 0xd5, 0x54, 0xb4, 0x09, 0x64, 0x05, 0x59, 0x45, 0x95, 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, 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, 0xe4, 0x6a, 0x52, 0x05, 0x95, 0x0a, 0xe4, 0x6a, 0x52, 0x05, 0x95, 0x0a, 0xe4, 0x6a, 0x52, 0x05, 0x95, 0x0a, 0xe4, 0x6a, 0x52, 0x05, 0x95, 0x0a, 0xe4, 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, 0x6a, 0x41, 0xda, 0x02, 0xb2, 0xa1, 0xa9, 0x05, 0x49, 0x0d, 0x0a, 0x6d, 0x2a, 0x09, 0x56, 0x01, 0xad, 0x50, 0x6d, 0x6d 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, 0x2d, 0x09, 0x9a, 0x68, 0xda, 0x08, 0x08, 0x08, 0xda, 0xda, 0xda, 0x08, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0XDA. 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, 0x2d 0x39, 0x36, 0x01, 0x6d, 0x80, 0x6d, 0x01, 0xd9, 0x02, 0xe9, 0x6a, 0xa8, 0x05, 0x29, 0x0b, 0x9a, 0x4c, 0xaa, 0x08, 0xb6, 0x08, 0xb4, 0x38, 0x38. 0x6c, 0x09, 0x54, 0x75, 0xd4, 0x0a, 0xa4, 0x05, 0x45, 0x55, 0x95, 0x0a, 0x9a, 0x04, 0x55, 0x44, 0xb5, 0x04, 0x6a, 0x82, 0x6a, 0xd2, 0xd2, 0xd2 0x0a, 0x92, 0x6a, 0x4a, 0x05, 0x55, 0x0a, 0x2a, 0x4a, 0x5a, 0x02, 0xb5, 0x02, 0x31, 0x69, 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, 0xda 0x04, 0x74, 0x05, 0xb0, 0x25, 0x54, 0x03}; String private getChineseterm () {if (get (calendar.date) == get (chino_sectional_term)) {return sectalTermnames [get (calendar.month)]; } else if (get (calendar.date) == get (chino_principle_term)) {return principalLetermnames [get (calendar.month)]; } else return null; } // Agregar por Skywang Private String getLunarfestival () {int day = get (chino_date); int mes = get (chino_month); String Stoday = Day <10? "0" + día: "" + día; Cadena smonth = mes <10? "0"+(mes): "+(mes); return lfestival.get (smonth+stoday);} cadena privada getSolarFestival () {int day = get (calendar.date); int mes = get (calendar.month); string stoday = day <10?" 0 "+día:" "+día; string smonth = mes <1 10?" 0 "+(((mes": "+1);"+1); return sfestival.get (smonth+stoday); } String private getFestivalOrTermordate () {String Ret; if ((ret = getSolarfestival ())! = null) return ret; if ((ret = getLunarfestival ())! = null) return ret; return getChinese (get (chino_term_or_date)); } // Gregorian Festival Private Static Hashmap <String, String> Sfestival = new Hashmap <String, String> (); // Intervine lunar hashmap estático privado <string, string> lfestival = new Hashmap <String, String> (); static {sfestival.put ("0101", "Día de Año Nuevo"); sfestival.put ("0214", "valenteen día"); sfestival.put ("0308", "Día de la Mujer"); sfestival.put ("0312", "Día del cenador"); sfestival.put ("0401", "Día de abril"); sfestival.put ("0501", "Día del trabajo"); Sfestival.put ("0504", "Jóvenes del Jóvenes"); sfestival.put ("0601", "Día del Niño"); sfestival.put ("0701", "día de centrado"); sfestival.put ("0801", "Día del ejército"); sfestival.put ("0910", "Día del maestro"); sfestival.put ("1001", "Día Nacional"); sFestival.put("1031","Halloween"); // sFestival.put("1112","Birthday of Sun Yat-sen"); sFestival.put("1225","Christmas"); lFestival.put("0101","Spring Festival"); // lFestival.put("0102","Quan 2"); // lFestival.put("0103","Quan 3"); lFestival.put("0115","Lantern Festival"); lFestival.put("0505","Dragon Boat Festival"); lFestival.put("0707","Qianxi Festival"); lFestival.put("0815","Mid-Autumn Festival"); lFestival.put("0909","Dongyang Festival"); lFestival.put("1208","Laba Festival"); // lFestival.put("1299","New Year's Eve"); }}