Java中的Calendar日歷API用法完全解析。本站提示廣大學習愛好者：（Java中的Calendar日歷API用法完全解析）文章只能為提供參考，不一定能成為您想要的結果。以下是Java中的Calendar日歷API用法完全解析正文
第一局部 Calendar引見
Calendar 定義:
public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar> {}
Calendar 可以看作是一個籠統類。
它的完成，采用了設計形式中的工廠辦法。表如今：當我們獲取Calendar實例時，Calendar會依據傳入的參數來前往相應的Calendar對象。獲取Calendar實例，有以下兩種方式：
(1) 當我們經過 Calendar.getInstance() 獲取日歷時，默許的是前往的一個GregorianCalendar對象。
GregorianCalendar是Calendar的一個完成類，它提供了世界上大少數國度/地域運用的規范日歷零碎。
(2) 當我們經過 Calendar.getInstance(TimeZone timezone, Locale locale) 或 Calendar.getInstance(TimeZone timezone) 或 Calendar.getInstance(Locale locale)獲取日歷時，是前往“對應時區(zone) 或 地域(local)等所運用的日歷”。
例如，若是日本，則前往JapaneseImperialCalendar對象。
參考如下代碼：
public static Calendar getInstance()
{
// 調用createCalendar()創立日歷
Calendar cal = createCalendar(TimeZone.getDefaultRef(), Locale.getDefault());
cal.sharedZone = true;
return cal;
}
public static Calendar getInstance(TimeZone zone)
{
// 調用createCalendar()創立日歷
return createCalendar(zone, Locale.getDefault());
}
public static Calendar getInstance(Locale aLocale) {
// 調用createCalendar()創立日歷
Calendar cal = createCalendar(TimeZone.getDefaultRef(), aLocale);
cal.sharedZone = true;
return cal;
}
public static Calendar getInstance(TimeZone zone,
Locale aLocale)
{
// 調用createCalendar()創立日歷
return createCalendar(zone, aLocale);
}
private static Calendar createCalendar(TimeZone zone,
Locale aLocale)
{
// (01) 若地域是“th”，則前往BuddhistCalendar對象
// (02) 若地域是“JP”，則前往JapaneseImperialCalendar對象
if ("th".equals(aLocale.getLanguage())
&& ("TH".equals(aLocale.getCountry()))) {
return new sun.util.BuddhistCalendar(zone, aLocale);
} else if ("JP".equals(aLocale.getVariant())
&& "JP".equals(aLocale.getCountry())
&& "ja".equals(aLocale.getLanguage())) {
return new JapaneseImperialCalendar(zone, aLocale);
}
// (03) 否則，前往GregorianCalendar對象
return new GregorianCalendar(zone, aLocale);
}
當我們獲取Calendar實例之後，就可以經過Calendar提供的一些列辦法來操作日歷。
第二局部 Calendar的原理和思想
我們運用Calendar，無非是操作Calendar的“年、月、日、星期、時、分、秒”這些字段。上面，我們對這些字段的的來源、定義以及計算辦法停止學習。
1. Calendar 各個字段值的來源
我們運用Calendar，無非是運用“年、月、日、星期、時、分、秒”等信息。那麼它是如何做到的呢？ 實質上，Calendar就是保管了一個時間。如下定義：
// time 是以後時間，單位是毫秒。 // 它是以後時間間隔“January 1, 1970, 0:00:00 GMT”的差值。 protected long time;
Calendar就是依據 time 計算出 “Calendar的年、月、日、星期、時、分、秒”等等信息。
2. Calendar 各個字段的定義和初始化
Calendar 的“年、月、日、星期、時、分、秒”這些信息，一共是17個字段。
我們運用Calendar，無非是就是運用這17個字段。它們的定義如下：
(字段0) public final static int ERA = 0;
闡明：紀元。
取值：只能為0 或 1。0表示BC(“before Christ”,即公元前)，1表示AD(拉丁語“Anno Domini”,即公元)。
(字段1) public final static int YEAR = 1;
闡明：年。
(字段2) public final static int MONTH = 2;
闡明：月
取值：可以為，JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER, UNDECIMBER。
其中第一個月是 JANUARY，它為 0。
(字段3) public final static int WEEK_OF_YEAR = 3;
闡明：以後日期在本年中對應第幾個星期。一年中第一個星期的值為 1。
(字段4) public final static int WEEK_OF_MONTH = 4;
闡明：以後日期在本月中對應第幾個星期。一個月中第一個星期的值為 1。
(字段5) public final static int DATE = 5;
闡明：日。一個月中第一天的值為 1。
(字段5) public final static int DAY_OF_MONTH = 5;
闡明：同“DATE”，表示“日”。
(字段6) public final static int DAY_OF_YEAR = 6;
闡明：以後日期在本年中對應第幾天。一年中第一天的值為 1。
(字段7) public final static int DAY_OF_WEEK = 7;
闡明：星期幾。
取值：可以為，SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY 和 SATURDAY。
其中，SUNDAY為1，MONDAY為2，順次類推。
(字段8) public final static int DAY_OF_WEEK_IN_MONTH = 8;
闡明：以後月中的第幾個星期。
取值：DAY_OF_MONTH 1 到 7 總是對應於 DAY_OF_WEEK_IN_MONTH 1；8 到 14 總是對應於 DAY_OF_WEEK_IN_MONTH 2，依此類推。
(字段9) public final static int AM_PM = 9;
闡明：上午 還是 下午
取值：可以是AM 或 PM。AM為0,表示上午；PM為1,表示下午。
(字段10) public final static int HOUR = 10;
闡明：指示一天中的第幾小時。
HOUR 用於 12 小時制時鐘 (0 - 11)。半夜和午夜用 0 表示，不必 12 表示。
(字段11) public final static int HOUR_OF_DAY = 11;
闡明：指示一天中的第幾小時。
HOUR_OF_DAY 用於 24 小時制時鐘。例如，在 10:04:15.250 PM 這一時辰，HOUR_OF_DAY 為 22。
(字段12) public final static int MINUTE = 12;
闡明：一小時中的第幾分鐘。
例如，在 10:04:15.250 PM這一時辰，MINUTE 為 4。
(字段13) public final static int SECOND = 13;
闡明：一分鐘中的第幾秒。
例如，在 10:04:15.250 PM 這一時辰，SECOND 為 15。
(字段14) public final static int MILLISECOND = 14;
闡明：一秒中的第幾毫秒。
例如，在 10:04:15.250 PM 這一時辰，MILLISECOND 為 250。
(字段15) public final static int ZONE_OFFSET = 15;
闡明：毫秒為單位指示距 GMT 的大致偏移量。
(字段16) public final static int DST_OFFSET = 16;
闡明：毫秒為單位指示夏令時的偏移量。
public final static int FIELD_COUNT = 17;
這17個字段是保管在int數組中。定義如下：
// 保管這17個字段的數組
protected int fields[];
// 數組的定義函數
protected Calendar(TimeZone zone, Locale aLocale)
{
// 初始化“fields數組”
fields = new int[FIELD_COUNT];
isSet = new boolean[FIELD_COUNT];
stamp = new int[FIELD_COUNT];
this.zone = zone;
setWeekCountData(aLocale);
}
protected Calendar(TimeZone zone, Locale aLocale) 這是Calendar的結構函數。它會被它的子類的結構函數調用到，從而新建“保管Calendar的17個字段數據”的數組。
3. Calendar 各個字段值的計算
上面以get(int field)為例，扼要的闡明Calendar的17個字段的計算和操作。 get(int field)是獲取“field”字段的值。它的定義如下：
public int get(int field) {
// 計算各個字段的值
complete();
// 前往field字段的值
return internalGet(field);
}
闡明：get(int field)的代碼很復雜。先經過 complete() 計算各個字段的值，然後在經過 internalGet(field) 前往“field字段的值”。
complete() 的作用就是計算Calendar各個字段的值。它定義在Calendar.java中，代碼如下：
protected void complete()
{
if (!isTimeSet)
updateTime();
if (!areFieldsSet || !areAllFieldsSet) {
computeFields(); // fills in unset fields
areAllFieldsSet = areFieldsSet = true;
}
}
private void updateTime() {
computeTime();
isTimeSet = true;
}
updateTime() 調用到的 computeTime() 定義在 Calendar.java的完成類中。上面，我列出GregorianCalendar.java中computeTime()的完成：
protected void computeTime() {
// In non-lenient mode, perform brief checking of calendar
// fields which have been set externally. Through this
// checking, the field values are stored in originalFields[]
// to see if any of them are normalized later.
if (!isLenient()) {
if (originalFields == null) {
originalFields = new int[FIELD_COUNT];
}
for (int field = 0; field < FIELD_COUNT; field++) {
int value = internalGet(field);
if (isExternallySet(field)) {
// Quick validation for any out of range values
if (value < getMinimum(field) || value > getMaximum(field)) {
throw new IllegalArgumentException(getFieldName(field));
}
}
originalFields[field] = value;
}
}
// Let the super class determine which calendar fields to be
// used to calculate the time.
int fieldMask = selectFields();
// The year defaults to the epoch start. We don't check
// fieldMask for YEAR because YEAR is a mandatory field to
// determine the date.
int year = isSet(YEAR) ? internalGet(YEAR) : EPOCH_YEAR;
int era = internalGetEra();
if (era == BCE) {
year = 1 - year;
} else if (era != CE) {
// Even in lenient mode we disallow ERA values other than CE & BCE.
// (The same normalization rule as add()/roll() could be
// applied here in lenient mode. But this checking is kept
// unchanged for compatibility as of 1.5.)
throw new IllegalArgumentException("Invalid era");
}
// If year is 0 or negative, we need to set the ERA value later.
if (year <= 0 && !isSet(ERA)) {
fieldMask |= ERA_MASK;
setFieldsComputed(ERA_MASK);
}
// Calculate the time of day. We rely on the convention that
// an UNSET field has 0.
long timeOfDay = 0;
if (isFieldSet(fieldMask, HOUR_OF_DAY)) {
timeOfDay += (long) internalGet(HOUR_OF_DAY);
} else {
timeOfDay += internalGet(HOUR);
// The default value of AM_PM is 0 which designates AM.
if (isFieldSet(fieldMask, AM_PM)) {
timeOfDay += 12 * internalGet(AM_PM);
}
}
timeOfDay *= 60;
timeOfDay += internalGet(MINUTE);
timeOfDay *= 60;
timeOfDay += internalGet(SECOND);
timeOfDay *= 1000;
timeOfDay += internalGet(MILLISECOND);
// Convert the time of day to the number of days and the
// millisecond offset from midnight.
long fixedDate = timeOfDay / ONE_DAY;
timeOfDay %= ONE_DAY;
while (timeOfDay < 0) {
timeOfDay += ONE_DAY;
--fixedDate;
}
// Calculate the fixed date since January 1, 1 (Gregorian).
calculateFixedDate: {
long gfd, jfd;
if (year > gregorianCutoverYear && year > gregorianCutoverYearJulian) {
gfd = fixedDate + getFixedDate(gcal, year, fieldMask);
if (gfd >= gregorianCutoverDate) {
fixedDate = gfd;
break calculateFixedDate;
}
jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask);
} else if (year < gregorianCutoverYear && year < gregorianCutoverYearJulian) {
jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask);
if (jfd < gregorianCutoverDate) {
fixedDate = jfd;
break calculateFixedDate;
}
gfd = fixedDate + getFixedDate(gcal, year, fieldMask);
} else {
gfd = fixedDate + getFixedDate(gcal, year, fieldMask);
jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask);
}
// Now we have to determine which calendar date it is.
if (gfd >= gregorianCutoverDate) {
if (jfd >= gregorianCutoverDate) {
fixedDate = gfd;
} else {
// The date is in an "overlapping" period. No way
// to disambiguate it. Determine it using the
// previous date calculation.
if (calsys == gcal || calsys == null) {
fixedDate = gfd;
} else {
fixedDate = jfd;
}
}
} else {
if (jfd < gregorianCutoverDate) {
fixedDate = jfd;
} else {
// The date is in a "missing" period.
if (!isLenient()) {
throw new IllegalArgumentException("the specified date doesn't exist");
}
// Take the Julian date for compatibility, which
// will produce a Gregorian date.
fixedDate = jfd;
}
}
}
// millis represents local wall-clock time in milliseconds.
long millis = (fixedDate - EPOCH_OFFSET) * ONE_DAY + timeOfDay;
// Compute the time zone offset and DST offset. There are two potential
// ambiguities here. We'll assume a 2:00 am (wall time) switchover time
// for discussion purposes here.
// 1. The transition into DST. Here, a designated time of 2:00 am - 2:59 am
// can be in standard or in DST depending. However, 2:00 am is an invalid
// representation (the representation jumps from 1:59:59 am Std to 3:00:00 am DST).
// We assume standard time.
// 2. The transition out of DST. Here, a designated time of 1:00 am - 1:59 am
// can be in standard or DST. Both are valid representations (the rep
// jumps from 1:59:59 DST to 1:00:00 Std).
// Again, we assume standard time.
// We use the TimeZone object, unless the user has explicitly set the ZONE_OFFSET
// or DST_OFFSET fields; then we use those fields.
TimeZone zone = getZone();
if (zoneOffsets == null) {
zoneOffsets = new int[2];
}
int tzMask = fieldMask & (ZONE_OFFSET_MASK|DST_OFFSET_MASK);
if (tzMask != (ZONE_OFFSET_MASK|DST_OFFSET_MASK)) {
if (zone instanceof ZoneInfo) {
((ZoneInfo)zone).getOffsetsByWall(millis, zoneOffsets);
} else {
int gmtOffset = isFieldSet(fieldMask, ZONE_OFFSET) ?
internalGet(ZONE_OFFSET) : zone.getRawOffset();
zone.getOffsets(millis - gmtOffset, zoneOffsets);
}
}
if (tzMask != 0) {
if (isFieldSet(tzMask, ZONE_OFFSET)) {
zoneOffsets[0] = internalGet(ZONE_OFFSET);
}
if (isFieldSet(tzMask, DST_OFFSET)) {
zoneOffsets[1] = internalGet(DST_OFFSET);
}
}
// Adjust the time zone offset values to get the UTC time.
millis -= zoneOffsets[0] + zoneOffsets[1];
// Set this calendar's time in milliseconds
time = millis;
int mask = computeFields(fieldMask | getSetStateFields(), tzMask);
if (!isLenient()) {
for (int field = 0; field < FIELD_COUNT; field++) {
if (!isExternallySet(field)) {
continue;
}
if (originalFields[field] != internalGet(field)) {
// Restore the original field values
System.arraycopy(originalFields, 0, fields, 0, fields.length);
throw new IllegalArgumentException(getFieldName(field));
}
}
}
setFieldsNormalized(mask);
}
上面，我們看看internalGet(field)的定義。如下：
protected final int internalGet(int field) {
return fields[field];
}
從中，我們就看出，get(int field) 最終是經過 internalGet(int field)來前往值的。
而 internalGet(int field) ，實踐上前往的是field數組中的第field個元素。這就正好和Calendar的17個元素所對應了！
總之，我們需求理解的就是：Calendar就是以一個time(毫秒)為基數，而計算出“年月日時分秒”等，從而方便我們對“年月日時分秒”等停止操作。上面，引見以下Calendar提供的相關操作函數。
第三局部 Calendar函數接口
1. Calendar的17個字段的公共接口
Calendar的這17個字段，都支持上面的公共函數接口。 這些公共接口的運用示例，請參考CalendarTest.java 示例中的 testAllCalendarSections() 函數。
(1) getMaximum(int field)
作用：獲取“字段的最大值”。留意“比照它和 getActualMaximum() 的區別”。 示例：以“MONTH”字段來說。運用辦法為：
// 獲取Calendar實例 Calendar cal = Calendar.getInstance(); // 獲取MONTH的最大值 int max = cal.getMaximum(Calendar.MONTH);
若要獲取其它字段的最大值，只需求將示例中的MONTH相應的交換成其它字段名即可。
(2) getActualMaximum(int field)
作用：獲取“以後日期下，該字段的最大值”。 示例：以“MONTH”字段來說。運用辦法為：
// 獲取Calendar實例 Calendar cal = Calendar.getInstance(); // 獲取以後MONTH的最大值 int max = cal.getActualMaximum(Calendar.MONTH);
若要獲取其它字段的最大值，只需求將示例中的MONTH相應的交換成其它字段名即可。
留意：比照getActualMaximum() 和 getMaximum() 的區別。參考上面的比照示例，
A、 getMaximum() 獲取的“字段最大值”，是指在綜合一切的日期，在一切這些日期中得出的“字段最大值”。
例如，getMaximum(Calendar.DATE)的目的是“獲取‘日的最大值'”。綜合一切的日期，得出一個月最多有31天。因而，getMaximum(Calendar.DATE)的前往值是“31”！
B、 getActualMaximum() 獲取的“以後日期時，該字段的最大值”。
例如，當日期為2013-09-01時，getActualMaximum(Calendar.DATE)是獲取“日的最大值”是“30”。以後日期是9月份，而9月只要30天。因而，getActualMaximum(Calendar.DATE)的前往值是“30”！
(3) getMinimum(int field)
作用：獲取“字段的最小值”。留意“比照它和 getActualMinimum() 的區別”。 示例：以“MONTH”字段來說。運用辦法為：
// 獲取Calendar實例 Calendar cal = Calendar.getInstance(); // 獲取MONTH的最小值 int min = cal.getMinimum(Calendar.MONTH);
若要獲取其它字段的最小值，只需求將示例中的MONTH相應的交換成其它字段名即可。
(4) getActualMinimum(int field)
作用：獲取“以後日期下，該字段的最小值”。 示例：以“MONTH”字段來說。運用辦法為： // 獲取Calendar實例 Calendar cal = Calendar.getInstance(); // 獲取MONTH的最小值 int min = cal.getMinimum(Calendar.MONTH);
若要獲取其它字段的最小值，只需求將示例中的MONTH相應的交換成其它字段名即可。
留意：在Java默許的Calendar中，雖然 getMinimum() 和 getActualMinimum() 的含義不同；但是，它們的前往值是一樣的。由於Calendar的默許是前往GregorianCalendar對象，而在GregorianCalendar.java中，getMinimum() 和 getActualMinimum() 前往值一樣。
（5) get(int field)
作用：獲取“字段的以後值”。獲取field字段的以後值。 示例：以“MONTH”字段來說。“獲取MONTH的以後值”的辦法為：
// 獲取Calendar實例 Calendar cal = Calendar.getInstance(); // 獲取“cal日歷”的以後MONTH值 int MONTH = cal.get(Calendar.MONTH);
若要獲取其它字段的以後值，只需求將示例中的MONTH相應的交換成其它字段名即可。
（6) set(int field, int value)
作用：設置“字段的以後值”。設置field字段的以後值為value 示例：以“MONTH”字段來說。“設置MONTH的以後值”的辦法為：
// 獲取Calendar實例 Calendar cal = Calendar.getInstance(); // 設置“cal日歷”的以後MONTH值為 1988年 cal.set(Calendar.MONTH, 1988);
闡明：
A、1988 是想要設置的MONTH的以後值。這個設置值必需是整數。
B、若要設置其它字段的以後值，只需求將示例中的MONTH相應的交換成其它字段名即可。
(7) add(int field, int value)
作用：給“字段的以後值”添加值。給field字段的以後值添加value。 示例：以“MONTH”字段來說。辦法如下：
// 獲取Calendar實例，並設置日期為“2013-09-01” Calendar cal = Calendar.getInstance(); cal.set(Calendar.YEAR, 2013); cal.set(Calendar.MONTH, 8); cal.set(Calendar.DATE, 1); // 給“cal日歷”的以後MONTH值 “添加-10” cal.add(Calendar.MONTH, -10);
闡明：
A、 -10 是添加值。
添加值可以為負數，也可以是正數。
負數表示將日期添加，正數表示將日期增加。
假定：如今cal的值是“2013-09-01”，如今我們將MONTH字段值添加-10。失掉的後果是：“2012-10-01”。
為什麼會這樣呢？“2013-09-01”添加-10，也就是將日期向前增加10個月；失掉的後果就是“2012-10-01”。
B、 Calendar的17個字段中：除了回滾Calendar.ZONE_OFFSET時，會拋出IllegalArgumentException異常；其它的字段都支持該操作。
C、 若要設置其它字段的以後值，只需求將示例中的MONTH相應的交換成其它字段名即可。
(8) roll(int field, int value)
作用：回滾“字段的以後值” 示例：以“MONTH”字段來說。“回滾MONTH的以後值”的辦法為：
// 獲取Calendar實例，並設置日期為“2013-09-01” Calendar cal = Calendar.getInstance(); cal.set(Calendar.YEAR, 2013); cal.set(Calendar.MONTH, 8); cal.set(Calendar.DATE, 1); // 將“cal日歷”的以後MONTH值 “向前滾動10” cal.roll(Calendar.MONTH, -10);
闡明：
A、 -10 是回滾值。
當回滾值是正數時，表示將以後字段向前滾；
當回滾值是負數時，表示將以後字段向後滾。
回滾Calendar中某一字段時，不更改更大的字段！
這是roll()與add()的依據區別！add()能夠會更改更大字段，比方“運用add()修正‘MONTH'字段，能夠會惹起‘YEAR'字段的改動”；但是roll()不會更改更大的字段，例如“運用roll()修正‘MONTH'字段，不回惹起‘YEAR'字段的改動。”
假定：如今cal的值是“2013-09-01”，如今我們將MONTH字段值添加-10。失掉的後果是：“2013-10-01”。
為什麼會這樣呢？這就是由於“回滾”就是“在最小值和最大值之間來回滾動”。本例中，MONTH是9月，前回滾10，失掉的值是10月，但是roll()不會改動“比MONTH”更大的字段，所以YEAR字段不會改動。所以後果是“2013-10-01”。
B、 Calendar的17個字段中：除了回滾Calendar.ZONE_OFFSET時，會拋出IllegalArgumentException異常；其它的字段都支持該操作。
C、 若要設置其它字段的以後值，只需求將示例中的MONTH相應的交換成其它字段名即可。
(9) clear(int field)
作用：清空“字段的以後值”。所謂清空，實踐上是將“field”的值設置為0；若field最小值為1,則設置為1。 示例：以“MONTH”字段來說。“清空MONTH”的辦法為：
// 獲取Calendar實例，並設置日期為“9月” Calendar cal = Calendar.getInstance(); cal.set(Calendar.MONTH, 9); // 清空MONTH cal.clear(Calendar.MONTH);
若要清空其它字段，只需求將示例中的MONTH相應的交換成其它字段名即可。
(10) isSet(int field)
作用：判別“字段field”能否被設置。若調用clear()清空之後，則field變為“沒有設置形態”。 示例：以“MONTH”字段來說。“判別MONTH能否被設置”的辦法為：
// 獲取Calendar實例 Calendar cal = Calendar.getInstance(); // 判別MONTH能否被設置 boolean bset = cal.isSet(Calendar.MONTH);
若要判別其它字段，只需求將示例中的MONTH相應的交換成其它字段名即可。
2. Calendar的其它函數
(1) 日期比擬函數
Calendar的比擬函數，次要有以下幾個：
// 比擬“以後Calendar對象”和“calendar” 的日期、時區等外容能否相等。 boolean equals(Object object) // 以後Calendar對象 能否 早於calendar boolean before(Object calendar) // 以後Calendar對象 能否 晚於calendar boolean after(Object calendar) // 比擬“以後Calendar對象”和“calendar”。 // 若 早於 “calendar” 則，前往-1 // 若 相等， 則，前往0 // 若 晚於 “calendar” 則，前往1 int compareTo(Calendar anotherCalendar)
這些函數的運用示例，請參考CalendarTest.java示例中的 testComparatorAPIs() 函數。
示例：假定cal1 和 cal2 都是Calendar的兩個對象。
// 它們的運用辦法如下 boolean isEqual = cal1.equals(cal2); boolean isBefore = cal1.before(cal2); boolean isAfter = cal1.after(cal2); int icompare = cal1.compareTo(cal2);
(2) “寬容”函數
// 設置“Calendar的寬容度” void setLenient(boolean value) // 獲取“Calendar的寬容度” boolean isLenient()
這些函數的運用示例，請參考CalendarTest.java示例中的 testLenientAPIs() 函數。
闡明：
Calendar 有兩種解釋日歷字段的形式，即 lenient 和 non-lenient。
A、 當 Calendar 處於 lenient 形式時，它可承受比它所生成的日歷字段范圍更大范圍內的值。當 Calendar 重新計算日歷字段值，以便由 get() 前往這些值時，一切日歷字段都被規范化。
例如，lenient 形式下的 GregorianCalendar 將 MONTH == JANUARY、DAY_OF_MONTH == 32 解釋為 February 1。
B、 當 Calendar 處於 non-lenient 形式時，假如其日歷字段中存在任何不分歧性，它都會拋出一個異常。
例如，GregorianCalendar 總是在 1 與月份的長度之間生成 DAY_OF_MONTH 值。假如曾經設置了任何超出范圍的字段值，那麼在計算時間或日歷字段值時，處於 non-lenient 形式下的 GregorianCalendar 會拋出一個異常。
留意：在(02)步驟中的異常，在運用set()時不會拋出，而需求在運用get()、getTimeInMillis()、getTime()、add() 和 roll() 等函數中才拋出。由於set()只是設置了一個修正標志，而get()等辦法才會惹起時間的重新計算，此時才會拋出異常！
(3) "年月日(時分秒)"、Date、TimeZone、MilliSecond函數
// 設置“年月日” final void set(int year, int month, int day) // 設置“年月日時分” final void set(int year, int month, int day, int hourOfDay, int minute, int second) // 設置“年月日時分秒” final void set(int year, int month, int day, int hourOfDay, int minute) // 獲取Calendar對應的日期 final Date getTime() // 設置Calendar為date final void setTime(Date date) // 獲取Calendar對應的時區 TimeZone getTimeZone() // 設置Calendar對應的時區 void setTimeZone(TimeZone timezone) // 獲取Calendar對應的milliscondes值，就是“Calendar以後日期”間隔“1970-01-01 0:00:00 GMT”的毫秒數 long getTimeInMillis() // 設置Calendar對應的milliscondes值 void setTimeInMillis(long milliseconds)
這些函數的運用示例，請參考CalendarTest.java示例中的 testTimeAPIs() 函數。
(4) 其它操作
// 克隆Calendar Object clone() // 獲取“每周的第一天是星期幾”。例如，在美國，這一天是 SUNDAY，而在法國，這一天是 MONDAY。 int getFirstDayOfWeek() // 設置“每周的第一天是星期幾”。例如，在美國，這一天是 SUNDAY，而在法國，這一天是 MONDAY。 void setFirstDayOfWeek(int value) // 獲取一年中第一個星期所需的最少天數，例如，假如定義第一個星期包括一年第一個月的第一天，則此辦法將前往 1。假如最少天數必需是一整個星期，則此辦法將前往 7。 int getMinimalDaysInFirstWeek() // 設置一年中第一個星期所需的最少天數，例如，假如定義第一個星期包括一年第一個月的第一天，則運用值 1 調用此辦法。假如最少天數必需是一整個星期，則運用值 7 調用此辦法。 void setMinimalDaysInFirstWeek(int value)
這些函數的運用示例，請參考CalendarTest.java示例中的 testOtherAPIs() 函數。
第四局部 Calendar運用示例
上面，我們經過示例學習運用Calendar的API。CalendarTest.java的源碼如下：
import java.util.Date;
import java.util.Calendar;
import java.util.TimeZone;
import java.util.Random;
public class CalendarTest {
public static void main(String[] args) {
// 測試Calendar的“17個字段的公共函數接口”
testAllCalendarSections() ;
// 測試Calendar的“比擬接口”
testComparatorAPIs() ;
// 測試Calendar的“比擬接口”
testLenientAPIs() ;
// 測試Calendar的Date、TimeZone、MilliSecond等相關函數
testTimeAPIs() ;
// 測試Calendar的clone()，getFirstDayOfWeek()等接口
testOtherAPIs() ;
}
/**
* 測試“Calendar的字段”
*
* @param cal -- Calendar對象
* @param field -- 要測試的“Calendar字段”。可以為以下值：
* Calendar.YEAR, Calendar.MONTH, Calendar.DATE, ... 等等
* @param title -- 標題
*/
private static void testSection(Calendar cal, int field, String title) {
final Random random = new Random();
final Date date = cal.getTime();
final int min = cal.getMinimum(field); // 獲取"字段最小值"
final int max = cal.getMaximum(field); // 獲取“字段最大值”
final int actualMin = cal.getActualMinimum(field); // 獲取"以後日期下，該字段最小值"
final int actualMax = cal.getActualMaximum(field); // 獲取“以後日期下，該字段的最大值”
// 獲取“字段的以後值”
final int ori = cal.get(field);
// 設置“字段的以後值”, 並獲取“設置之後的值”
final int r1 = random.nextInt(max);
cal.set(field, r1);
final int set = cal.get(field);
try {
// 回滾“字段的以後值”：在“字段最小值”和“字段最大值”之間回滾。
// “回滾值”可以為正，也可以為負。
cal.roll(field, -max);
} catch (IllegalArgumentException e) {
// 當field == Calendar.ZONE_OFFSET時，會拋出該異常！
e.printStackTrace();
}
final int roll = cal.get(field);
// 獲取一個隨機值
final int sign = ( random.nextInt(2) == 1) ? 1 : -1;
final int r2 = sign * random.nextInt(max);
try {
// 添加“字段的以後值” ，並獲取“新的以後字段值”
// add的“參數值”可以為正，也可以為負。
cal.add(field, r2);
} catch (IllegalArgumentException e) {
// 當field == Calendar.ZONE_OFFSET時，會拋出該異常！
e.printStackTrace();
}
final int add = cal.get(field);
// 打印字段信息
System.out.printf("%s:\n\trange is [%d - %d] actualRange is [%d - %d]. original=%d, set(%d)=%d, roll(%d)=%d, add(%d)=%d\n",
title, min, max, actualMin, actualMax, ori, r1, set, -max, roll, r2, add);
}
/**
* 測試Calendar的“17個字段的公共函數接口”
*/
private static void testAllCalendarSections() {
// 00. ERA 字段
testSection(Calendar.getInstance(), Calendar.ERA, "Calendar.ERA");
// 01. YEAR 字段
testSection(Calendar.getInstance(), Calendar.YEAR, "Calendar.YEAR");
// 02. MONTH 字段
testSection(Calendar.getInstance(), Calendar.MONTH, "Calendar.MONTH");
// 03. WEEK_OF_YEAR 字段
testSection(Calendar.getInstance(), Calendar.WEEK_OF_YEAR, "Calendar.WEEK_OF_YEAR");
// 04. WEEK_OF_MONTH 字段
testSection(Calendar.getInstance(), Calendar.WEEK_OF_MONTH, "Calendar.WEEK_OF_MONTH");
// 05. DATE 字段
testSection(Calendar.getInstance(), Calendar.DATE, "Calendar.DATE");
// 06. DAY_OF_MONTH 字段
testSection(Calendar.getInstance(), Calendar.DAY_OF_MONTH, "Calendar.DAY_OF_MONTH");
// 07. DAY_OF_YEAR 字段
testSection(Calendar.getInstance(), Calendar.DAY_OF_YEAR, "Calendar.DAY_OF_YEAR");
// 08. DAY_OF_WEEK 字段
testSection(Calendar.getInstance(), Calendar.DAY_OF_WEEK, "Calendar.DAY_OF_WEEK");
// 09. DAY_OF_WEEK_IN_MONTH 字段
testSection(Calendar.getInstance(), Calendar.DAY_OF_WEEK_IN_MONTH, "Calendar.DAY_OF_WEEK_IN_MONTH");
// 10. AM_PM 字段
testSection(Calendar.getInstance(), Calendar.AM_PM, "Calendar.AM_PM");
// 11. HOUR 字段
testSection(Calendar.getInstance(), Calendar.HOUR, "Calendar.HOUR");
// 12. HOUR_OF_DAY 字段
testSection(Calendar.getInstance(), Calendar.HOUR_OF_DAY, "Calendar.HOUR_OF_DAY");
// 13. MINUTE 字段
testSection(Calendar.getInstance(), Calendar.MINUTE, "Calendar.MINUTE");
// 14. SECOND 字段
testSection(Calendar.getInstance(), Calendar.SECOND, "Calendar.SECOND");
// 15. MILLISECOND 字段
testSection(Calendar.getInstance(), Calendar.MILLISECOND, "Calendar.MILLISECOND");
// 16. ZONE_OFFSET 字段
testSection(Calendar.getInstance(), Calendar.ZONE_OFFSET, "Calendar.ZONE_OFFSET");
}
/**
* 測試Calendar的“比擬接口”
*/
private static void testComparatorAPIs() {
// 新建cal1 ，且時間為1988年
Calendar cal1 = Calendar.getInstance();
cal1.set(Calendar.YEAR, 1988);
// 新建cal2 ，且時間為2000年
Calendar cal2 = Calendar.getInstance();
cal2.set(Calendar.YEAR, 2000);
// 新建cal3, 為cal1的克隆對象
Calendar cal3 = (Calendar)cal1.clone();
// equals 判別 cal1和cal2的“時間、時區等”內容能否相等
boolean isEqual12 = cal1.equals(cal2);
// equals 判別 cal1和cal3的“時間、時區等”內容能否相等
boolean isEqual13 = cal1.equals(cal3);
// cal1能否比cal2早
boolean isBefore = cal1.before(cal2);
// cal1能否比cal2晚
boolean isAfter = cal1.after(cal2);
// 比擬cal1和cal2
// (01) 若cal1 早於 cal2，前往-1
// (02) 若cal1 等於 cal2，前往0
// (03) 若cal1 晚於 cal2，前往1
int icompare = cal1.compareTo(cal2);
System.out.printf("\ntestComparatorAPIs: isEuqal12=%s, isEqual13=%s, isBefore=%s, isAfter=%s, icompare=%s\n",
isEqual12, isEqual13, isBefore, isAfter, icompare);
}
/**
* 測試Calendar的“比擬接口”
*/
private static void testLenientAPIs() {
Calendar cal = Calendar.getInstance();
// 獲取默許的“寬容度”。前往true
boolean oriLenient = cal.isLenient();
// MONTH值只能是“0-11”，這裡越界。但是由於以後cal是寬容的，所以不會拋出異常
cal.set(Calendar.MONTH, 50);
// 設置“寬容度”為false。
cal.setLenient(false);
// 獲取設置後的“寬容度”
boolean curLenient = cal.isLenient();
try {
// MONTH值只能是“0-11”，這裡越界。而且以後cal是不寬容的，所以會發生異常。
// 但是，異常到下次計算日期時才會拋出。即，set()中不回拋出異常，而要等到get()中才會拋出異常
cal.set(Calendar.MONTH, 50);
// 此時，對cal停止讀取。讀取會招致重新計算cal的值，所以此時拋出異常！
int m2 = cal.get(Calendar.MONTH);
} catch (IllegalArgumentException e) {
e.printStackTrace();
}
System.out.printf("\ntestLenientAPIs: oriLenient=%s, curLenient=%s\n",
oriLenient, curLenient);
}
/**
* 測試Calendar的Date、TimeZone、MilliSecond等相關函數
*/
private static void testTimeAPIs() {
Calendar cal = Calendar.getInstance();
// 設置cal的時區為“GMT+8”
cal.setTimeZone(TimeZone.getTimeZone("GMT+8"));
// 獲取以後的cal時區
TimeZone timezone = cal.getTimeZone();
// 設置 milliseconds
cal.setTimeInMillis(1279419645742l);
// 獲取 milliseconds
long millis = cal.getTimeInMillis();
// 設置 milliseconds之後，時間也改動了。
// 獲取cal對應的日期
Date date = cal.getTime();
// 設置時間為“1988-08-08”
cal.set(1988, 08, 08);
// 設置時間為“1999-09-09 09:09”
cal.set(1999, 09, 09, 9, 9);
// 設置時間為“2000-10-10 10:10:10”
cal.set(2000, 10, 10, 10, 10, 10);
System.out.printf("\ntestTimeAPIs: date=%s, timezone=%s, millis=%s\n",
date, timezone, millis);
}
/**
* 測試Calendar的clone()，getFirstDayOfWeek()等接口
*/
private static void testOtherAPIs() {
Calendar cal = Calendar.getInstance();
// 克隆cal
Calendar clone = (Calendar)cal.clone();
// 設置 為 2013-01-10。
// 注：2013-01-01 為“星期二”，2013-01-06為“星期天”，
clone.set(Calendar.YEAR, 2013);
clone.set(Calendar.MONTH, 0);
clone.set(Calendar.DATE, 10);
// 設置“本年的第一個星期最少包括1天”。
// 則2013-01-10屬於第2個星期
clone.setMinimalDaysInFirstWeek(1);
int m1 = clone.getMinimalDaysInFirstWeek();
int index1 = clone.get(Calendar.WEEK_OF_YEAR);
// 設置“本年的第一個星期最少包括7天”。
// 則2013-01-10屬於第1個星期
clone.setMinimalDaysInFirstWeek(7);
int m2 = clone.getMinimalDaysInFirstWeek();
int index2 = clone.get(Calendar.WEEK_OF_YEAR);
// 設置“每周的第一天是星期幾”。
clone.setFirstDayOfWeek(Calendar.WEDNESDAY);
// 獲取“每周的第一天是星期幾”。
int firstdayOfWeek = clone.getFirstDayOfWeek();
System.out.printf("\ntestOtherAPIs: firstdayOfWeek=%s, [minimalDay, WeekOfYear]={(%s, %s), (%s, %s)} %s\n",
firstdayOfWeek, m1, index1, m2, index2, clone.getTime());
}
}
第五局部 自定義的Calendar接口示例
這些接口在寫日歷順序時能夠會用到。
源代碼如下(CalendarSelfDefineTest.java)：
import java.util.Calendar;
/**
* 依據Calendar的API封裝的一些常用函數
*/
public class CalendarSelfDefineTest {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
// 設置日期為“2013-09-18”
cal.set(2013, Calendar.SEPTEMBER, 18);
// 獲取“年”
System.out.printf("year: %s\n", getYear(cal) );
// 獲取“月”
System.out.printf("month: %s\n", getMonth(cal) );
// 獲取“上月”
System.out.printf("previcou month: %s\n", getLastMonth(cal) );
// 獲取“下月”
System.out.printf("next month: %s\n", getNextMonth(cal) );
// 獲取“日”
System.out.printf("day: %s\n", getDay(cal) );
// 獲取Cal對應星期幾
System.out.printf("weekday: %s\n", getWeekDay(cal) );
// 本月天數
System.out.printf("Current Month days: %s\n", getMonthDays(cal) );
// 上月天數
System.out.printf("Previcous Month days: %s\n", getPrevMonthDays(cal) );
// 下月天數
System.out.printf("Next Month days: %s\n", getNextMonthDays(cal) );
// 獲取當月第一天的星期幾
System.out.printf("First day' weekday : %s\n", getFirstDayWeekday(cal) );
// 獲取以後月最後一天的星期幾
System.out.printf("Last day' weekday : %s\n", getLastDayWeekday(cal) );
// 獲取上月最後一天的星期幾
System.out.printf("PrevMonth Last day' weekday: %s\n", getLastDayWeekdayOfPrevMonth(cal) );
// 獲取下月第一天的星期幾
System.out.printf("NextMonth First day' weekday: %s\n", getFirstDayWeekdayOfNextMonth(cal) );
}
/**
* 獲取“年”
*
* @return 例如，2013-09-18，則前往2013
*/
public static int getYear(Calendar cal) {
return cal.get(Calendar.YEAR);
}
/**
* 獲取“月”
*
* @return 前往值可以為以下值：
* JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER, UNDECIMBER。
* 其中第一個月是 JANUARY，它為 0。
*
* 例如，2013-09-18，則前往8
*/
public static int getMonth(Calendar cal) {
return cal.get(Calendar.MONTH);
}
/**
* 獲取“上一個月”
*
* @return 前往值可以為以下值：
* JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER, UNDECIMBER。
* 其中第一個月是 JANUARY，它為 0。
*
* 例如，2012-01-12的上一個月是“11”(即DECEMBER)。
*/
public static int getLastMonth(Calendar cal) {
return (cal.get(Calendar.MONTH) + 11) % 12;
}
/**
* 獲取“下一個月”
*
* @return 前往值可以為以下值：
* JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER, UNDECIMBER。
* 其中第一個月是 JANUARY，它為 0。
*
* 例如，2013-12-12的下一個月是“1”(即DECEMBER)。
*/
public static int getNextMonth(Calendar cal) {
return (cal.get(Calendar.MONTH) + 13) % 12;
}
/**
* 獲取“日”
*
* @return 例如，2013-09-18，則前往18
*
*/
public static int getDay(Calendar cal) {
return cal.get(Calendar.DATE);
}
/**
* 獲取“本月的天數”
*
* @return 例如，2013-09-18，則前往30
*
*/
public static int getMonthDays(Calendar cal) {
return cal.getActualMaximum(Calendar.DATE);
}
/**
* 獲取“上一個月的天數”
*
* @return 例如，2013-01-18，則前往31 (由於2012-12有31天)
*
*/
public static int getPrevMonthDays(Calendar cal) {
Calendar tmpCal = (Calendar)cal.clone(); // 克隆cal。前面對tmpCal操作，就不會改動cal
tmpCal.add(Calendar.MONTH, -1); // 設為“上一個月”
return tmpCal.getActualMaximum(Calendar.DATE);
}
/**
* 獲取“下一個月的天數”
*
* @return 例如，2013-12-18，則前往31 (由於2014-01有31天)
*
*/
public static int getNextMonthDays(Calendar cal) {
Calendar tmpCal = (Calendar)cal.clone(); // 克隆cal。前面對tmpCal操作，就不會改動cal
tmpCal.add(Calendar.MONTH, 1); // 設為“下一個月”
return tmpCal.getActualMaximum(Calendar.DATE);
}
/**
* 獲取Cal對應星期幾
*
* @return 前往“星期幾”，可以為以下值：
* SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY 和 SATURDAY。
* SUNDAY為1，MONDAY為2，順次類推。
* 例如，2013-09-18(星期三)，則前往4
*/
public static int getWeekDay(Calendar cal) {
return cal.get(Calendar.DAY_OF_WEEK);
}
/**
* 獲取當月第一天對應星期幾
*
* @return SUNDAY為1，MONDAY為2，順次類推。
*/
public static int getFirstDayWeekday(Calendar cal) {
Calendar tmpCal = (Calendar)cal.clone(); // 克隆cal。前面對tmpCal操作，就不會改動cal
tmpCal.set(Calendar.DATE, 1); // 把日期設置為當月第一天
return tmpCal.get(Calendar.DAY_OF_WEEK);
}
/**
* 獲取以後月最後一天對應星期幾
*
* @return SUNDAY為1，MONDAY為2，順次類推。
*/
public static int getLastDayWeekday(Calendar cal) {
Calendar tmpCal = (Calendar)cal.clone(); // 克隆cal。前面對tmpCal操作，就不會改動cal
tmpCal.set(Calendar.DATE, 1); // 把日期設置為當月第一天
tmpCal.roll(Calendar.DATE, -1); // 把日期設置為當月最後一天
return tmpCal.get(Calendar.DAY_OF_WEEK);
}
/**
* 獲取上月最後一天的星期幾
*
* @return SUNDAY為1，MONDAY為2，順次類推。
*/
public static int getLastDayWeekdayOfPrevMonth(Calendar cal) {
Calendar tmpCal = (Calendar)cal.clone(); // 克隆cal。前面對tmpCal操作，就不會改動cal
tmpCal.set(Calendar.DATE, 1); // 把日期設置為當月第一天
tmpCal.add(Calendar.DATE, -1); // 把日期設置為上一個月最後一天
return tmpCal.get(Calendar.DAY_OF_WEEK);
}
/**
* 獲取下月第一天的星期偏移
*
* @return SUNDAY為1，MONDAY為2，順次類推。
*/
public static int getFirstDayWeekdayOfNextMonth(Calendar cal) {
Calendar tmpCal = (Calendar)cal.clone(); // 克隆cal。前面對tmpCal操作，就不會改動cal
tmpCal.add(Calendar.MONTH, 1); // 設為“下一個月”
tmpCal.set(Calendar.DATE, 1); // 設為“第一天”
return tmpCal.get(Calendar.DAY_OF_WEEK);
}
}
