اشکالی نداره، باید jdk 8 رو داشته باشید.
اون چند خط رو حذف کنید اصلا.
import java.io.Serializable;
import java.util.Calendar;
import java.util.Date;
import java.util.Objects;
public class PersianCalendar implements Serializable, Cloneable, Comparable<PersianCalendar> {
private static final int[] BUF_1 = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
private static final int[] BUF_2 = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335};
private static final String[] MONTH_STR = {
"فروردين",
"ارديبهشت",
"خرداد",
"تير",
"مرداد",
"شهريور",
"مهر",
"آبان",
"آذر",
"دي",
"بهمن",
"اسفند"
};
private static final String[] WEEK_DAY_STR = {
"يکشنبه",
"دوشنبه",
"سه شنبه",
"چهارشنبه",
"پنج شنبه",
"جمعه",
"شنبه"
};
private Calendar calendar;
private int year;
private int month;
private int date;
private int weekDay;
private int hour;
private int minute;
private int second;
public static PersianCalendar fromGregorianCalendar(int year, int month, int date) {
Calendar calendar = Calendar.getInstance();
calendar.set(year, month, date);
return new PersianCalendar(calendar);
}
public static PersianCalendar fromGregorianCalendar(int year, int month, int date, int hourOfDay, int minute, int second) {
Calendar calendar = Calendar.getInstance();
calendar.set(year, month, date, hourOfDay, minute, second);
return new PersianCalendar(calendar);
}
public PersianCalendar() {
this(Calendar.getInstance());
}
private PersianCalendar(Calendar calendar) {
this.calendar = calendar;
weekDay = calendar.get(Calendar.DAY_OF_WEEK);
hour = calendar.get(Calendar.HOUR_OF_DAY);
minute = calendar.get(Calendar.MINUTE);
second = calendar.get(Calendar.SECOND);
calPersianCalendar(calendar.get(Calendar.YEAR),
calendar.get(Calendar.MONTH) + 1,
calendar.get(Calendar.DATE));
}
private void calPersianCalendar(int gYear, int gMonth, int gDate) {
int ld;
if (gYear % 4 == 0) {
date = BUF_2[gMonth - 1] + gDate;
ld = gYear >= 1996 ? 79 : 80;
} else {
date = BUF_1[gMonth - 1] + gDate;
ld = 79;
}
if (date > ld) {
date -= ld;
if (date <= 186) {
if (date % 31 == 0) {
month = date / 31;
date = 31;
} else {
month = date / 31 + 1;
date %= 31;
}
} else {
date -= 186;
if (date % 30 == 0) {
month = date / 30 + 6;
date = 30;
} else {
month = date / 30 + 7;
date %= 30;
}
}
year = gYear - 621;
} else {
ld = gYear % 4 == 0 ? 10 : gYear > 1996 && gYear % 4 == 1 ? 11 : 10;
date += ld;
if (date % 30 == 0) {
month = date / 30 + 9;
date = 30;
} else {
month = date / 30 + 10;
date %= 30;
}
year = gYear - 622;
}
}
public String getMonth() {
return MONTH_STR[month - 1];
}
public String getWeekDay() {
return WEEK_DAY_STR[weekDay - 1];
}
public String getDateString() {
return String.valueOf(year) + "/" + String.valueOf(month) + "/" + String.valueOf(date);
}
public String getTimeString() {
return (hour < 10 ? "0" + hour : hour) + ":"
+ (minute < 10 ? "0" + minute : minute) + ":"
+ (second < 10 ? "0" + second : second);
}
public String getDateTimeString() {
return getDateString() + " " + getTimeString();
}
public Date getTime() {
return calendar.getTime();
}
public long getTimeInMillis() {
return calendar.getTimeInMillis();
}
@Override
public String toString() {
return getWeekDay() + " " + String.valueOf(date) + " " + getMonth() + " " + String.valueOf(year) + " ه.ش ساعت " + getTimeString();
}
@Override
public Object clone() {
try {
PersianCalendar other = (PersianCalendar) super.clone();
other.calendar = (Calendar) calendar.clone();
return other;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
@Override
public int compareTo(PersianCalendar o) {
Objects.requireNonNull(o);
return calendar.compareTo(o.calendar);
}
public static void main(String[] args) {
// PersianCalendar calendar = new PersianCalendar();
PersianCalendar calendar = PersianCalendar.fromGregorianCalendar(2015, Calendar.JUNE, 13);
System.out.println(calendar);
System.out.println(calendar.getDateTimeString());
System.out.println(calendar.getTime());
}
}
از این کلاس هم میتونید استفاده کنید. میلادی به شمسی و برعکسش رو هم بهتون میده :
import java.util.Calendar;
import java.util.GregorianCalendar;
/**
* Title: Calender Conversion class
* Description: Convert Iranian (Jalali), Julian, and Gregorian dates to
* each other
* Public Methods Summary:
* -----------------------
* JavaSource_Calendar();
* JavaSource_Calendar(int year, int month, int day);
* int getIranianYear();
* int getIranianMonth();
* int getIranianDay();
* int getGregorianYear();
* int getGregorianMonth();
* int getGregorianDay();
* int getJulianYear();
* int getJulianMonth();
* int getJulianDay();
* String getIranianDate();
* String getGregorianDate();
* String getJulianDate();
* String getWeekDayStr();
* String toString();
* int getDayOfWeek();
* void nextDay();
* void nextDay(int days);
* void previousDay();
* void previousDay(int days);
* void setIranianDate(int year, int month, int day);
* void setGregorianDate(int year, int month, int day);
* void setJulianDate(int year, int month, int day);
*/
public class CalendarTool {
public static final int FARVARDIN = 0;
public static final int ORDIBEHESHT = 1;
public static final int KHORDAD = 2;
public static final int TIR = 3;
public static final int MORDAD = 4;
public static final int SHAHRIVAR = 5;
public static final int MEHR = 6;
public static final int ABAN = 7;
public static final int AZAR = 8;
public static final int DEY = 9;
public static final int BAHMAN = 10;
public static final int ESFAND = 11;
private static final String WEEK_DAY_STR[] = {
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday"};
private int irYear; // Year part of a Iranian date
private int irMonth; // Month part of a Iranian date
private int irDay; // Day part of a Iranian date
private int gYear; // Year part of a Gregorian date
private int gMonth; // Month part of a Gregorian date
private int gDay; // Day part of a Gregorian date
private int juYear; // Year part of a Julian date
private int juMonth; // Month part of a Julian date
private int juDay; // Day part of a Julian date
private int leap; // Number of years since the last leap year (0 to 4)
private int JDN; // Julian Day Number
private int march; // The march day of Farvardin the first (First day of jaYear)
/**
* JavaSource_Calendar:
* The default constructor uses the current Gregorian date to initialize the
* other private members of the class (Iranian and Julian dates).
*/
public CalendarTool() {
Calendar calendar = new GregorianCalendar();
setGregorianDate(calendar.get(Calendar.YEAR),
calendar.get(Calendar.MONTH) + 1,
calendar.get(Calendar.DAY_OF_MONTH));
}
/**
* JavaSource_Calendar:
* This constructor receives a Gregorian date and initializes the other private
* members of the class accordingly.
*
* @param year int
* @param month int
* @param day int
*/
public CalendarTool(int year, int month, int day) {
setGregorianDate(year, month, day);
}
/**
* getIranianYear:
* Returns the 'year' part of the Iranian date.
*
* @return int
*/
public int getIranianYear() {
return irYear;
}
/**
* getIranianMonth:
* Returns the 'month' part of the Iranian date.
*
* @return int
*/
public int getIranianMonth() {
return irMonth;
}
/**
* getIranianDay:
* Returns the 'day' part of the Iranian date.
*
* @return int
*/
public int getIranianDay() {
return irDay;
}
/**
* getGregorianYear:
* Returns the 'year' part of the Gregorian date.
*
* @return int
*/
public int getGregorianYear() {
return gYear;
}
/**
* getGregorianMonth:
* Returns the 'month' part of the Gregorian date.
*
* @return int
*/
public int getGregorianMonth() {
return gMonth;
}
/**
* getGregorianDay:
* Returns the 'day' part of the Gregorian date.
*
* @return int
*/
public int getGregorianDay() {
return gDay;
}
/**
* getJulianYear:
* Returns the 'year' part of the Julian date.
*
* @return int
*/
public int getJulianYear() {
return juYear;
}
/**
* getJulianMonth:
* Returns the 'month' part of the Julian date.
*
* @return int
*/
public int getJulianMonth() {
return juMonth;
}
/**
* getJulianDay()
* Returns the 'day' part of the Julian date.
*
* @return int
*/
public int getJulianDay() {
return juDay;
}
/**
* getIranianDate:
* Returns a string version of Iranian date
*
* @return String
*/
public String getIranianDate() {
return (irYear + "/" + irMonth + "/" + irDay);
}
/**
* getGregorianDate:
* Returns a string version of Gregorian date
*
* @return String
*/
public String getGregorianDate() {
return (gYear + "/" + gMonth + "/" + gDay);
}
/**
* getJulianDate:
* Returns a string version of Julian date
*
* @return String
*/
public String getJulianDate() {
return (juYear + "/" + juMonth + "/" + juDay);
}
/**
* getWeekDayStr:
* Returns the week day name.
*
* @return String
*/
public String getWeekDayStr() {
return (WEEK_DAY_STR[getDayOfWeek()]);
}
/**
* toString:
* Overrides the default toString() method to return all dates.
*
* @return String
*/
@Override
public String toString() {
return (getWeekDayStr() +
", Gregorian:[" + getGregorianDate() +
"], Julian:[" + getJulianDate() +
"], Iranian:[" + getIranianDate() + "]");
}
/**
* getDayOfWeek:
* Returns the week day number. Monday=0..Sunday=6;
*
* @return int
*/
public int getDayOfWeek() {
return (JDN % 7);
}
/**
* nextDay:
* Go to next julian day number (JDN) and adjusts the other dates.
*/
public void nextDay() {
JDN++;
JDNToIranian();
JDNToJulian();
JDNToGregorian();
}
/**
* nextDay:
* Overload the nextDay() method to accept the number of days to go ahead and
* adjusts the other dates accordingly.
*
* @param days int
*/
public void nextDay(int days) {
JDN += days;
JDNToIranian();
JDNToJulian();
JDNToGregorian();
}
/**
* previousDay:
* Go to previous julian day number (JDN) and adjusts the other dates.
*/
public void previousDay() {
JDN--;
JDNToIranian();
JDNToJulian();
JDNToGregorian();
}
/**
* previousDay:
* Overload the previousDay() method to accept the number of days to go backward
* and adjusts the other dates accordingly.
*
* @param days int
*/
public void previousDay(int days) {
JDN -= days;
JDNToIranian();
JDNToJulian();
JDNToGregorian();
}
/**
* setIranianDate:
* Sets the date according to the Iranian calendar and adjusts the other dates.
*
* @param year int
* @param month int
* @param day int
*/
public void setIranianDate(int year, int month, int day) {
irYear = year;
irMonth = month;
irDay = day;
JDN = IranianDateToJDN();
JDNToIranian();
JDNToJulian();
JDNToGregorian();
}
/**
* setGregorianDate:
* Sets the date according to the Gregorian calendar and adjusts the other dates.
*
* @param year int
* @param month int
* @param day int
*/
public void setGregorianDate(int year, int month, int day) {
gYear = year;
gMonth = month;
gDay = day;
JDN = gregorianDateToJDN(year, month, day);
JDNToIranian();
JDNToJulian();
JDNToGregorian();
}
/**
* setJulianDate:
* Sets the date according to the Julian calendar and adjusts the other dates.
*
* @param year int
* @param month int
* @param day int
*/
public void setJulianDate(int year, int month, int day) {
juYear = year;
juMonth = month;
juDay = day;
JDN = julianDateToJDN(year, month, day);
JDNToIranian();
JDNToJulian();
JDNToGregorian();
}
/**
* IranianCalendar:
* This method determines if the Iranian (Jalali) year is leap (366-day long)
* or is the common year (365 days), and finds the day in March (Gregorian
* Calendar)of the first day of the Iranian year ('irYear').Iranian year (irYear)
* ranges from (-61 to 3177).This method will set the following private data
* members as follows:
* leap: Number of years since the last leap year (0 to 4)
* Gy: Gregorian year of the beginning of Iranian year
* march: The March day of Farvardin the 1st (first day of jaYear)
*/
private void IranianCalendar() {
// Iranian years starting the 33-year rule
int Breaks[] =
{-61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181,
1210, 1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178};
int jm, N, leapJ, leapG, jp, j, jump;
gYear = irYear + 621;
leapJ = -14;
jp = Breaks[0];
// Find the limiting years for the Iranian year 'irYear'
j = 1;
do {
jm = Breaks[j];
jump = jm - jp;
if (irYear >= jm) {
leapJ += (jump / 33 * 8 + (jump % 33) / 4);
jp = jm;
}
j++;
} while (j < 20 && irYear >= jm);
N = irYear - jp;
// Find the number of leap years from AD 621 to the beginning of the current
// Iranian year in the Iranian (Jalali) calendar
leapJ += (N / 33 * 8 + ((N % 33) + 3) / 4);
if (jump % 33 == 4 && jump - N == 4)
leapJ++;
// And the same in the Gregorian date of Farvardin the first
leapG = gYear / 4 - ((gYear / 100 + 1) * 3 / 4) - 150;
march = 20 + leapJ - leapG;
// Find how many years have passed since the last leap year
if (jump - N < 6)
N = N - jump + ((jump + 4) / 33 * 33);
leap = ((N + 1) % 33 - 1) % 4;
if (leap == -1)
leap = 4;
}
/**
* IsLeap:
* This method determines if the Iranian (Jalali) year is leap (366-day long)
* or is the common year (365 days), and finds the day in March (Gregorian
* Calendar)of the first day of the Iranian year ('irYear').Iranian year (irYear)
* ranges from (-61 to 3177).This method will set the following private data
* members as follows:
* leap: Number of years since the last leap year (0 to 4)
* Gy: Gregorian year of the beginning of Iranian year
* march: The March day of Farvardin the 1st (first day of jaYear)
*/
public boolean IsLeap(int irYear1) {
// Iranian years starting the 33-year rule
int Breaks[] =
{-61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181,
1210, 1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178};
int jm, N, leapJ, leapG, jp, j, jump;
gYear = irYear1 + 621;
leapJ = -14;
jp = Breaks[0];
// Find the limiting years for the Iranian year 'irYear'
j = 1;
do {
jm = Breaks[j];
jump = jm - jp;
if (irYear1 >= jm) {
leapJ += jump / 33 * 8 + jump % 33 / 4;
jp = jm;
}
j++;
} while (j < 20 && irYear1 >= jm);
N = irYear1 - jp;
// Find the number of leap years from AD 621 to the beginning of the current
// Iranian year in the Iranian (Jalali) calendar
leapJ += (N / 33 * 8 + ((N % 33) + 3) / 4);
if (jump % 33 == 4 && jump - N == 4)
leapJ++;
// And the same in the Gregorian date of Farvardin the first
leapG = gYear / 4 - ((gYear / 100 + 1) * 3 / 4) - 150;
march = 20 + leapJ - leapG;
// Find how many years have passed since the last leap year
if ((jump - N) < 6)
N = N - jump + ((jump + 4) / 33 * 33);
leap = ((N + 1) % 33 - 1) % 4;
if (leap == -1)
leap = 4;
return leap == 4 || leap == 0;
}
/**
* IranianDateToJDN:
* Converts a date of the Iranian calendar to the Julian Day Number. It first
* invokes the 'IranianCalender' private method to convert the Iranian date to
* Gregorian date and then returns the Julian Day Number based on the Gregorian
* date. The Iranian date is obtained from 'irYear'(1-3100),'irMonth'(1-12) and
* 'irDay'(1-29/31).
*
* @return long (Julian Day Number)
*/
private int IranianDateToJDN() {
IranianCalendar();
return (gregorianDateToJDN(gYear, 3, march) + (irMonth - 1) * 31 - irMonth / 7 * (irMonth - 7) + irDay - 1);
}
/**
* JDNToIranian:
* Converts the current value of 'JDN' Julian Day Number to a date in the
* Iranian calendar. The caller should make sure that the current value of
* 'JDN' is set correctly. This method first converts the JDN to Gregorian
* calendar and then to Iranian calendar.
*/
private void JDNToIranian() {
JDNToGregorian();
irYear = gYear - 621;
IranianCalendar(); // This invocation will update 'leap' and 'march'
int JDN1F = gregorianDateToJDN(gYear, 3, march);
int k = JDN - JDN1F;
if (k >= 0) {
if (k <= 185) {
irMonth = 1 + k / 31;
irDay = (k % 31) + 1;
return;
} else
k -= 186;
} else {
irYear--;
k += 179;
if (leap == 1)
k++;
}
irMonth = 7 + k / 30;
irDay = (k % 30) + 1;
}
/**
* julianDateToJDN:
* Calculates the julian day number (JDN) from Julian calendar dates. This
* integer number corresponds to the noon of the date (i.e. 12 hours of
* Universal Time). This method was tested to be good (valid) since 1 March,
* -100100 (of both calendars) up to a few millions (10^6) years into the
* future. The algorithm is based on D.A.Hatcher, Q.Jl.R.Astron.Soc. 25(1984),
* 53-55 slightly modified by K.M. Borkowski, Post.Astron. 25(1987), 275-279.
*
* @param year int
* @param month int
* @param day int
* @return int
*/
private int julianDateToJDN(int year, int month, int day) {
return (year + (month - 8) / 6 + 100100) * 1461 / 4 + (153 * ((month + 9) % 12) + 2) / 5 + day - 34840408;
}
/**
* JDNToJulian:
* Calculates Julian calendar dates from the julian day number (JDN) for the
* period since JDN=-34839655 (i.e. the year -100100 of both calendars) to
* some millions (10^6) years ahead of the present. The algorithm is based on
* D.A. Hatcher, Q.Jl.R.Astron.Soc. 25(1984), 53-55 slightly modified by K.M.
* Borkowski, Post.Astron. 25(1987), 275-279).
*/
private void JDNToJulian() {
int j = 4 * JDN + 139361631;
int i = j % 1461 / 4 * 5 + 308;
juDay = i % 153 / 5 + 1;
juMonth = i / 153 % 12 + 1;
juYear = j / 1461 - 100100 + (8 - juMonth) / 6;
}
/**
* gregorianDateToJDN:
* Calculates the julian day number (JDN) from Gregorian calendar dates. This
* integer number corresponds to the noon of the date (i.e. 12 hours of
* Universal Time). This method was tested to be good (valid) since 1 March,
* -100100 (of both calendars) up to a few millions (10^6) years into the
* future. The algorithm is based on D.A.Hatcher, Q.Jl.R.Astron.Soc. 25(1984),
* 53-55 slightly modified by K.M. Borkowski, Post.Astron. 25(1987), 275-279.
*
* @param year int
* @param month int
* @param day int
* @return int
*/
private int gregorianDateToJDN(int year, int month, int day) {
int jdn = (year + (month - 8) / 6 + 100100) * 1461 / 4 + (153 * ((month + 9) % 12) + 2) / 5 + day - 34840408;
jdn = jdn - (year + 100100 + (month - 8) / 6) / 100 * 3 / 4 + 752;
return jdn;
}
/**
* JDNToGregorian:
* Calculates Gregorian calendar dates from the julian day number (JDN) for
* the period since JDN=-34839655 (i.e. the year -100100 of both calendars) to
* some millions (10^6) years ahead of the present. The algorithm is based on
* D.A. Hatcher, Q.Jl.R.Astron.Soc. 25(1984), 53-55 slightly modified by K.M.
* Borkowski, Post.Astron. 25(1987), 275-279).
*/
private void JDNToGregorian() {
int j = 4 * JDN + 139361631;
j = j + (4 * JDN + 183187720) / 146097 * 3 / 4 * 4 - 3908;
int i = j % 1461 / 4 * 5 + 308;
gDay = i % 153 / 5 + 1;
gMonth = i / 153 % 12 + 1;
gYear = j / 1461 - 100100 + (8 - gMonth) / 6;
}
public static void main(String[] args) {
CalendarTool calendarTool = new CalendarTool(2015, Calendar.JUNE, 13);
System.out.println(calendarTool);
calendarTool.setIranianDate(1394, CalendarTool.KHORDAD, 23);
System.out.println(calendarTool);
}
}
فقط حواستون باشه تو جفتشون ماه از 0 شروع میشه.