La production de calendrier perpétuelle utilise principalement la classe de calendrier et la classe Gregoriancalendar. Prenons d'abord les bases:
Parties de base
1. Classe de calendrier.
1. Champs principaux:
Année (année), mois (mois à partir de 0), date (jour de janvier), heure (indique l'heure du matin ou de l'après-midi), heure_F_DAY (indique l'heure du jour.), Day_of_week (indique le nombre de semaines dans la semaine), Day_of_month (indique le nombre de semaines de l'année), Day_of_in_inte le nombre de semaines) Nombre de semaines dans le mois), semaine_of_year (indique le nombre de semaines de l'année)
2. Obtenez l'objet de classe Calendar.
// Passez la méthode statique GetInstance de la classe de calendrier. Calendar Ca = calendar.getInstance ();
3. Méthodes principales
SET VOID (INT Field, int Value) // Les paramètres de la classe de calendrier de champ, tels que la date du mois d'année, etc. Ensemble de vide (année int, mois, date int, int hourofday, int mienne) // année, mois, jour, heure et minute) // Année, mois, jour, heure, minute et seconde du Settime de vide (date de date); // définit l'heure de ce calendrier avec la date donnée. int get (Int Field) // Renvoie la valeur du champ Calendaire donné. Par exemple: int mois = acobj.get (calendar.month); date getTime () // renvoie un objet date représentant la valeur d'heure du calendrier. Long GetTimeInmilis () // Renvoie le nombre de millisecondes de 1970.1.1 00:00:00 au calendrier. void add (int champ, amont); // selon les règles du calendrier, ajoutez ou soustrayez la durée spécifiée pour un champ de calendrier donné. Peut être ajouté ou soustrait. Par exemple: CAOBJ.ADD (Calendar.month, 1) le mois prochain.
2. Classe Gregoriancalendar.
1. Obtenez cet objet de classe
Calendar CA = nouveau GregorianCalendar () // Moment de courant par défaut. Calendar CA = New Gregoriancanlendar (int an, int mois, int dayofmonth) // initialement, l'objet de classe grégorienne avec une année, un mois et un jour spécifié. Calendar CA = New Gregoriancanlendar (int an, int mois, int dayofmonth, int hourofday, int mutte) L'objet de classe grégorienne a initialement une année, un mois et un jour spécifiés. Calendar CA = New Gregoriancanlendar (int an, int mois, int dayofmonth, int hourofday, int mutte, int seconde) // initialement, l'objet de classe grégorienne avec une année, un mois et un jour spécifiés. Ce qui précède est tous obtenus en obtenant le paramètre par défaut et les objets de fuseau horaire par défaut.
2. L'utilisation de l'utilisation hérite principalement du calendrier des classes parentales.
Exemple de section
3. Code de calendrier perpétuel
package com.via.mce.monthcalendar.utils; import java.util.calendar; import java.util.date; import java.util.gregoriancalendar; import java.util.hashmap; / ** * calendar lunar. <br> * Économisez la taille de l'année, du mois et des termes solaires précédents entre 1901 et 2100 du calendrier lunaire, puis calculez en fonction de ces données. <br> * <br> * Plusieurs champs d'attribut constants pour le calendrier lunaire ont été ajoutés, et vous pouvez utiliser la méthode get () pour obtenir la valeur correspondante du calendrier; <br> * L'année civile, le mois et le jour lunaires peuvent également être définis à l'aide de la méthode set () / add () / roll (), et d'autres attributs de calendrier lunaire sont automatiquement calculés; <br> * En outre, la méthode GetChinese (champ int) est également fournie pour obtenir du texte chinois du calendrier lunaire (uniquement applicable aux attributs du calendrier lunaire et à la semaine). <br> * <ul> * <li> Chinese_year - Année lunaire </li> * <li> Chinese_Month - Mois lunaire </li> * <li> Chinese_Date - Lunar Day </li> * <li> Chinese_Sectional_term - Termes solaires du mois </li> * <li> Chinese_HeaPle_Term - Central Qi du mois </li> * <li> Chinese_HeAple_Tepled - Central Qi du mois </li> * <li> Chinese_HeAple_Temy - Central Qi du mois </li> * <li> Chinese_HeAple_Temy - Central Qi du mois </li> * <LI> Chine Tiches de l'année lunaire </li> * <li> chinois_arthly_branch - branches terrestres de l'année lunaire </li> * <li> Chinese_zodiac - Zodiac de l'année lunaire </li> * <li> Chinese_term_or_date - S'il y a un terme solaire le jour, il indique le terme solaire. Sinon, si le jour est le premier jour de la journée, cela indique le mois lunaire, sinon cela indique le jour lunaire. * </ul> * Remarque: <br> * En raison du réglage de la classe de calendrier, le mois grégorien commence à partir de 0. Toutes les méthodes suivent cette convention. <br> * Mais tous les attributs lunaires commencent à partir de 1. Même dans la méthode fournie par le calendrier, le mois lunaire commence par 1 et représente le mois de saut avec un nombre négatif. <br> * La méthode Clear () entraînera incohérente le calendrier lunaire et les dates du calendrier grégorien ou l'effet de réinitialisation attendu ne peut pas être obtenu. Il doit être évité autant que possible. <br> * Lorsque vous utilisez getImpledateString () pour obtenir la chaîne de date de calendrier grégorienne, le mois civil grégorien a été corrigé; <br> * Lorsque vous utilisez getIMPlechineSedateString () pour obtenir la chaîne de date de calendrier lunaire, le mois LUNAR LEAP est représenté par *. <br> * * @version 0.12 2011-9-5 <br> * <blockquote> Correction d'un problème où le calendrier a été piégé dans un cycle mort lors de l'initialisation du calendrier en utilisant le premier mois du calendrier lunaire. </clockquote> * @version 0.11 2009-12-27 <br> * <lockquote> Correction du problème où le calendrier lunaire n'a pas été calculé lors de l'obtention du calendrier lunaire chinois; <br> * Ajouter un champ chinois_term_or_date pour imiter la méthode d'affichage du calendrier de bureau: s'il y a un terme solaire ce jour-là, il indique le terme solaire, s'il s'agit du premier jour du mois lunaire, * sinon il indique le jour lunaire. </ Blockquote> * @version 0.10 2009-12-22 * / Classe finale publique Chinesecalendar étend GregorianCalendar {private statique final SerialVersionUID = 8l; / ** année lunaire * / public statique final int chinois_year = 801; / ** Mois lunaire * / public statique final int chinois_month = 802; / ** jour lunaire * / public statique final int chinois_date = 803; / ** Jour grégorien correspondant au terme solaire du mois (le terme solaire précédent) * / public static final int chinois_sectional_term = 804; / ** Jour grégorien correspondant au terme solaire du mois (le prochain terme solaire) * / public static final int chinois_principle_term = 805; / ** TEAUDES CEALLES * / public static final int chinois_heavenly_stem = 806; / ** branches terrestres * / public statique final int chinois_arthly_branch = 807; / ** Signes du zodiaque (signes zodiaques) * / public statique final int chinois_zodiac = 808; / ** Terme solaire ou jour lunaire * / public statique final int chinois_term_or_date = 888; // Ajouter par Skywang / ** Festival lunaire * / public statique final int lunar_festival = 809; / ** Terme solaire * / public static final int solar_festival = 810; / ** Terme solaire * / public statique final int chinois_term = 811; / ** mois ou jour lunaire * / public static final int chinois_month_or_date = 812; / ** Festival ou terme solaire ou jour lunaire * / public static final int festival_or_term_or_date = 813; privé int chinoisyear; private int chinesenth; // Commencez avec 1, les nombres négatifs représentent le mois de saut dans le chinedate privé; private int sectionterm; // Grégorian Day Private Int Principleterm; // Gregorian Day Private Boolean est composé de champs chinois; // si la date lunaire a été calculée et confirmée parmi les aresolarterms du sol privé; // si le terme solaire a été calculé et confirmé le booléen privé LastTechinese; // est le dernier paramètre de l'attribut lunaire / ** Construire une instance en utilisant l'heure actuelle. * / public chinesecalendar () {super (); } / ** Construire une instance en utilisant le temps spécifié. * / public chinesecalendar (date d) {super.settime (d); } / ** Construire une instance en utilisant le temps spécifié. * / public chinesecalendar (calendrier c) {this (c.getTime ()); } / ** Construire une instance en utilisant la date grégorienne spécifiée. * / public chinesecalendar (int y, int m, int d) {super (y, m, d); } / ** * Construisez une instance avec la date spécifiée. * * @param ischinese * Est-ce la date lunaire * @param y * @param m * @param d * / public chinesecalendar (boolean ischinese, int y, int m, int d) {if (ischinese) {set (chinois_year, y); set (chinois_month, m); set (chinois_date, d); } else {set (y, m, d); }} public void set (Int champ, int Value) {computeIfNeed (champ); if (ischineseField (champ)) {// commutateur d'attribut calendrier lunaire (champ) {case chinois_year: chinoisyear = value; casser; case chinois_month: chineSemath = valeur; casser; case chinois_date: chinesedate = value; casser; Par défaut: lancez un nouveau IllégalArgumentException ("Paramètres de champ non pris en charge:" + champ); } LastSetchinese = true; } else {// Attribut de calendrier non lunar super.set (champ, valeur); LastSetchinese = false; } areFieldsSet = false; aRechinEseFieldsCompuled = false; aresolartermsComputed = false; } public int get (int champ) {computeIfNeed (champ); if (! IschineseField (champ)) {return super.get (champ); } switch (champ) {case chinois_year: return chinoisyear; Case chinois_month: retour chinesemonth; Case chinois_date: retour chinedate; Case chinois_sectional_term: rendement sectionalterm; Case chinois_principle_term: Return Principleterm; Case chinois_heavenly_stem: Retour (Chineseyear - 4)% 10 + 1; Case chinois_arthly_branch: cas chinois_zodiac: retour (chinoisyear - 4)% 12 + 1; case chinois_month_or_date: if (get (chinois_date) == 1) {return chinois_month; } else {return chinois_date; } cas chinois_term_or_date: option int; if (get (calendar.date) == get (chinois_sectional_term)) {option = chinois_sectional_term; } else if (get (calendar.date) == get (chinois_prinpile_term)) {option = chinois_prinpile_term; } else if (get (chinois_date) == 1) {option = chinois_month; } else {option = chinois_date; } option de retour; Par défaut: lancez un nouveau IllégalArgumentException ("Field non pris en charge Get:" + Field); }} public void add (int, int montant) {computeIfNeed (champ); if (! IschineseField (champ)) {super.add (champ, montant); LastSetchinese = false; aRechinEseFieldsCompuled = false; aresolartermsComputed = false; retour; } commutateur (champ) {case chinois_year: chinoisyear + = montant; casser; case chinois_month: for (int i = 0; i <montant; i ++) {chineSemEth = nextCheneSemonth (chinoisyear, chineSaith); if (chineSaith == 1) {chinoisyear ++; } } casser; Case chinois_date: int maxdate = daysInChineSonth (chinoisyear, chinesemm); pour (int i = 0; i <montant; i ++) {Chinedate ++; if (chinesedate> maxdate) {chinesedate = 1; CHINESEMPH = NEXTCHINESEMPETH (Chineseyear, CHINESEMPH); if (chineSaith == 1) {chinoisyear ++; } maxdate = DaysInChinesEmonth (Chineseyear, chineSemath); }} par défaut: lancez un nouveau IllégalArgumentException ("Field non pris en charge:" + champ); } LastSetchinese = true; areFieldsSet = false; aRechinEseFieldsCompuled = false; aresolartermsComputed = false; } public void roll (int champ, houmn int) {computeIfNeed (champ); if (! IschineseField (champ)) {super.roll (champ, montant); LastSetchinese = false; aRechinEseFieldsCompuled = false; aresolartermsComputed = false; retour; } commutateur (champ) {case chinois_year: chinoisyear + = montant; casser; case chinois_month: for (int i = 0; i <montant; i ++) {chineSemEth = nextCheneSemonth (chinoisyear, chineSaith); } casser; Case chinois_date: int maxdate = daysInChineSonth (chinoisyear, chinesemm); pour (int i = 0; i <montant; i ++) {Chinedate ++; if (chinesedate> maxdate) {chinesedate = 1; }} par défaut: lancez un nouveau IllégalArgumentException ("Field non pris en charge:" + champ); } LastSetchinese = true; areFieldsSet = false; aRechinEseFieldsCompuled = false; aresolartermsComputed = false; } / ** * Obtenez la langue chinoise de l'attribut, les champs d'attribut qui peuvent être utilisés sont day_of_week et tous les champs d'attribut lunaires. * * @param field * @return * / public String getChinese (int champ) {computeIfNeed (champ); Switch (champ) {case chinois_year: return getchinese (chinois_heavenly_stem) + getchinese (chinois_arthly_branch) + "année"; case chinois_month: if (chineSemonth> 0) return chineSemaThNames [chinesemont] + "mois"; else return "leap" + chineSemonThNames [-CHINESEMPH] + "mois"; case chinois_date: return chinesedatenames [chinesedate]; Case chinois_sectional_term: Retour sectiontermNames [get (calendar.month)]; case chinois_prinpile_term: return PrinciplemNames [get (calendar.month)]; case chinois_heavenly_stem: return stemnames [get (field)]; case chinois_arthly_branch: return branchNames [get (field)]; Case chinois_zodiac: Retour AnimalNames [Get (Field)]; Case calendar.day_of_week: return chineseweeknoms [get (field)]; case chinois_term_or_date: return getChinese (get (chinois_term_or_date)); case lunar_festival: return getlunarfestival (); Case Solar_Festival: return getolarfestival (); cas festival_or_term_or_date: return getFestivalTorterMordate (); // TODO COST CASE CHINOS_MONTH_OR_DATE: RETOUR GetChinese (get (chinois_month_or_date)); case chinois_term: return getCHineSeterm (); Par défaut: lancez un nouveau IllégalArgumentException ("Field non pris en charge chinois obtient:" + champ); }} public string getSimpleregorIandAtString () {return new StringBuffer (). A SPEND (get (année)). APPEND ("-") .APPEND (get (mois) + 1) .Apnd ("-"). A SPEND (get (date)) .ToString (); } String public getIMPlechineSedateString () {return new StringBuffer () .Apnd (get (chinois_year)) .append ("-") .append (get (chinois_month)> 0? "" + get (chinois_month): "*" + (-get (chinois_month))). } public String getCHineSeDateString () {return new StringBuffer (). APPEND (getchinese (chinois_year)) .Apnd (getChinese (chinois_month)) .Apnd (getchinese (chinois_date)). toString (); } public String toString () {stringBuffer buf = new StringBuffer (); buf.append (getSImpleGreandAdateString ()). append ("|") .append (getChinese (day_of_week)). APPEND ("| [Lunar Calendar]") .Apnd (getChineseDatestring ()). APPEND (""). .APPEND (GET (chinois_sectional_term)). APPEND ("Day") .Apnd (getChinese (chinois_sectional_term)). APPEND ("") .APPEND (GET (chinois_principle_term)). return buf.toString (); } / ** * Déterminez s'il s'agit d'un attribut lunaire * * @param champ * @return * / private boolean ischinesefield (int champ) {switch (champ) {case chinois_year: case chinois_month: case chinois_date: case chinois_sectional_term: case chinois_principle_term: case chinois_heaenly_stem: case chinois_eart Chinois_term_or_date: case chinois_month_or_date: return true; par défaut: return false; }} / ** * Déterminez s'il s'agit d'un attribut lié au terme solaire * * @param field * @return * / private booléan ischinesetermsfield (int champ) {switch (champ) {case chinois_sectional_term: case chinois_prinpile_term: case chinois_term_or_date: return true; par défaut: 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 date. * * @param field * / private void calleifneed (int champ) {if (ischinesefield (champ)) {if (! LastSetchinese &&! arechineseFieldsComputed) {super.comPlete (); ComputechineseFields (); areFieldsSet = true; aRechinEseFieldsCompuled = true; aresolartermsComputed = false; } if (isChineSeTermsField (champ) &&! AresolartermsCompuded) {calcularterSolaire (); aresolartermsComputed = true; }} else {if (LastSetchinese &&! areFieldsSet) {computeGregorianFields (); supercomptete (); areFieldsSet = true; aRechinEseFieldsCompuled = true; aresolartermsComputed = false; }}} / ** * Utilisez la date lunaire pour calculer le gregoriandate * / private void computegregorianfields () {int y = chinoisyear; int m = chinesemm; int d = chinedate; aRechinEseFieldsCompuled = true; areFieldsSet = true; LastSetchinese = false; // ajuster la plage de dates 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 (datelint <19001111) {// trop petit ensemble (1901, calendar.january, 1); supercomptete (); } else if (dateInt> 21001201) {// trop grand ensemble (2100, calendar.december, 31); supercomptete (); } else {if (math.abs (m)> 12) {m = 12; } int days = chinesecalendar.daysInChinesEmonth (y, m); if (days == 0) {m = -m; jours = Chinesecalendar.DaySinChinesEmonth (y, m); } if (d> jours) {d = jours; } set (y, math.abs (m) - 1, d); ComputechineseFields (); int montant = 0; tandis que (chinoisyear! = y || chineSaith! = m) {quantité + = daysInChineSemonth (Chineseyear, chineSaith); CHINESEMPH = NEXTCHINESEMPETH (Chineseyear, CHINESEMPH); if (chineSaith == 1) {chinoisyear ++; }} montant + = d - chinesedate; super.add (calendar.date, montant); } composeChineseFields (); } / ** * Calculez la date du calendrier lunaire à l'aide de la date grégorienne * / private void composeChineseFields () {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 = basemanth; startDate = basasedate; Chineseyear = BasEchineseyear; CHINESEMPH = BUSECHINESEMPETH; Chinedate = Basechinedate; } else {// Le deuxième jour correspondant est utilisé pour améliorer l'efficacité de l'informatique // 1er janvier 2000, le calendrier lunaire correspondant 4697 (1999), Startyear = Baseyear + 99; startMonth = 1; startDate = 1; Chineseyear = BasEchineseyear + 99; CHINESEMPH = 11; Chinedate = 25; } int DaysDiff = 0; // année pour (int i = startyear; i <gregorianyear; i ++) {if (isgregorianleapyear (i)) {DaysDiff + = 366; // Leap Year} else {DaysDiff + = 365; }} // mois pour (int i = startMonth; i <gregorianmonth; i ++) {DaysDiff + = DaysingRegorianMonth (Gregorianyear, i - 1); } // DaydaysDiff + = Gregoriandate - startDate; Chinedate + = DaysDiff; int LastDate = DaysInchineSemath (Chineseyear, chineonth); while (chinesedate> LastDate) {chinesedate - = lastDate; CHINESEMPH = NEXTCHINESEMPETH (Chineseyear, CHINESEMPH); if (chineSaith == 1) {chinoisyear ++; } LastDate = DaysInChineSonth (Chineseyear, ChineSaith); }} / ** * Calculer les termes solaires * / private void calcularterms () {int gregorianyear = internalGet (calendar.year); int gregorianmonth = internalget (calendar.month); if (gregorianyear <1901 || gregorianyear> 2100) {return; } sectionalterm = sectionalterm (Gregorianyear, Gregorianmonth); Principlem = Principalterm (Gregorianyear, Gregorianmonth); } / * Next est la méthode statique ~ * / / ** * est-ce une année de saut dans l'année grégorienne * * @param année * @return * / public static booléen isgregorianleapyear (int an) {boolean isleap = false; if (année% 4 == 0) {isleap = true; } if (année% 100 == 0) {isleap = false; } if (année% 400 == 0) {isleap = true; } return isleap; } / ** * Calculez le nombre de jours au cours de l'année grégorienne, et le mois grégorien commence à partir de 0! * * @param y * @param m * @return * / public static int waysingRegorianMonth (int y, int m) {int d = waysingregorianmonth [m]; if (m == calendar.february && isgregorianleapyear (y)) {d ++; // un jour de plus au cours d'une année leap au cours de l'année grégorienne} retour d; } / ** * Calculez les termes solaires du mois grégorien, le mois grégorien commence à partir de 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> = sectionalteryear [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; } Terme de retour; } / ** * Calculez le zhongqi de l'année grégorienne, et le mois grégorien commence à partir de 0! * * @param y * @param m * @return * / public static int plombleterm (int y, int m) {m ++; if (y <1901 || y> 2100) {return 0; } int index = 0; int ry = y - Baseyear + 1; while (ry> = principeTermyear [m - 1] [index]) {index ++; } int term = principaltermmap [m - 1] [4 * index + ry% 4]; if ((ry == 171) && (m == 3)) {term = 21; } if ((ry == 181) && (m == 5)) {term = 21; } Terme de retour; } / ** * Calculez le nombre de jours dans l'année lunaire * * @param y * @param m * @return * / public static int waysInChineSemm (int y, int m) {// note: leap mois m <0 int index = y - BasEchineseyear + BaseIndex; int v = 0; int l = 0; int d = 30; if (1 <= m && m <= 8) {v = chineSaitms [2 * index]; l = m - 1; if (((v >> l) & 0x01) == 1) {d = 29; }} else if (9 <= m && m <= 12) {v = chineSaiths [2 * index + 1]; l = m - 9; if (((v >> l) & 0x01) == 1) {d = 29; }} else {v = chineSaiths [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; casser; }}}} return d; } / ** * Calculez le mois suivant du calendrier lunaire * * @param y * @param m * @return * / public static int nextCheneSemm (int y, int m) {int n = math.abs (m) + 1; if (m> 0) {int index = y - BasEchineseear + BaseIndex; int v = chinesemonths [2 * index + 1]; v = (v >> 4) & 0x0f; if (v == m) {n = -m; }} if (n == 13) {n = 1; } return n; } / * Date du premier jour du calendrier * / private statique final int basyear = 1901; Final statique privé Int Basemonth = 1; INT-STATIQUE STATIQUE privé Base-Basedate = 1; private static final int basaseIndex = 0; Final statique privé int Basechineseyear = 1900; Final statique privé int BaseCheSechineSem = 11; Final statique privé Int Basechinedate = 11; / * Chaîne chinoise * / chaîne finale statique privée [] Chineseweeknoms = {"", "dimanche", "lundi", "mardi", "jeudi", "vendredi", "samedi"}; String final statique privé [] chinesemonthNames = {"", "premier", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix", "dix", "onze", "douze"}; 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", "Dixième", "dixième", "dixième", "dixième", "dixième", "dixième", "dixième", "dixième", "dixième"}; String final statique privée [] PrinciplemNames = {"Great Cold", "Rain Water", "Spring Equinox", "Green Rain", "Summer Solar", "Green Summer", "Green Summer", "Green Summer", "Green Summer", "Summer Solar", "Green Summer", "Starry Summer", "Sepce-Equinox", "Sept Equinox", "Frost Fall", "Light Snow", "WinterSice"}; chaîne finale statique privée [] sectiontermNames = {"Little Cold", "Bird Spring", "Jingzhe", "Qingming", "début de l'été", "graisses de grain", "Little Heat", "Bird Automne", "White Dew", "Cold Dew", "Breaking Winter", "High Snow"}; String final statique privé [] stremNames = {"", "jia", "yi", "bing", "ding", "wu", "ji", "geng", "xin", "ren", "gui"}; String final statique privé [] branchNames = {"", "zi", "ug", "yin", "mao", "Chen", "si", "wu", "shen", "vous", "xu", "hai"}; chaîne finale statique privée [] AnimalNames = {"", "rat", "ox", "tigre", "lapin", "dragon", "serpent", "cheval", "mouton", "singe", "poulet", "chien", "cochon"}; / * Ensuite, le tableau de compression des données ~ * / final statique privé 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, 5, 4, 4, 4, 5, 4, 4, 4, 4,, 5}, {6, 6, 6, 6, 6, 6, 6, 6,, 5, 6, 6, 6,, 5, 5, 5, 5, 5, 6, 6, 5, 5, 6, 6, 5, 5, 5, 6, 5, 5, 5, 5, 4, 5, 5, 5, 5}, {7, 8, 8, 8, 8, 7, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 7, 8, 7, 8, 8, 8, 7, 7, 8, 8, 7, 7, 7, 8, 7, 7, 7, 7, 6, 7, 7, 7, 7, 6,, 7, 7, 8, 8,, {8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9,, 8, 9, 9, 9, 8, 8,, 9, 9, 8, 8, 8, 9, 8, 8, 8, 8, 7,, 8, 8,, 8,, 8, 8, 8, 8}, {8, 8, 8, 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}}; Char final statique privé [] [] sectionalteryear = {{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, 66 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, 22, 23, 23, 23, 23, 22, 22, 23, 23, 22, 23, 23, 22, 23, {23, 24, 24, 24, 23, 23, 24, 23, {23, 24, 24, 24, 23, 23, 24, 24 2 23, 23, 23, 23, 23, 23, 22, 23, 23, 23, 22, 22, 23, 23, 23, 22, 22, 22, 23, 23, 23, 23, 24, 23, 23, 23, 23, 22, 23, 23, 23, 22, 22, 23, 23, 22, 22, 23, 23 23, 23, 24, 24,, 23, 23, 23, 24, 23, 23, 23, 23, 22, 23, 23, 23, 22, 22, 22, 23, 23, 23}, {23, 23, 22, 23, 22, 22, 23, 22, 22, 22, 23, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 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}}; Char final statique privé [] [] 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, {21, 49, 81, 116, 144, 176, 200, 201. 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, 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}}; charbon final statique privé [] dayingRegorianmonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31}; Char Final statique privé [] ChineSematHs = {0x00, 0x04, 0xad, 0x08, 0x5a, 0x01, 0xd5, 0x54, 0xb4, 0x09, 0x64, 0x05, 0x59, 0x45, 0x95, 0x95, 0x0a, 0xa6, 0x04, 0x55, 0x0a, 0xa6, 0x04, 0x55, 0x24, 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, 0x6d, 0x56, 0x01, 0xb5 0xa9, 0x56, 0xa5, 0x04, 0x2b, 0x09, 0x9e, 0x38, 0xb6, 0xd4, 0x0a, 0x74, 0x6c, 0x05 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, 0xd4, 0xad, 0xb4, 0xda, 0x04, 0xd4, 0x44, 0xb4 0x56, 0x6a, 0x56, 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, 0xd2, 0xac, 0x52, 0x6a, 0x05, 0xd2 0x2d, 0x0a, 0x5a, 0x02, 0x75, 0x61, 0xb5, 0x02, 0x6a, 0x03, 0x61, 0x45, 0xa9, 0x0a, 0x4a, 0x05 0xb4, 0x09, 0xa8, 0x59, 0x54, 0x03, 0xa5, 0x0a, 0x91, 0x3a, 0x96, 0x04, 0xad, 0xb0, 0xad, 0x04, 0xda, 0x04, 0xf4, 0x62, 0xb4, 0x05, 0xf4, 0x62, 0xb4, 0x05, 0xf4, 0x62, 0xb4, 0x05, 0xf4, 0x62, 0xb4, 0x05, 0x54, 0x04 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, 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}; String privé getCHineSeterm () {if (get (calendar.date) == get (chinois_sectional_term)) {return sectionalThames [get (calendar.month)]; } else if (get (calendar.date) == get (chinois_prinpile_term)) {return PrincipleTermNames [get (calendar.month)]; } else return null; } // Ajouter par SkyWang Private String getlunarfestival () {int day = get (chinois_date); int mois = get (chinois_month); String stoday = jour <10? "0" + jour: "" + jour; String smonth = mois <10? "0" + (mois): "+ (mois); return lfestival.get (smonth + stoday);} private string getolarfestival () {int day = get (calendar.date); int mois = get (calendar.month); string stoday = day <10?" 0 "+ day:" "+ day smonth = mois <10?" 0 "+ (mois + 1):" + 1); return sfestival.get (smonth + stoday); } String privé getFestivalorRmordate () {String ret; if ((ret = getolarfestival ())! = null) return ret; if ((ret = getlunarfestival ())! = null) return ret; return getchinese (get (chinois_term_or_date)); } // Gregorian Festival Private Static Hashmap <String, String> sfestival = new HashMap <String, String> (); // Lunar intervenait privé statique hashmap <string, string> lfestival = new hashmap <string, string> (); statique {sfestival.put ("0101", "jour du Nouvel An"); sfestival.put ("0214", "Valenteen Day"); sfestival.put ("0308", "Journée des femmes"); sfestival.put ("0312", "Day Arbor"); sfestival.put ("0401", "jour d'avril"); sfestival.put ("0501", "fête du travail"); sfestival.put ("0504", "Journée des jeunes"); sfestival.put ("0601", "Journée des enfants"); sfestival.put ("0701", "Jour du centre"); sfestival.put ("0801", "Jour de l'armée"); sfestival.put ("0910", "Journée des enseignants"); sfestival.put ("1001", "Journée nationale"); 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"); } }