A produção perpétua do calendário aqui usa principalmente a classe do calendário e a classe GregorianCalendar. Vamos primeiro revisar o básico:
Partes básicas
1. Classe de calendário.
1. Campos principais:
Ano (ano), mês (o mês começa a partir de 0), data (dia de janeiro), hora (indica a hora da manhã ou da tarde), hour_f_day (indica a hora do dia.), Day_of_week (indica o número de semanas na semana (indicam o número do número de semanas), dia_ _ _year (indicam o número do número de semanas), dia_of_year (indicar o número de semanas), dia_ _ _yar ( Número de semanas no mês), WEEM_OF_YEAR (indica o número de semanas no ano)
2. Obtenha objeto de classe de calendário.
// Pense no método estático Getinstance da classe do calendário. Calendário CA = calendário.getInstance ();
3. Métodos principais
Void Set (campo int, int valor) // Os parâmetros da classe do calendário de campo, como data do mês, etc .... Void Set (Int Ano, Int Mês, Int Data) // Defina ano, mês e dia. Void Set (Ano int, Int Mês, Int Data, Int HourOfday, Int Minute) // Defina ano, mês, dia, hora e minuto) // Defina ano, mês, dia, hora, minuto e segundo vazio (data); // Defina a hora deste calendário com a data fornecida. int get (campo int) // retorna o valor do campo de calendário especificado. Por exemplo: int mês = acobj.get (calendar.month); data gettime () // retorna um objeto de data que representa o valor do tempo do calendário. long gettimeinmillis () // retorna o número de milissegundos de 1970.1.1 00:00:00 para o calendário. Void Add (campo int, Amont); // De acordo com as regras do calendário, adicione ou subtraia a quantidade especificada de tempo para um determinado campo de calendário. Pode ser adicionado ou subtraído. Por exemplo: caobj.add (calendário.month, 1) no próximo mês.
2. Classe GregoriaNendar.
1. Obtenha este objeto de classe
Calendário CA = new GregoriaCalendar () // Momento atual padrão. Calendário CA = New GregoriaNCanLendar (INT Ano, Int Mês, Int Dayofmonth) // Inicialmente, o objeto Gregorian Class com um ano, mês e dia especificado. Calendário CA = New GregoriaNCanLendar (ano int, mês int, int diarofonth, int hourOfday, int minuto) O objeto de classe gregorian inicialmente possui um ano, mês e dia especificado. Calendário CA = New GregoriaNCanLendar (ano int, mês int, Int Dayofmonth, int HourOfday, int minuto, int segundo) // Inicialmente, o objeto Gregorian Class com um ano, mês e dia especificado. Os acima são todos obtidos pela obtenção do local padrão e dos objetos de fuso horário padrão.
2. O uso de uso herda principalmente o calendário da classe pai.
Seção de exemplo
3. Código do calendário perpétuo
pacote com.via.mce.monthcalendar.utils; importar java.util.calendar; importar java.util.date; importar java.util.greiaCalendar; importar java.util.hashmap;/*** calendar lunar. <br> * Salve o tamanho do ano, o mês e os termos solares anteriores entre 1901 e 2100 do calendário lunar e calcule com base nesses dados. <br> * <br> * Vários campos de atributo constante para o calendário lunar foram adicionados e você pode usar o método get () para obter o valor correspondente do calendário; <br> * O ano civil lunar, mês e dia também pode ser definido usando o método set ()/add ()/roll (), e outros atributos do calendário lunar são calculados automaticamente; <br> * Além disso, o método GetChinese (INT Field) também é fornecido para obter o texto chinês do calendário lunar (aplicável apenas aos atributos do calendário lunar e à semana). <br> * <ul> * <li> chinês_year - ano lunar </li> * <li> chinês_month - mês lunar </li> * <li> chinês_date - dia lunar </li> * <li> chinês_steme_tern_term - termos solares do mês </li * * <li> chinês_principle_tern - central qi do mês </li> * <li> Do ano lunar </li> * <li> Chinês_earthly_branch - ramos terrenos do ano lunar </li> * <li> chinês_zodiac - zodíaco do ano lunar </li> * <li> chinês_term_or_date - se houver um termo solar no dia, indica o termo solar. Caso contrário, se o dia for o primeiro dia do dia, indica o mês lunar, caso contrário, indica o dia lunar. * </ul> * Nota: <br> * Devido à configuração da classe do calendário, o mês gregoriano começa a partir de 0. Todos os métodos seguem esta convenção. <br> * Mas todos os atributos lunares começam de 1. Mesmo no método fornecido pelo calendário, o mês lunar começa com 1 e representa o mês salto com um número negativo. <br> * O método clear () causará o calendário lunar e as datas do calendário gregoriano são inconsistentes ou o efeito de redefinição esperado não pode ser alcançado. Deve ser evitado o máximo possível. <br> * Ao usar o getsImpledateString () para obter a sequência de data do calendário gregoriano, o mês do calendário gregoriano foi corrigido; <br> * Ao usar o getSplechinesEdATEstring () para obter a sequência de data do calendário lunar, o mês de salto lunar é representado por *. <br> * * @version 0.12 2011-9-5 <br> * <lockQuote> Corrigido um problema em que o calendário estava preso em um ciclo morto ao inicializar o calendário usando o primeiro mês do calendário lunar. </blockquote> * @Version 0.11 2009-12-27 <br> * <lockQuote> Corrigido o problema em que o calendário lunar não foi calculado ao obter o calendário lunar chinês; <br> * Adicione um campo chinês_term_or_date para imitar o método de exibição do calendário da mesa: se houver um termo solar naquele dia, indica o termo solar, se for o primeiro dia do mês lunar, * caso contrário, indica o dia lunar. </lockquote> * @Version 0.10 2009-12-22 */Classe final pública ChineseCalendar estende GregoriaCalendar {private estático final serialversionuid = 8L; / ** Ano lunar*/ Public Static final int chinês_year = 801; / ** mês lunar*/ public static final int chinês_month = 802; / ** Dia lunar*/ public static final int chinês_date = 803; / ** Dia Gregoriano correspondente ao termo solar do mês (o termo solar anterior)*/ public static final int chinês_section_term = 804; / ** Dia Gregoriano correspondente ao termo solar do mês (o próximo termo solar)*/ public static final int chinês_principle_term = 805; / ** HAUMAS CELUITAS*/ Public Static final int chinês_heavenly_stem = 806; / ** ramos terrestre*/ public static final int chinês_earthly_branch = 807; / ** signos do zodíaco (signos do zodíaco)*/ public static final int chines_zodiac = 808; / ** Termo solar ou dia lunar*/ public static final int chinês_tern_or_date = 888; // Adicionar por Skywang/ ** Festival Lunar*/ Public Static final int lunar_festival = 809; / ** Termo solar*/ public static final int solar_festival = 810; / ** Termo solar*/ public static final int chinês_term = 811; / ** mês ou dia lunar*/ public static final int chinês_month_or_date = 812; / ** festival ou termo solar ou dia lunar*/ public static final int festival_or_term_or_date = 813; private int chinese; privado int chinesemonth; // Comece com 1, números negativos representam o mês bisseiro privado int chinesedate; Seção privada int termin; // Gregorian Day Private Int Principleterm; // Booleano Privado do Dia Gregoriano é ChinesefieldsComputed; // se a data lunar foi calculada e confirmada private booleano aresolartermscomputed; // se o termo solar foi calculado e confirmado, privado booleano lastSetchinese; // é a última configuração do atributo lunar/** Construa uma instância usando o horário atual. */ public chineseCalendar () {super (); } /** Construa uma instância usando o tempo especificado. */ public chinesecalendar (data d) {super.setTime (d); } /** Construa uma instância usando o tempo especificado. */ public chinesecalendar (calendário c) {this (c.gettime ()); } /** Construa uma instância usando a data gregoriana especificada. */ public chinesecalendar (int y, int m, int d) {super (y, m, d); } /*** Construa uma instância com a data especificada. * * @param ischinese * é a data lunar * @param y * @param m * @param d */ public chineseCalendar (booleano isquinheiro, int y, int m, int d) {if (ischinês) {set (chinês_year, y); set (chinês_month, m); set (chinês_date, d); } else {set (y, m, d); }} public void set (campo int, int value) {computeifneed (campo); if (ischinesefield (campo)) {// switch de atributo do calendário lunar (campo) {case chinês_year: chinêsyear = value; quebrar; case chinês_month: chinesemonth = value; quebrar; case chinês_date: chinesedate = value; quebrar; Padrão: jogue novo ilegalargumentException ("Configurações de campo não suportadas:" + campo); } lastSetchinEse = true; } else {// Atributo do calendário não lunar Super.set (campo, valor); lastSetchinEse = false; } arefieldSset = false; arechinesefieldscomputed = false; aresolartermscomputed = false; } public int get (Int Field) {computeifneed (campo); if (! ischinesefield (campo)) {return super.get (campo); } switch (campo) {case chinês_year: return chinêsyear; Case Chinese_month: retornar Chinesonth; case chinês_date: retornar chinesedate; case chinês_sectional_term: retornar seccional; case chinês_principle_term: retornar princípio de princípio; case chinês_heavenly_stem: return (chinês - 4) % 10 + 1; case chinês_earthly_branch: case chinês_zodiac: retornar (chinês - 4) % 12 + 1; case chinês_month_or_date: if (get (chinês_date) == 1) {return chinês_month; } else {return chinês_date; } case chinês_term_or_date: int option; if (get (calendar.date) == get (chinês_sectional_term)) {option = chinês_sectional_term; } else if (get (calendar.date) == get (chinês_principle_term)) {option = chinês_principle_term; } else if (get (chinês_date) == 1) {option = chinês_month; } else {option = chinês_date; } opção de retorno; Padrão: jogue novo IllegalargumentException ("Campo não suportado Get:" + Field); }} public void add (campo int, int vale) {computeifneed (campo); if (! ischinesefield (campo)) {super.add (campo, quantidade); lastSetchinEse = false; arechinesefieldscomputed = false; aresolartermscomputed = false; retornar; } switch (campo) {case chinês_year: chinêsyear += vale; quebrar; case chinês_month: for (int i = 0; i <valor; i ++) {chinesemonth = nextChinesemonth (chinêsyear, chinesemonth); if (chinesonth == 1) {chinêsyear ++; } } quebrar; case chinês_date: int maxdate = Daysinchinesemonth (chinês, Chinesemoth); for (int i = 0; i <valor; i ++) {chinesedate ++; if (chinesedate> maxdate) {chinesedate = 1; Chinesemonth = NextChinesemonth (chinês, Chinesonth); if (chinesonth == 1) {chinêsyear ++; } maxdate = Daysinchinesemonth (Chineseyear, chinesemonth); }} Padrão: jogue novo ilegalArgumentException ("Campo não suportado:" + campo); } lastSetchinEse = true; arefieldsset = false; arechinesefieldscomputed = false; aresolartermscomputed = false; } public void roll (campo int, INT) {computeifneed (campo); if (! ischinesefield (campo)) {super.roll (campo, quantidade); lastSetchinEse = false; arechinesefieldscomputed = false; aresolartermscomputed = false; retornar; } switch (campo) {case chinês_year: chinêsyear += vale; quebrar; case chinês_month: for (int i = 0; i <valor; i ++) {chinesemonth = nextChinesemonth (chinêsyear, chinesemonth); } quebrar; case chinês_date: int maxdate = Daysinchinesemonth (chinês, Chinesemoth); for (int i = 0; i <valor; i ++) {chinesedate ++; if (chinesedate> maxdate) {chinesedate = 1; }} Padrão: jogue novo ilegalArgumentException ("Campo não suportado:" + campo); } lastSetchinEse = true; arefieldsset = false; arechinesefieldscomputed = false; aresolartermscomputed = false; } /*** Obtenha o idioma chinês do atributo, os campos de atributo que podem ser usados são Day_Of_Week e todos os campos de atributo lunar. * * @param field * @return */ public string getchinese (int campo) {computeiFneed (campo); switch (campo) {case chinês_year: return getchinese (chinês_heavenly_stem) + getchinese (chinês_earthly_branch) + "ano"; case chinês_month: if (chinesemonth> 0) retorna chinesemonthnames [chinesemoth] + "mês"; else Retornar "Leap" + chinesemonthNames [-chinesemonth] + "mês"; case chinês_date: retornar chinesedatenames [chinesedate]; case chinês_sectional_term: retornar seção termin nomes [get (calendar.month)]; case chinês_principle_term: retorna princípio de princípio [get (calendar.month)]; case chinês_heavenly_stem: retornar stemnames [get (campo)]; case chinês_earthly_branch: retornar nomes de ramificação [get (campo)]; case chinês_zodiac: retornar nomes de animais [get (campo)]; Case calendário.day_of_week: retornar chinesesweeknekames [get (campo)]; case chinês_term_or_date: return getchinese (get (chinês_term_or_date)); case lunar_festival: return getLunarfestival (); case solar_festival: return getSolarfestival (); case festival_or_term_or_date: return getFestivalorMerDordate (); // TODO Verifique o caso chinês_month_or_date: return getchinese (get (chinês_month_or_date)); case chinês_term: return getChineSeterm (); Padrão: jogue novo IllegalargumentException ("Campo não suportado chinesa Get:" + Field); }} public string getSIMPLEGREGIDADATESTRING () {retorna new StringBuffer (). Apêndos (get (ano)). Append ("-") .Append (get (Month) + 1) .Append ("-"). Append (get (data) .ToString (); } public string getSImplechinesEdATestring () {return new stringbuffer () .append (get (chinês_year)) .append ("-") .append (get (chinês_month)> 0? "" + get (chinês_month): "*" + (-get (chinês)). ".. } public string getchinesedateString () {return new stringBuffer (). Append (getChinese (chinês_year)) .append (getchinese (chinês_month) .append (getchinese (chinês_date)). tostring (); } public string tostring () {stringbuffer buf = new StringBuffer (); buf.append (getSIMPLEGREGORIDATATERRING ()). Append ("|") .Append (getChinese (Day_Of_week)). Append ("| [calendário lunar]") .Append (getchinesEdAtString (). .Append (get (chinês_seccional_term)). Anexe ("dia") .append (getchinese (chinês_sectional_term)). Anexe ("") .Append (get (chinês_principle_term)). Appender ("dia") .append (getchinês (chinês_prvince_tern)); retornar buf.toString (); } / ** * Determine se é um atributo lunar * * @param campo * @return * / private booleano ischinesefield (int campo) {switch (campo) {case chinês_year: case chinese_month: case chinês_date: case chinese_section_tern_term: case chinese_principle_term: case_heaLely_stem_stem_stem_sectional_tern_term: case chinês_principle_tern: case_healy_stem_tem_tem_section_sectional_term: case chinês_principle_tern: Chinês_term_or_date: case chinês_month_or_date: retornar true; Padrão: retornar false; }} / ** * Determine se é um atributo relacionado ao termo solar * * @Param Field * @return * / private boolean ischineSetermsfield (int field) {switch (field) {case chinês_sectional_term: case chines_principle_term: case chines_or_or_date: return; Padrão: retornar false; }} /** * Se os atributos que foram definidos na última vez não forem os mesmos a serem definidos ou obtidos desta vez (calendário lunar /calendário gregoriano), <br> * Por exemplo, a última vez que eu defini o calendário lunar e agora eu quero definir ou obtiver o calendário gregiano, com base no calendário que você precisa para o calendário lunar, que você precisa. * * @Param Field */ private void compUteIfNeed (Int Field) {if (isnchinesefield (campo)) {if (! lastSetchInEse &&! arechinesefieldscomputed) {super.complete (); computechinesefields (); arefieldsset = true; arechinesefieldscomputed = true; aresolartermscomputed = false; } if (ischineSetermsfield (campo) &&! aresolartermscomputed) {computesolarterms (); aresolartermscomputed = true; }} else {if (lastSetchinese &&! arefieldsSet) {computeGreGRIANFIELDS (); super.complete (); arefieldsset = true; arechinesefieldscomputed = true; aresolartermscomputed = false; }}} / *** Use a data lunar para calcular o Gregioriandate* / private void compUteGreGeRIANFIELDS () {int y = chinês; int m = chinesonth; int d = chinesedate; arechinesefieldscomputed = true; arefieldsset = true; lastSetchinEse = false; // ajuste o intervalo de data se (y <1900) y = 1899; caso contrário, se (y> 2100) y = 2101; if (m <-12) m = -12; caso contrário, se (m> 12) m = 12; if (d <1) d = 1; caso contrário, se (d> 30) d = 30; int dateInt = y * 10000 + math.abs (m) * 100 + d; if (dateInt <19001111) {// conjunto muito pequeno (1901, calendário.january, 1); super.complete (); } else if (dateInt> 21001201) {// conjunto muito grande (2100, calendário.docember, 31); super.complete (); } else {if (math.abs (m)> 12) {m = 12; } int Days = chinesecalendar.DaysInchinesemonth (y, m); if (dias == 0) {m = -m; dias = chinesecalendar.daysinchinesemonth (y, m); } if (d> dias) {d = dias; } set (y, math.abs (m) - 1, d); computechinesefields (); INT valor = 0; while (chinêsyear! = y || chinesemonth! = m) {quantidade += Daysinchinesemonth (chinês, chinesemoth); Chinesemonth = NextChinesemonth (chinês, Chinesonth); if (chinesonth == 1) {chinêsyear ++; }} quantidade += d - chinesedate; super.add (calendário.date, quantidade); } computechinesefields (); } / *** Calcule a data do calendário lunar usando a data gregoriana* / private vazio computechinesefields () {int gregionianyear = internget (calendar.year); int gregorianmonth = internalget (calendar.month) + 1; int gregioniandate = internalget (calendar.date); if (GregorianYear <1901 || GregorianYear> 2100) {return; } int startyear, startmonth, startDate; if (GregorianYear <2000) {startyear = Baseyear; startmonth = basemonth; startDate = baseado; Chinês Year = Basechineseyear; Chinesemonth = Basechinesemonth; ChineSedate = BasechineSedate; } else {// O segundo dia correspondente é usado para melhorar a eficiência da computação // 1 de janeiro de 2000, o calendário lunar correspondente 4697 (1999), StartYear = Baseyear + 99; startmonth = 1; startDate = 1; Chinês Year = Basechineseyear + 99; chinesonth = 11; ChineSedate = 25; } int DaysDiff = 0; // ano para (int i = startyear; i <gregorianYear; i ++) {if (isregorianLeapyear (i)) {DaysDiff+= 366; // ano salgado} else {DaysDiff += 365; }} // mês para (int i = startmonth; i <gregorianmonth; i ++) {DaysDiff+= DaysingReGorianMonth (GregorianYear, i - 1); } // DayDaysDiff += Gregoriandate - StartDate; ChineSedate += DaysDiff; int lastdate = Daysinchinesemonth (chinês, chinesemonth); while (chinesedate> lastdate) {chinesedate -= lastDate; Chinesemonth = NextChinesemonth (chinês, Chinesonth); if (chinesonth == 1) {chinêsyear ++; } lastDate = DaysInchinesemonth (Chineseyear, Chinesonth); }} / *** Calcule os termos solares* / private void compactesolarterms () {int gregorianYear = internget (calendar.year); int gregorianmonth = internalget (calendar.month); if (GregorianYear <1901 || GregorianYear> 2100) {return; } SectionalTerm = SectionalTerm (GregorianYear, GregorianMonth); PrincipLeTerm = PrincipalTerm (GregorianYear, GregorianMonth); } / * Em seguida é o método estático ~ * / / ** * É um ano bissexto no ano gregoriano * * @param ano * @return * / public static boolean isgregorianleapyear (int ano) {boolean isleap = false; if (ano % 4 == 0) {isleap = true; } if (ano % 100 == 0) {isleap = false; } if (ano % 400 == 0) {isleap = true; } retornar Isleap; } /*** Calcule o número de dias no ano gregoriano, e o mês gregoriano começa a partir de 0! * * @param y * @param m * @return */ public static int DaysingReGorianmonth (int y, int m) {int d = DaysingReGorianMonth [m]; if (m == calendar.febrovery && isgregorianleapyear (y)) {d ++; // mais um dia em um ano bissexto no ano gregoriano} retorna d; } /*** Calcule os termos solares do mês gregoriano, o mês gregoriano começa a partir de 0! * * @param y * @param m * @return */ public static int seccional dom (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 termo = SectionalTermMap [m - 1] [4 * Índice + Ry % 4]; if ((ry == 121) && (m == 4)) {termo = 5; } if ((ry == 132) && (m == 4)) {termo = 5; } if ((ry == 194) && (m == 6)) {termo = 6; } Termo de retorno; } /*** Calcule o zhongqi do ano gregoriano, e o mês gregoriano começa a partir de 0! * * @param y * @param m * @return */ public static int princípio (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 termo = PrincipalTermMap [M - 1] [4 * Index + Ry % 4]; if ((ry == 171) && (m == 3)) {termo = 21; } if ((ry == 181) && (m == 5)) {termo = 21; } Termo de retorno; } / ** * Calcule o número de dias no ano lunar * * @param y * @param m * @return * / public static int Daysinchinesemonth (int y, int m) {// Nota: mês fio 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) e 0x01) == 1) {d = 29; }} else if (9 <= m && m <= 12) {v = chinesemonths [2 * index + 1]; l = m - 9; if (((v >> l) e 0x01) == 1) {d = 29; }} else {v = chinesonths [2 * Índice + 1]; v = (v >> 4) e 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; quebrar; }}}} retornar d; } / ** * Calcule no próximo mês do calendário 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 = chinesonths [2 * índice + 1]; v = (v >> 4) e 0x0f; if (v == m) {n = -m; }} if (n == 13) {n = 1; } retornar n; } /* Data do primeiro dia do calendário* / private estático final int year = 1901; private estático final int basemonth = 1; private estático final int baseado = 1; private estático 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; /* String chinesa*/ String final estática privada [] ChineseweekNames = {"", "Sunday", "Segunda -feira", "Terça -feira", "Quinta String final estática privada [] chinesemonthnames = {"", "primeiro", "três", "quatro", "cinco", "seis", "sete", "oito", "nove", "ten", "ten", "eleven", "doze"}; private static final String[] chineseDateNames = { "", "First", "First", "Fourth", "Five", "Sixth", "Seventh", "Eighth", "Nine", "Nine", "Tenth", "Tenth", "Tenth", "Tenth", "Tenth", "Tenth", "Tenth", "Tenth", "Tenth", "Tenth", "Tenth", "Décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo", "décimo"}; private static final String[] principleTermNames = { "Great Cold", "Rain Water", "Spring Equinox", "Green Rain", "Summer Solar", "Green Summer", "Green Summer", "Green Summer", "Green Summer", "Summer Solar", "Green Summer", "Starry Summer", "September Equinox", "September Equinox", "Frost fall", "Light snow", "Winter Solstice" }; String final estática privada [] Seção terminamNames = {"Little Cold", "Bird Spring", "Jingzhe", "Qingming", "Início do verão", "Sementes de granulação", "Little Heat", "Autumn de pássaro", "orvalho branco", "orvalho frio", "inverno em snow", "alto"} "}; String final estática privada [] stemmames = {"", "jia", "yi", "bing", "ding", "wu", "ji", "geng", "xin", "ren", "gui"}; String final estática privada [] BranchNames = {"", "Zi", "UG", "Yin", "Mao", "Chen", "Si", "Wu", "Shen", "Você", "Xu", "Hai"}; String final estática privada [] AnimalNames = {"", "Rat", "Ox", "Tiger", "Rabbit", "Dragon", "Snake", "Horse", "Sheep", "Monkey", "Frango", "Dog", "Pig"}; / * Em seguida, é a tabela de compressão de dados ~ */ private estático 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. 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. 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, 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; 124, 160, 192, 200, 201}, {16, 44, 80, 112, 148, 180, 200, 201}, {17, 53, 88, 120, 156, 188, 200, 201}}; Char estático privado [] DayingRegorianMonth = {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, 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, 0x6a, 0x41, 0xda, 0x02, 0xb2, 0xA1, 0XA9, 0x05, 0x49, 0x0d, 0x0a, 0x6d, 0x2a, 0x50, 0x0d, 0x0a, 0x6d, 0x2A, 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, 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, 0x31, 0x69, 0x31, 0x73, 0X02, 0x31, 0x69, 0x31, 0x73, 0xax, 0x31, 0x69, 0x31, 0x73, 0xax, 0x0a, 0x2d, 0x09, 0x5a, 0x01, 0xd5, 0x48, 0xb4, 0x09, 0x68, 0x89, 0x54, 0x0b, 0xa4, 0x0a, 0xa5, 0x6a, 0x95, 0x44, 0x0a, 0xa5, 0x6a, 0x95, 0x4, 0xad, 0X0a, 0xa5, 0x6a, 0x95, 0x44, 0xad, 0xa5, 0x6a, 0x95, 0x44, 0xad, 0xA5, 0x6a, 0x95, 0x44, 0xad, 0xa5, 0x6a, 0x95, 0x44, 0xad, 0xa5, 0x6a, 0x95, 0x44, 0xad, 0xa5, 0x6a, 0x95, 0x44, 0xad, 0xa5, 0x6a, 0x95, 0x44, 0xad, 0x0. 0x04, 0x74, 0x05, 0xb0, 0x25, 0x54, 0x03}; private string getChineSeterm () {if (get (calendar.date) == get (chinês_sectional_term)) {retorna seccionaltermNames [get (calendar.month)]; } else if (get (calendar.date) == get (chinês_principle_term)) {return princípio de princípio [get (calendar.month)]; } mais retorna nulo; } // Adicionar por Skywang Private String getLunarfestival () {int Day = get (chinês_date); int mês = get (chinês_month); String stoday = dia <10? "0" + dia: "" + dia; String smonth = mês <10? "0"+(mês): "+(mês); retorna lfestival.get (smonth+stoday);} private string getSolarfestival () {int dia = get (calendar.date); int mês = get (calendar.mOth); string = dia <10?" ""+Dia: ""+dia; return sfestival.get (smonth+stoday); } private String getFestivalorMerDate () {String ret; if ((ret = getSolarfestival ())! = NULL) return ret; if ((ret = getLunarfestival ())! = NULL) return ret; return getchinese (get (chinês_tern_or_date)); } // festival gregoriano private estático hashmap <string, string> sfestival = new hashmap <string, string> (); // Lunar Intervey Private Static Hashmap <String, String> lfestival = new Hashmap <String, String> (); estático {sfestival.put ("0101", "dia de ano novo"); sfestival.put ("0214", "dia do dia do dia do dia valenteen"); sfestival.put ("0308", "Dia da Mulher"); sfestival.put ("0312", "Dia do Arbor"); sfestival.put ("0401", "dia de abril"); sfestival.put ("0501", "Dia do Trabalho"); sfestival.put ("0504", "dia da juventude"); sfestival.put ("0601", "Dia das Crianças"); sfestival.put ("0701", "Centering Day"); sfestival.put ("0801", "Dia do Exército"); sfestival.put ("0910", "dia do professor"); sFestival.put("1001","National Day"); 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"); }}