Android lunar calendar to the Gregorian calendar (Public lunar calendar for each other) Time Selector

Android lunar calendar to the Gregorian calendar (Public lunar calendar for each other) Time Selector

Recently, the company is working on a time selector, which involves calendar replacement. There is nothing to do with a single selector, but there is a headache in calendar replacement. Below we will share the code of a calendar converter, there are a lot of online websites for the conversion from the Gregorian calendar to the lunar calendar, but the conversion from the lunar calendar to the Gregorian calendar is relatively small,

Directly run the Code:

Package com. openbook. mars. utils;


/**
* This type mainly supports interchange between the lunar calendar and the Gregorian calendar from 1900 to 2050.
* System. out. println (calendar test );
System. out. println (ChineseCalendarTwo. sCalendarLundarToSolar (2015, 9, 2); Agricultural Handover
System. out. println (ChineseCalendarTwo. sCalendarSolarToLundar (2015, 9, 2 );
*
*/
Public class ChineseCalendarTwo {
// Array lIntLunarDay is stored in the monthly day information in every year from 1901 to 2100 of the lunar calendar,
// The lunar calendar can only be 29 or 30 days every month, express with 12 (or 13) pieces of binary bit in one year,
// It is 30 days for 1 form in the corresponding location, otherwise it is 29 days
Public static final int [] iLunarMonthDaysTable = {0x4ae0, 0xa570, 0x5268, 0xd260, 0xd950, 0x6aa8, 0x56a0, 0x9ad0, 0x4ae8,
0x4ae0, // 1910
0xa4d8, 0xa4d0, 0xd250, 0xd548, 0xb550, 0x56a0, 0x96d0, 0x95b0, 0x49b8, 0x49b0, // 1920
0xa4b0, 0xb258, 0x6a50, 0x6d40, 0xada8, 0x2b60, 0x9570, 0x4978, 0x4970, 0x64b0, // 1930
0xd4a0, 0xea50, 0x6d48, 0x5ad0, 0x2b60, 0x9370, 0x92e0, 0xc968, 0xc950, 0xd4a0, // 1940
0xda50, 0xb550, 0x56a0, 0xaad8, 0x25d0, 0x92d0, 0xc958, 0xa950, 0xb4a8, 0x6ca0, // 1950
0xb550, 0x55a8, 0x4da0, 0xa5b0, 0x52b8, 0x52b0, 0xa950, 0xe950, 0x6aa0, 0xad50, // 1960
0xab50, 0x4b60, 0xa570, 0xa570, 0x5260, 0xe930, 0xd950, 0x5aa8, 0x56a0, 0x96d0, /// 1970
0x4ae8, 0x4ad0, 0xa4d0, 0xd268, 0xd250, 0xd528, 0xb540, 0xb6a0, 0x96d0, 0x95b0, // 1980
0x49b0, 0xa4b8, 0xa4b0, 0xb258, 0x6a50, 0x6d40, 0xada0, 0xab60, 0x9370, 0x4978, // 1990
0x4970, 0x64b0, 0x6a50, 0xea50, 0x6b28, 0x5ac0, 0xab60, 0x9368, 0x92e0, 0xc960, // 2000
0xd4a8, 0xd4a0, 0xda50, 0x5aa8, 0x56a0, 0xaad8, 0x25d0, 0x92d0, 0xc958, 0xa950, // 2010
0xb4a0, 0xb550, 0xb550, 0x55a8, 0x4ba0, 0xa5b0, 0x52b8, 0x52b0, 0xa930, 0x74a8, // 2020
0x6aa0, 0xad50, 0x4da8, 0x4b60, 0x9570, 0xa4e0, 0xd260, 0xe930, 0xd530, 0x5aa0, // 2030
0x6b50, 0x96d0, 0x4ae8, 0x4ad0, 0xa4d0, 0xd258, 0xd250, 0xd520, 0xdaa0, 0xb5a0, // 2040
0x56d0, 0x4ad8, 0x49b0, 0xa4b8, 0xa4b0, 0xaa50, 0xb528, 0x6d20, 0xada0, 0x55b0 // 2050
};


// Array iLunarLeapMonthTable preserves the lunar calendar leap month from 1901 to 2050,
// If it is 0 express not to have, every byte was stored for two years
Public static final char [] iLunarLeapMonthTable = {0x00, 0x50, 0x04, 0x00, 0x20, // 1910
0x60, 0x05, 0x00, 0x20, 0x70, // 1920
0x05, 0x00, 0x40, 0x02, 0x06, // 1930
0x00, 0x50, 0x03, 0x07, 0x00, // 1940
0x60, 0x04, 0x00, 0x20, 0x70, // 1950
0x05, 0x00, 0x30, 0x80, 0x06, // 1960
0x00, 0x40, 0x03, 0x07, 0x00, // 1970
0x50, 0x04, 0x08, 0x00, 0x60, // 1980
0x04, 0x0a, 0x00, 0x60, 0x05, // 1990
0x00, 0x30, 0x80, 0x05, 0x00, // 2000
0x40, 0x02, 0x07, 0x00, 0x50, // 2010
0x04, 0x09, 0x00, 0x60, 0x04, // 2020
0x00, 0x20, 0x60, 0x05, 0x00, // 2030
0x30, 0xb0, 0x06, 0x00, 0x50, // 2040
0x02, 0x07, 0x00, 0x50, 0x03 // 2050
};


// Array iSolarLunarTable stored the offset days
// In New Year of solar calendar and lunar calendar from 1901 to 2050;
Private static final char [] iSolarLunarOffsetTable = {49, 38, 28, 46, 34, 24, 43, 32, 21, 40, // 1910
29, 48, 36, 25, 44, 34, 22, 41, 31, 50, // 1920
38, 27, 46, 35, 23, 43, 32, 22, 40, 29, // 1930
47, 36, 25, 44, 34, 23, 41, 30, 49, 38, // 1940
26, 45, 35, 24, 43, 32, 21, 40, 28, 47, // 1950
36, 26, 44, 33, 23, 42, 30, 48, 38, 27, // 1960
45, 35, 24, 43, 32, 20, 39, 29, 47, 36, // 1970
26, 45, 33, 22, 41, 30, 48, 37, 27, 46, // 1980
35, 24, 43, 32, 50, 39, 28, 47, 36, 26, // 1990
45, 34, 22, 40, 30, 49, 37, 27, 46, 35, // 2000
23, 42, 31, 21, 39, 28, 48, 37, 25, 44, // 2010
33, 23, 41, 31, 50, 39, 28, 47, 35, 24, // 2020
42, 30, 21, 40, 28, 47, 36, 25, 43, 33, // 2030
22, 41, 30, 49, 37, 26, 44, 33, 23, 42, // 2040
31, 21, 40, 29, 47, 36, 25, 44, 32, 22, // 2050
};


Static boolean bIsSolarLeapYear (int iYear ){
Return (iYear % 4 = 0) & (iYear % 100! = 0) | iYear % 400 = 0 );
}


// Days in the Gregorian Calendar
Static int iGetSYearMonthDays (int iYear, int iMonth ){
If (iMonth = 1) | (iMonth = 3) | (iMonth = 5) | (iMonth = 7) | (iMonth = 8) | (iMonth = 10) | (iMonth = 12 ))
Return 31;
Else if (iMonth = 4) | (iMonth = 6) | (iMonth = 9) | (iMonth = 11 ))
Return 30;
Else if (iMonth = 2 ){
If (bIsSolarLeapYear (iYear ))
Return 29;
Else
Return 28;
} Else
Return 0;
}


// Offset the day of the new year, indicating the day of the Gregorian calendar
Static int iGetSNewYearOffsetDays (int iYear, int iMonth, int iDay ){
Int iOffsetDays = 0;


For (int I = 1; I <iMonth; I ++ ){
IOffsetDays + = iGetSYearMonthDays (iYear, I );
}
IOffsetDays + = iDay-1;


Return iOffsetDays;
}


Static int iGetLLeapMonth (int iYear ){
Char iMonth = iLunarLeapMonthTable [(iYear-1901)/2];


If (iYear % 2 = 0)
Return (iMonth & 0x0f );
Else
Return (iMonth & 0xf0)> 4;
}


Static int iGetLMonthDays (int iYear, int iMonth ){
Int iLeapMonth = iGetLLeapMonth (iYear );
If (iMonth> 12) & (iMonth-12! = ILeapMonth) | (iMonth <0 )){
System. out. println (Wrong month, interval _^, I think you are want a-1, go to death !);
Return-1;
}
If (iMonth-12 = iLeapMonth ){
If (iLunarMonthDaysTable [iYear-1901] & (0x8000> iLeapMonth) = 0)
Return 29;
Else
Return 30;
}
If (iLeapMonth> 0) & (iMonth> iLeapMonth ))
IMonth ++;
If (iLunarMonthDaysTable [iYear-1901] & (0x8000> (iMonth-1) = 0)
Return 29;
Else
Return 30;
}


// Day of the lunar calendar of this year
Static int iGetLYearDays (int iYear ){
Int iYearDays = 0;
Int iLeapMonth = iGetLLeapMonth (iYear );


For (int I = 1; I <13; I ++)
IYearDays + = iGetLMonthDays (iYear, I );
If (iLeapMonth> 0)
IYearDays + = iGetLMonthDays (iYear, iLeapMonth + 12 );
Return iYearDays;
}


Static int iGetLNewYearOffsetDays (int iYear, int iMonth, int iDay ){
Int iOffsetDays = 0;
Int iLeapMonth = iGetLLeapMonth (iYear );


If (iLeapMonth> 0) & (iLeapMonth = iMonth-12 )){
IMonth = iLeapMonth;
IOffsetDays + = iGetLMonthDays (iYear, iMonth );
}


For (int I = 1; I <iMonth; I ++ ){
IOffsetDays + = iGetLMonthDays (iYear, I );
If (I = iLeapMonth)
IOffsetDays + = iGetLMonthDays (iYear, iLeapMonth + 12 );
}
IOffsetDays + = iDay-1;


Return iOffsetDays;
}



/** The Gregorian calendar is changed to the lunar calendar.
* @ Param iYear
* @ Param iMonth
* @ Param iDay
* @ Return
*/
Public static String sCalendarSolarToLundar (int iYear, int iMonth, int iDay ){
Int iLDay, iLMonth, iLYear;
Int iOffsetDays = iGetSNewYearOffsetDays (iYear, iMonth, iDay-1 );
Int iLeapMonth = iGetLLeapMonth (iYear );


If (iOffsetDays <iSolarLunarOffsetTable [iYear-1901]) {
ILYear = iYear-1;
IOffsetDays = iSolarLunarOffsetTable [iYear-1901]-iOffsetDays;
ILDay = iOffsetDays;


For (iLMonth = 12; iOffsetDays> iGetLMonthDays (iLYear, iLMonth); iLMonth --){
ILDay = iOffsetDays;
IOffsetDays-= iGetLMonthDays (iLYear, iLMonth );
}
If (0 = iLDay)
ILDay = 1;
Else
ILDay = iGetLMonthDays (iLYear, iLMonth)-iOffsetDays + 1;
} Else {
ILYear = iYear;
IOffsetDays-= iSolarLunarOffsetTable [iYear-1901];
ILDay = iOffsetDays + 1;


For (iLMonth = 1; iOffsetDays> = 0; iLMonth ++ ){
ILDay = iOffsetDays + 1;
IOffsetDays-= iGetLMonthDays (iLYear, iLMonth );
If (iLeapMonth = iLMonth) & (iOffsetDays> 0 )){
ILDay = iOffsetDays;
IOffsetDays-= iGetLMonthDays (iLYear, iLMonth + 12 );
If (iOffsetDays <= 0 ){
ILMonth + = 12 + 1;
Break;
}
}
}
ILMonth --;
}
Return + iLYear + (iLMonth> 9? + ILMonth: 0 + iLMonth) + (iLDay> 9? + ILDay: 0 + iLDay );
}


/** The lunar calendar changes to the Gregorian Calendar
* @ Param iYear
* @ Param iMonth
* @ Param iDay
* @ Return
*/
Public static String sCalendarLundarToSolar (int iYear, int iMonth, int iDay ){
Int iSYear, iSMonth, iSDay;
Int iOffsetDays = iGetLNewYearOffsetDays (iYear, iMonth, iDay + 1) + iSolarLunarOffsetTable [iYear-1901];
Int iYearDays = bIsSolarLeapYear (iYear )? 366: 365;


If (iOffsetDays> = iYearDays ){
ISYear = iYear + 1;
IOffsetDays-= iYearDays;
} Else {
ISYear = iYear;
}
ISDay = iOffsetDays + 1;
For (iSMonth = 1; iOffsetDays> = 0; iSMonth ++ ){
ISDay = iOffsetDays + 1;
IOffsetDays-= iGetSYearMonthDays (iSYear, iSMonth );
}
ISMonth --;


Return + iSYear + (iSMonth> 9? ISMonth +: 0 + iSMonth) + (iSDay> 9? ISDay +: 0 + iSDay );
}
}


// Customize the week class
Class Week {
Int iWeek;


Private String sWeek [] = {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };


Public Week (){
IWeek = 0;
}


Public Week (int w ){
If (w> 6) | (w <0 )){
System. out. println (Week out of range, I think you want Sunday );
This. iWeek = 0;
} Else
This. iWeek = w;
}


Public String toString (){
Return sWeek [iWeek];
}
}


// Custom date class
Class MyDate {


Public int iYear;


Public int iMonth;


Public int iDay;


Private static int checkYear (int iYear ){
If (iYear> 1901) & (iYear <2050 ))
Return iYear;
Else {
System. out. println (The Year out of range, I think you want 1981 );
Return 1981;
}
}


Public MyDate (int iYear, int iMonth, int iDay ){
This. iYear = checkYear (iYear );
This. iMonth = iMonth;
This. iDay = iDay;
}


Public MyDate (int iYear, int iMonth ){
This. iYear = checkYear (iYear );
This. iMonth = iMonth;
This. iDay = 1;
}


Public MyDate (int iYear ){
This. iYear = checkYear (iYear );
This. iMonth = 1;
This. iDay = 1;
}


Public MyDate (){
This. iYear = 1981;
This. iMonth = 1;
This. iDay = 1;
}


Public String toString (){
Return + this. iYear + (this. iMonth> 9? + This. iMonth: 0 + this. iMonth)
+ (This. iDay> 9? + This. iDay: 0 + this. iDay );
}


Public boolean equals (MyDate md ){
Return (md. iDay = this. iDay) & (md. iMonth = this. iMonth) & (md. iYear = this. iYear ));
}
}


// Calendar date class, inheriting custom date
Class SolarDate extends MyDate {


Private static int checkMonth (int iMonth ){
If (iMonth> 12 ){
System. out. println (Month out of range, I think you want 12 );
Return 12;
} Else if (iMonth <1 ){
System. out. println (Month out of range, I think you want 1 );
Return 1;
} Else
Return iMonth;
}


Private static int checkDay (int iYear, int iMonth, int iDay ){
Int iMonthDays = ChineseCalendarTwo. iGetSYearMonthDays (iYear, iMonth );


If (iDay> iMonthDays ){
System. out. println (Day out of range, I think you want + iMonthDays + );
Return iMonthDays;
} Else if (iDay <1 ){
System. out. println (Day out of range, I think you want 1 );
Return 1;
} Else
Return iDay;
}


Public SolarDate (int iYear, int iMonth, int iDay ){
Super (iYear );
This. iMonth = checkMonth (iMonth );
This. iDay = checkDay (this. iYear, this. iMonth, iDay );
}


Public SolarDate (int iYear, int iMonth ){
Super (iYear );
This. iMonth = checkMonth (iMonth );
}


Public SolarDate (int iYear ){
Super (iYear );
}


Public SolarDate (){
Super ();
}


Public String toString (){
Return + this. iYear + (this. iMonth> 9? -+ This. iMonth:-0 + this. iMonth)
+ (This. iDay> 9? -+ This. iDay:-0 + this. iDay );
}


Public Week toWeek (){
Int iOffsetDays = 0;
For (int I = 1901; I <iYear; I ++ ){
If (ChineseCalendarTwo. bIsSolarLeapYear (I ))
IOffsetDays ++ = 366;
Else
IOffsetDays ++ = 365;
}


IOffsetDays + = ChineseCalendarTwo. iGetSNewYearOffsetDays (iYear, iMonth, iDay );
Return new Week (iOffsetDays + 2) % 7 );
}


Public LunarDate toLunarDate (){
Int iYear, iMonth, iDay, iDate;
LunarDate ld;
IDate = Integer. parseInt (ChineseCalendarTwo. sCalendarSolarToLundar (this. iYear, this. iMonth, this. iDay ));
IYear = iDate/10000;
IMonth = iDate %10000/100;
IDay = iDate %100;
Ld = new LunarDate (iYear, iMonth, iDay );
Return ld;
}
}


// Lunar date class, inheriting the custom date class
Class LunarDate extends MyDate {


Private String sChineseNum [] = {zero, one, two, three, four, five, six, seven, eight, nine, ten };


Private static int checkMonth (int iYear, int iMonth ){
If (iMonth> 12) & (iMonth = ChineseCalendarTwo. iGetLLeapMonth (iYear) + 12 )){
Return iMonth;
} Else if (iMonth> 12 ){
System. out. println (Month out of range, I think you want 12 );
Return 12;
} Else if (iMonth <1 ){
System. out. println (Month out of range, I think you want 1 );
Return 1;
} Else
Return iMonth;
}


Private static int checkDay (int iYear, int iMonth, int iDay ){
Int iMonthDays = ChineseCalendarTwo. iGetLMonthDays (iYear, iMonth );


If (iDay> iMonthDays ){
System. out. println (Day out of range, I think you want + iMonthDays + );
Return iMonthDays;
} Else if (iDay <1 ){
System. out. println (Day out of range, I think you want 1 );
Return 1;
} Else
Return iDay;
}


Public LunarDate (int iYear, int iMonth, int iDay ){
Super (iYear );
This. iMonth = checkMonth (this. iYear, iMonth );
This. iDay = checkDay (this. iYear, this. iMonth, iDay );
}


Public LunarDate (int iYear, int iMonth ){
Super (iYear );
This. iMonth = checkMonth (this. iYear, iMonth );
}


Public LunarDate (int iYear ){
Super (iYear );
}


Public LunarDate (){
Super ();
}


Public String toString (){
String sCalendar = lunar calendar;


SCalendar + = sChineseNum [iYear/1000] + sChineseNum [iYear % 1000/100] + sChineseNum [iYear % 100/10]
+ SChineseNum [iYear % 10] + (+ toChineseEra () +) year;
If (iMonth> 12 ){
IMonth-= 12;
SCalendar + = scaling;
}
If (iMonth = 12)
SCalendar + = lunar December;
Else if (iMonth = 11)
SCalendar + = lunar November;
Else if (iMonth = 1)
SCalendar + = lunar January;
Else
SCalendar + = sChineseNum [iMonth] + month;
If (iDay> 29)
SCalendar + = thirty;
Else if (iDay> 20)
SCalendar + = 20 + sChineseNum [iDay % 20];
Else if (iDay = 20)
SCalendar + = 20;
Else if (iDay> 10)
SCalendar + = 10 + sChineseNum [iDay % 10];
Else
SCalendar + = + + sChineseNum [iDay];


Return sCalendar;
}


Public CnWeek toWeek (){
Int iOffsetDays = 0;
For (int I = 1901; I <iYear; I ++)
IOffsetDays + = ChineseCalendarTwo. iGetLYearDays (I );


IOffsetDays + = ChineseCalendarTwo. iGetLNewYearOffsetDays (iYear, iMonth, iDay );
Return new CnWeek (iOffsetDays + 2) % 7 );
}


Public ChineseEra toChineseEra (){
Return new ChineseEra (iYear );
}


Public SolarDate toSolarDate (){
Int iYear, iMonth, iDay, iDate;
SolarDate sd;
IDate = Integer. parseInt (ChineseCalendarTwo. sCalendarLundarToSolar (this. iYear, this. iMonth, this. iDay ));
IYear = iDate/10000;
IMonth = iDate %10000/100;
IDay = iDate %100;
Sd = new SolarDate (iYear, iMonth, iDay );
Return sd;
}
}


Class CnWeek extends Week {


Private String sCnWeek [] = {day, one, two, three, four, five, six };


Public CnWeek (){
Super ();
}


Public CnWeek (int iWeek ){
Super (iWeek );
}


Public String toString (){
Return week + sCnWeek [this. iWeek];
}
}


Class ChineseEra {
Int iYear;


String [] sHeavenlyStems = {A, B, C, ding, E, Ji, Geng, Xin, Yi, Xi };


String [] searlybranches = {Child, ugly, Yin, Mao, Chen, Si, Wu, Wei, Shen, you, Chen, Hai };


Public ChineseEra (){
Int iYear = 1981;
}


Public ChineseEra (int iYear ){
If (iYear <2050) & (iYear> 1901 ))
This. iYear = iYear;
Else
This. iYear = 1981;
}


Public String toString (){
Int temp;
Temp = Math. abs (iYear-1924 );
Return sHeavenlyStems [temp % 10] + searlybranches [temp % 12];
}
}

Complete the time selector and share it all.