Also see:

GregorianCalendar#AD
GregorianCalendar#BC

Also see:

JANUARY
FEBRUARY
MARCH
APRIL
MAY
JUNE
JULY
AUGUST
SEPTEMBER
OCTOBER
NOVEMBER
DECEMBER
UNDECIMBER

Also see:

getFirstDayOfWeek
getMinimalDaysInFirstWeek

Also see:

getFirstDayOfWeek
getMinimalDaysInFirstWeek

Also see:

DAY_OF_MONTH

Also see:

DATE

Also see:

SUNDAY
MONDAY
TUESDAY
WEDNESDAY
THURSDAY
FRIDAY
SATURDAY

Also see:

DAY_OF_WEEK
WEEK_OF_MONTH

Also see:

AM
PM
HOUR

Also see:

AM_PM
HOUR_OF_DAY

Also see:

HOUR

This field reflects the correct GMT offset value of the time zone of this Calendar if the TimeZone implementation subclass supports historical GMT offset changes. 

This field reflects the correct daylight saving offset value of the time zone of this Calendar if the TimeZone implementation subclass supports historical Daylight Saving Time schedule changes. 

Also see:

SHORT
LONG
since: 1.6 -

Also see:

LONG
since: 1.6 -

Also see:

SHORT
since: 1.6 -

serial:

serial:

Also see:

isTimeSet
serial:

Also see:

time
serial:

serial:

serial:

 protected Calendar() 
{
        this(TimeZone.getDefaultRef(), Locale.getDefault(Locale.Category.FORMAT));
        sharedZone = true;
}

Constructs a Calendar with the default time zone and locale.

Also see:

TimeZone#getDefault

 protected Calendar(TimeZone zone,
    Locale aLocale) 
{
        fields = new int[FIELD_COUNT];
        isSet = new boolean[FIELD_COUNT];
        stamp = new int[FIELD_COUNT];
        this.zone = zone;
        setWeekCountData(aLocale);
}

Constructs a calendar with the specified time zone and locale.

Parameters:

zone - the time zone to use

aLocale - the locale for the week data

 abstract public  void add(int field,
    int amount)
Adds or subtracts the specified amount of time to the given calendar field,
based on the calendar's rules. For example, to subtract 5 days from
the current time of the calendar, you can achieve it by calling:
add(Calendar.DAY_OF_MONTH, -5).

 public boolean after(Object when) 
{
        return when instanceof Calendar
            && compareTo((Calendar)when)  > 0;
}

Returns whether this Calendar represents a time after the time represented by the specified Object. This method is equivalent to:

        compareTo(when) > 0

if and only if when is a Calendar instance. Otherwise, the method returns false.

 public boolean before(Object when) 
{
        return when instanceof Calendar
            && compareTo((Calendar)when) <  0;
}

Returns whether this Calendar represents a time before the time represented by the specified Object. This method is equivalent to:

        compareTo(when) < 0

if and only if when is a Calendar instance. Otherwise, the method returns false.

 boolean checkDisplayNameParams(int field,
    int style,
    int minStyle,
    int maxStyle,
    Locale locale,
    int fieldMask) 
{
        if (field <  0 || field  >= fields.length ||
            style <  minStyle || style  > maxStyle) {
            throw new IllegalArgumentException();
        }
        if (locale == null) {
            throw new NullPointerException();
        }
        return isFieldSet(fieldMask, field);
}

 public final  void clear() 
{
        for (int i = 0; i <  fields.length; ) {
            stamp[i] = fields[i] = 0; // UNSET == 0
            isSet[i++] = false;
        }
        areAllFieldsSet = areFieldsSet = false;
        isTimeSet = false;
}

Sets all the calendar field values and the time value (millisecond offset from the Epoch) of this Calendar undefined. This means that isSet() will return false for all the calendar fields, and the date and time calculations will treat the fields as if they had never been set. A Calendar implementation class may use its specific default field values for date/time calculations. For example, GregorianCalendar uses 1970 if the YEAR field value is undefined.

 public final  void clear(int field) 
{
        fields[field] = 0;
        stamp[field] = UNSET;
        isSet[field] = false;
        areAllFieldsSet = areFieldsSet = false;
        isTimeSet = false;
}

Sets the given calendar field value and the time value (millisecond offset from the Epoch) of this Calendar undefined. This means that isSet(field) will return false, and the date and time calculations will treat the field as if it had never been set. A Calendar implementation class may use the field's specific default value for date and time calculations.

The #HOUR_OF_DAY , #HOUR and #AM_PM fields are handled independently and the the resolution rule for the time of day is applied. Clearing one of the fields doesn't reset the hour of day value of this Calendar. Use set(Calendar.HOUR_OF_DAY, 0) to reset the hour value.

 public Object clone() 
{
        try {
            Calendar other = (Calendar) super.clone();
            other.fields = new int[FIELD_COUNT];
            other.isSet = new boolean[FIELD_COUNT];
            other.stamp = new int[FIELD_COUNT];
            for (int i = 0; i <  FIELD_COUNT; i++) {
                other.fields[i] = fields[i];
                other.stamp[i] = stamp[i];
                other.isSet[i] = isSet[i];
            }
            other.zone = (TimeZone) zone.clone();
            return other;
        }
        catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
}

Creates and returns a copy of this object.

 public int compareTo(Calendar anotherCalendar) 
{
        return compareTo(getMillisOf(anotherCalendar));
}

Compares the time values (millisecond offsets from the Epoch) represented by two Calendar objects.

 protected  void complete() 
{
        if (!isTimeSet)
            updateTime();
        if (!areFieldsSet || !areAllFieldsSet) {
            computeFields(); // fills in unset fields
            areAllFieldsSet = areFieldsSet = true;
        }
}

Fills in any unset fields in the calendar fields. First, the #computeTime() method is called if the time value (millisecond offset from the Epoch) has not been calculated from calendar field values. Then, the #computeFields() method is called to calculate all calendar field values.

 abstract protected  void computeFields()
Converts the current millisecond time value #time 
to calendar field values in  fields[] .
This allows you to sync up the calendar field values with
a new time that is set for the calendar.  The time is not
recomputed first; to recompute the time, then the fields, call the
#complete()  method.

 abstract protected  void computeTime()
Converts the current calendar field values in  fields[] 
to the millisecond time value
#time .

 public boolean equals(Object obj) 
{
        if (this == obj)
            return true;
        try {
            Calendar that = (Calendar)obj;
            return compareTo(getMillisOf(that)) == 0 &&
                lenient == that.lenient &&
                firstDayOfWeek == that.firstDayOfWeek &&
                minimalDaysInFirstWeek == that.minimalDaysInFirstWeek &&
                zone.equals(that.zone);
        } catch (Exception e) {
            // Note: GregorianCalendar.computeTime throws
            // IllegalArgumentException if the ERA value is invalid
            // even it's in lenient mode.
        }
        return false;
}

Compares this Calendar to the specified Object. The result is true if and only if the argument is a Calendar object of the same calendar system that represents the same time value (millisecond offset from the Epoch) under the same Calendar parameters as this object.

The Calendar parameters are the values represented by the isLenient, getFirstDayOfWeek, getMinimalDaysInFirstWeek and getTimeZone methods. If there is any difference in those parameters between the two Calendars, this method returns false.

Use the compareTo method to compare only the time values.

 public int get(int field) 
{
        complete();
        return internalGet(field);
}

Returns the value of the given calendar field. In lenient mode, all calendar fields are normalized. In non-lenient mode, all calendar fields are validated and this method throws an exception if any calendar fields have out-of-range values. The normalization and validation are handled by the #complete() method, which process is calendar system dependent.

 public int getActualMaximum(int field) 
{
        int fieldValue = getLeastMaximum(field);
        int endValue = getMaximum(field);
        // if we know that the maximum value is always the same, just return it.
        if (fieldValue == endValue) {
            return fieldValue;
        }
        // clone the calendar so we don't mess with the real one, and set it to
        // accept anything for the field values.
        Calendar work = (Calendar)this.clone();
        work.setLenient(true);
        // if we're counting weeks, set the day of the week to Sunday.  We know the
        // last week of a month or year will contain the first day of the week.
        if (field == WEEK_OF_YEAR || field == WEEK_OF_MONTH)
            work.set(DAY_OF_WEEK, firstDayOfWeek);
        // now try each value from getLeastMaximum() to getMaximum() one by one until
        // we get a value that normalizes to another value.  The last value that
        // normalizes to itself is the actual maximum for the current date
        int result = fieldValue;
        do {
            work.set(field, fieldValue);
            if (work.get(field) != fieldValue) {
                break;
            } else {
                result = fieldValue;
                fieldValue++;
            }
        } while (fieldValue < = endValue);
        return result;
}

Returns the maximum value that the specified calendar field could have, given the time value of this Calendar. For example, the actual maximum value of the MONTH field is 12 in some years, and 13 in other years in the Hebrew calendar system.

The default implementation of this method uses an iterative algorithm to determine the actual maximum value for the calendar field. Subclasses should, if possible, override this with a more efficient implementation.

 public int getActualMinimum(int field) 
{
        int fieldValue = getGreatestMinimum(field);
        int endValue = getMinimum(field);
        // if we know that the minimum value is always the same, just return it
        if (fieldValue == endValue) {
            return fieldValue;
        }
        // clone the calendar so we don't mess with the real one, and set it to
        // accept anything for the field values
        Calendar work = (Calendar)this.clone();
        work.setLenient(true);
        // now try each value from getLeastMaximum() to getMaximum() one by one until
        // we get a value that normalizes to another value.  The last value that
        // normalizes to itself is the actual minimum for the current date
        int result = fieldValue;
        do {
            work.set(field, fieldValue);
            if (work.get(field) != fieldValue) {
                break;
            } else {
                result = fieldValue;
                fieldValue--;
            }
        } while (fieldValue  >= endValue);
        return result;
}

Returns the minimum value that the specified calendar field could have, given the time value of this Calendar.

The default implementation of this method uses an iterative algorithm to determine the actual minimum value for the calendar field. Subclasses should, if possible, override this with a more efficient implementation - in many cases, they can simply return getMinimum().

 public static synchronized Locale[] getAvailableLocales() 
{
        return DateFormat.getAvailableLocales();
}

Returns an array of all locales for which the getInstance methods of this class can return localized instances. The array returned must contain at least a Locale instance equal to Locale.US .

 public String getDisplayName(int field,
    int style,
    Locale locale) 
{
        if (!checkDisplayNameParams(field, style, ALL_STYLES, LONG, locale,
                                    ERA_MASK|MONTH_MASK|DAY_OF_WEEK_MASK|AM_PM_MASK)) {
            return null;
        }
        DateFormatSymbols symbols = DateFormatSymbols.getInstance(locale);
        String[] strings = getFieldStrings(field, style, symbols);
        if (strings != null) {
            int fieldValue = get(field);
            if (fieldValue <  strings.length) {
                return strings[fieldValue];
            }
        }
        return null;
}

Returns the string representation of the calendar field value in the given style and locale. If no string representation is applicable, null is returned. This method calls get(field) to get the calendar field value if the string representation is applicable to the given calendar field.

For example, if this Calendar is a GregorianCalendar and its date is 2005-01-01, then the string representation of the #MONTH field would be "January" in the long style in an English locale or "Jan" in the short style. However, no string representation would be available for the #DAY_OF_MONTH field, and this method would return null.

The default implementation supports the calendar fields for which a DateFormatSymbols has names in the given locale.

 public Map<String, Integer> getDisplayNames(int field,
    int style,
    Locale locale) 
{
        if (!checkDisplayNameParams(field, style, ALL_STYLES, LONG, locale,
                                    ERA_MASK|MONTH_MASK|DAY_OF_WEEK_MASK|AM_PM_MASK)) {
            return null;
        }
        // ALL_STYLES
        if (style == ALL_STYLES) {
            Map< String,Integer > shortNames = getDisplayNamesImpl(field, SHORT, locale);
            if (field == ERA || field == AM_PM) {
                return shortNames;
            }
            Map< String,Integer > longNames = getDisplayNamesImpl(field, LONG, locale);
            if (shortNames == null) {
                return longNames;
            }
            if (longNames != null) {
                shortNames.putAll(longNames);
            }
            return shortNames;
        }
        // SHORT or LONG
        return getDisplayNamesImpl(field, style, locale);
}

Returns a Map containing all names of the calendar field in the given style and locale and their corresponding field values. For example, if this Calendar is a GregorianCalendar , the returned map would contain "Jan" to #JANUARY , "Feb" to #FEBRUARY , and so on, in the {@linkplain #SHORT short} style in an English locale.

The values of other calendar fields may be taken into account to determine a set of display names. For example, if this Calendar is a lunisolar calendar system and the year value given by the #YEAR field has a leap month, this method would return month names containing the leap month name, and month names are mapped to their values specific for the year.

The default implementation supports display names contained in a DateFormatSymbols . For example, if field is #MONTH and style is #ALL_STYLES , this method returns a Map containing all strings returned by DateFormatSymbols#getShortMonths() and DateFormatSymbols#getMonths() .

 static final String getFieldName(int field) 
{
        return FIELD_NAME[field];
}

Returns the name of the specified calendar field.

 public int getFirstDayOfWeek() 
{
        return firstDayOfWeek;
}

Gets what the first day of the week is; e.g., SUNDAY in the U.S., MONDAY in France.

 abstract public int getGreatestMinimum(int field)
Returns the highest minimum value for the given calendar field
of this Calendar instance. The highest minimum
value is defined as the largest value returned by #getActualMinimum(int)  for any possible time value. The
greatest minimum value depends on calendar system specific
parameters of the instance.

 public static Calendar getInstance() 
{
        Calendar cal = createCalendar(TimeZone.getDefaultRef(), Locale.getDefault(Locale.Category.FORMAT));
        cal.sharedZone = true;
        return cal;
}

Gets a calendar using the default time zone and locale. The Calendar returned is based on the current time in the default time zone with the default locale.

 public static Calendar getInstance(TimeZone zone) 
{
        return createCalendar(zone, Locale.getDefault(Locale.Category.FORMAT));
}

Gets a calendar using the specified time zone and default locale. The Calendar returned is based on the current time in the given time zone with the default locale.

 public static Calendar getInstance(Locale aLocale) 
{
        Calendar cal = createCalendar(TimeZone.getDefaultRef(), aLocale);
        cal.sharedZone = true;
        return cal;
}

Gets a calendar using the default time zone and specified locale. The Calendar returned is based on the current time in the default time zone with the given locale.

 public static Calendar getInstance(TimeZone zone,
    Locale aLocale) 
{
        return createCalendar(zone, aLocale);
}

Gets a calendar with the specified time zone and locale. The Calendar returned is based on the current time in the given time zone with the given locale.

 abstract public int getLeastMaximum(int field)
Returns the lowest maximum value for the given calendar field
of this Calendar instance. The lowest maximum
value is defined as the smallest value returned by #getActualMaximum(int)  for any possible time value. The least
maximum value depends on calendar system specific parameters of
the instance. For example, a Calendar for the
Gregorian calendar system returns 28 for the
DAY_OF_MONTH field, because the 28th is the last
day of the shortest month of this calendar, February in a
common year.

 abstract public int getMaximum(int field)
Returns the maximum value for the given calendar field of this
Calendar instance. The maximum value is defined as
the largest value returned by the  get  method
for any possible time value. The maximum value depends on
calendar system specific parameters of the instance.

 public int getMinimalDaysInFirstWeek() 
{
        return minimalDaysInFirstWeek;
}

Gets what the minimal days required in the first week of the year are; e.g., if the first week is defined as one that contains the first day of the first month of a year, this method returns 1. If the minimal days required must be a full week, this method returns 7.

 abstract public int getMinimum(int field)
Returns the minimum value for the given calendar field of this
Calendar instance. The minimum value is defined as
the smallest value returned by the  get  method
for any possible time value.  The minimum value depends on
calendar system specific parameters of the instance.

 final int getSetStateFields() 
{
        int mask = 0;
        for (int i = 0; i <  fields.length; i++) {
            if (stamp[i] != UNSET) {
                mask |= 1 < <  i;
            }
        }
        return mask;
}

Returns a field mask (bit mask) indicating all calendar fields that have the state of externally or internally set.

 public final Date getTime() 
{
        return new Date(getTimeInMillis());
}

Returns a Date object representing this Calendar's time value (millisecond offset from the Epoch").

 public long getTimeInMillis() 
{
        if (!isTimeSet) {
            updateTime();
        }
        return time;
}

Returns this Calendar's time value in milliseconds.

 public TimeZone getTimeZone() 
{
        // If the TimeZone object is shared by other Calendar instances, then
        // create a clone.
        if (sharedZone) {
            zone = (TimeZone) zone.clone();
            sharedZone = false;
        }
        return zone;
}

Gets the time zone.

 public int getWeekYear() 
{
        throw new UnsupportedOperationException();
}

Returns the week year represented by this {@code Calendar}. The week year is in sync with the week cycle. The {@linkplain #getFirstDayOfWeek() first day of the first week} is the first day of the week year.

The default implementation of this method throws an UnsupportedOperationException .

 public int getWeeksInWeekYear() 
{
        throw new UnsupportedOperationException();
}

Returns the number of weeks in the week year represented by this {@code Calendar}.

The default implementation of this method throws an {@code UnsupportedOperationException}.

 TimeZone getZone() 
{
        return zone;
}

Returns the time zone (without cloning).

 public int hashCode() 
{
        // 'otheritems' represents the hash code for the previous versions.
        int otheritems = (lenient ? 1 : 0)
            | (firstDayOfWeek < <  1)
            | (minimalDaysInFirstWeek < <  4)
            | (zone.hashCode() < <  7);
        long t = getMillisOf(this);
        return (int) t ^ (int)(t  > > 32) ^ otheritems;
}

Returns a hash code for this calendar.

 protected final int internalGet(int field) 
{
        return fields[field];
}

Returns the value of the given calendar field. This method does not involve normalization or validation of the field value.

 final  void internalSet(int field,
    int value) 
{
        fields[field] = value;
}

Sets the value of the given calendar field. This method does not affect any setting state of the field in this Calendar instance.

 final boolean isExternallySet(int field) 
{
        return stamp[field]  >= MINIMUM_USER_STAMP;
}

Returns whether the value of the specified calendar field has been set externally by calling one of the setter methods rather than by the internal time calculation.

 static final boolean isFieldSet(int fieldMask,
    int field) 
{
        return (fieldMask & (1 < <  field)) != 0;
}

Returns whether the specified field is on in the fieldMask.

 final boolean isFullyNormalized() 
{
        return areFieldsSet && areAllFieldsSet;
}

Returns whether the calendar fields are fully in sync with the time value.

 public boolean isLenient() 
{
        return lenient;
}

Tells whether date/time interpretation is to be lenient.

 final boolean isPartiallyNormalized() 
{
        return areFieldsSet && !areAllFieldsSet;
}

Returns whether the calendar fields are partially in sync with the time value or fully in sync but not stamp values are not normalized yet.

 public final boolean isSet(int field) 
{
        return stamp[field] != UNSET;
}

Determines if the given calendar field has a value set, including cases that the value has been set by internal fields calculations triggered by a get method call.

 public boolean isWeekDateSupported() 
{
        return false;
}

Returns whether this {@code Calendar} supports week dates.

The default implementation of this method returns {@code false}.

 abstract public  void roll(int field,
    boolean up)
Adds or subtracts (up/down) a single unit of time on the given time
field without changing larger fields. For example, to roll the current
date up by one day, you can achieve it by calling:
roll(Calendar.DATE, true).
When rolling on the year or Calendar.YEAR field, it will roll the year
value in the range between 1 and the value returned by calling
getMaximum(Calendar.YEAR).
When rolling on the month or Calendar.MONTH field, other fields like
date might conflict and, need to be changed. For instance,
rolling the month on the date 01/31/96 will result in 02/29/96.
When rolling on the hour-in-day or Calendar.HOUR_OF_DAY field, it will
roll the hour value in the range between 0 and 23, which is zero-based.

 public  void roll(int field,
    int amount) 
{
        while (amount  > 0) {
            roll(field, true);
            amount--;
        }
        while (amount <  0) {
            roll(field, false);
            amount++;
        }
}

Adds the specified (signed) amount to the specified calendar field without changing larger fields. A negative amount means to roll down.

NOTE: This default implementation on Calendar just repeatedly calls the version of roll() that rolls by one unit. This may not always do the right thing. For example, if the DAY_OF_MONTH field is 31, rolling through February will leave it set to 28. The GregorianCalendar version of this function takes care of this problem. Other subclasses should also provide overrides of this function that do the right thing.

 final int selectFields() 
{
        // This implementation has been taken from the GregorianCalendar class.
        // The YEAR field must always be used regardless of its SET
        // state because YEAR is a mandatory field to determine the date
        // and the default value (EPOCH_YEAR) may change through the
        // normalization process.
        int fieldMask = YEAR_MASK;
        if (stamp[ERA] != UNSET) {
            fieldMask |= ERA_MASK;
        }
        // Find the most recent group of fields specifying the day within
        // the year.  These may be any of the following combinations:
        //   MONTH + DAY_OF_MONTH
        //   MONTH + WEEK_OF_MONTH + DAY_OF_WEEK
        //   MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK
        //   DAY_OF_YEAR
        //   WEEK_OF_YEAR + DAY_OF_WEEK
        // We look for the most recent of the fields in each group to determine
        // the age of the group.  For groups involving a week-related field such
        // as WEEK_OF_MONTH, DAY_OF_WEEK_IN_MONTH, or WEEK_OF_YEAR, both the
        // week-related field and the DAY_OF_WEEK must be set for the group as a
        // whole to be considered.  (See bug 4153860 - liu 7/24/98.)
        int dowStamp = stamp[DAY_OF_WEEK];
        int monthStamp = stamp[MONTH];
        int domStamp = stamp[DAY_OF_MONTH];
        int womStamp = aggregateStamp(stamp[WEEK_OF_MONTH], dowStamp);
        int dowimStamp = aggregateStamp(stamp[DAY_OF_WEEK_IN_MONTH], dowStamp);
        int doyStamp = stamp[DAY_OF_YEAR];
        int woyStamp = aggregateStamp(stamp[WEEK_OF_YEAR], dowStamp);
        int bestStamp = domStamp;
        if (womStamp  > bestStamp) {
            bestStamp = womStamp;
        }
        if (dowimStamp  > bestStamp) {
            bestStamp = dowimStamp;
        }
        if (doyStamp  > bestStamp) {
            bestStamp = doyStamp;
        }
        if (woyStamp  > bestStamp) {
            bestStamp = woyStamp;
        }
        /* No complete combination exists.  Look for WEEK_OF_MONTH,
         * DAY_OF_WEEK_IN_MONTH, or WEEK_OF_YEAR alone.  Treat DAY_OF_WEEK alone
         * as DAY_OF_WEEK_IN_MONTH.
         */
        if (bestStamp == UNSET) {
            womStamp = stamp[WEEK_OF_MONTH];
            dowimStamp = Math.max(stamp[DAY_OF_WEEK_IN_MONTH], dowStamp);
            woyStamp = stamp[WEEK_OF_YEAR];
            bestStamp = Math.max(Math.max(womStamp, dowimStamp), woyStamp);
            /* Treat MONTH alone or no fields at all as DAY_OF_MONTH.  This may
             * result in bestStamp = domStamp = UNSET if no fields are set,
             * which indicates DAY_OF_MONTH.
             */
            if (bestStamp == UNSET) {
                bestStamp = domStamp = monthStamp;
            }
        }
        if (bestStamp == domStamp ||
           (bestStamp == womStamp && stamp[WEEK_OF_MONTH]  >= stamp[WEEK_OF_YEAR]) ||
           (bestStamp == dowimStamp && stamp[DAY_OF_WEEK_IN_MONTH]  >= stamp[WEEK_OF_YEAR])) {
            fieldMask |= MONTH_MASK;
            if (bestStamp == domStamp) {
                fieldMask |= DAY_OF_MONTH_MASK;
            } else {
                assert (bestStamp == womStamp || bestStamp == dowimStamp);
                if (dowStamp != UNSET) {
                    fieldMask |= DAY_OF_WEEK_MASK;
                }
                if (womStamp == dowimStamp) {
                    // When they are equal, give the priority to
                    // WEEK_OF_MONTH for compatibility.
                    if (stamp[WEEK_OF_MONTH]  >= stamp[DAY_OF_WEEK_IN_MONTH]) {
                        fieldMask |= WEEK_OF_MONTH_MASK;
                    } else {
                        fieldMask |= DAY_OF_WEEK_IN_MONTH_MASK;
                    }
                } else {
                    if (bestStamp == womStamp) {
                        fieldMask |= WEEK_OF_MONTH_MASK;
                    } else {
                        assert (bestStamp == dowimStamp);
                        if (stamp[DAY_OF_WEEK_IN_MONTH] != UNSET) {
                            fieldMask |= DAY_OF_WEEK_IN_MONTH_MASK;
                        }
                    }
                }
            }
        } else {
            assert (bestStamp == doyStamp || bestStamp == woyStamp ||
                    bestStamp == UNSET);
            if (bestStamp == doyStamp) {
                fieldMask |= DAY_OF_YEAR_MASK;
            } else {
                assert (bestStamp == woyStamp);
                if (dowStamp != UNSET) {
                    fieldMask |= DAY_OF_WEEK_MASK;
                }
                fieldMask |= WEEK_OF_YEAR_MASK;
            }
        }
        // Find the best set of fields specifying the time of day.  There
        // are only two possibilities here; the HOUR_OF_DAY or the
        // AM_PM and the HOUR.
        int hourOfDayStamp = stamp[HOUR_OF_DAY];
        int hourStamp = aggregateStamp(stamp[HOUR], stamp[AM_PM]);
        bestStamp = (hourStamp  > hourOfDayStamp) ? hourStamp : hourOfDayStamp;
        // if bestStamp is still UNSET, then take HOUR or AM_PM. (See 4846659)
        if (bestStamp == UNSET) {
            bestStamp = Math.max(stamp[HOUR], stamp[AM_PM]);
        }
        // Hours
        if (bestStamp != UNSET) {
            if (bestStamp == hourOfDayStamp) {
                fieldMask |= HOUR_OF_DAY_MASK;
            } else {
                fieldMask |= HOUR_MASK;
                if (stamp[AM_PM] != UNSET) {
                    fieldMask |= AM_PM_MASK;
                }
            }
        }
        if (stamp[MINUTE] != UNSET) {
            fieldMask |= MINUTE_MASK;
        }
        if (stamp[SECOND] != UNSET) {
            fieldMask |= SECOND_MASK;
        }
        if (stamp[MILLISECOND] != UNSET) {
            fieldMask |= MILLISECOND_MASK;
        }
        if (stamp[ZONE_OFFSET]  >= MINIMUM_USER_STAMP) {
                fieldMask |= ZONE_OFFSET_MASK;
        }
        if (stamp[DST_OFFSET]  >= MINIMUM_USER_STAMP) {
            fieldMask |= DST_OFFSET_MASK;
        }
        return fieldMask;
}

Returns a field mask indicating which calendar field values to be used to calculate the time value. The calendar fields are returned as a bit mask, each bit of which corresponds to a field, i.e., the mask value of field is (1 << field). For example, 0x26 represents the YEAR, MONTH, and DAY_OF_MONTH fields (i.e., 0x26 is equal to (1<<YEAR)|(1<<MONTH)|(1<<DAY_OF_MONTH)).

This method supports the calendar fields resolution as described in the class description. If the bit mask for a given field is on and its field has not been set (i.e., isSet(field) is false), then the default value of the field has to be used, which case means that the field has been selected because the selected combination involves the field.

 public  void set(int field,
    int value) 
{
        // If the fields are partially normalized, calculate all the
        // fields before changing any fields.
        if (areFieldsSet && !areAllFieldsSet) {
            computeFields();
        }
        internalSet(field, value);
        isTimeSet = false;
        areFieldsSet = false;
        isSet[field] = true;
        stamp[field] = nextStamp++;
        if (nextStamp == Integer.MAX_VALUE) {
            adjustStamp();
        }
}

Sets the given calendar field to the given value. The value is not interpreted by this method regardless of the leniency mode.

 public final  void set(int year,
    int month,
    int date) 
{
        set(YEAR, year);
        set(MONTH, month);
        set(DATE, date);
}

Sets the values for the calendar fields YEAR, MONTH, and DAY_OF_MONTH. Previous values of other calendar fields are retained. If this is not desired, call #clear() first.

 public final  void set(int year,
    int month,
    int date,
    int hourOfDay,
    int minute) 
{
        set(YEAR, year);
        set(MONTH, month);
        set(DATE, date);
        set(HOUR_OF_DAY, hourOfDay);
        set(MINUTE, minute);
}

Sets the values for the calendar fields YEAR, MONTH, DAY_OF_MONTH, HOUR_OF_DAY, and MINUTE. Previous values of other fields are retained. If this is not desired, call #clear() first.

 public final  void set(int year,
    int month,
    int date,
    int hourOfDay,
    int minute,
    int second) 
{
        set(YEAR, year);
        set(MONTH, month);
        set(DATE, date);
        set(HOUR_OF_DAY, hourOfDay);
        set(MINUTE, minute);
        set(SECOND, second);
}

Sets the values for the fields YEAR, MONTH, DAY_OF_MONTH, HOUR, MINUTE, and SECOND. Previous values of other fields are retained. If this is not desired, call #clear() first.

 final  void setFieldsComputed(int fieldMask) 
{
        if (fieldMask == ALL_FIELDS) {
            for (int i = 0; i <  fields.length; i++) {
                stamp[i] = COMPUTED;
                isSet[i] = true;
            }
            areFieldsSet = areAllFieldsSet = true;
        } else {
            for (int i = 0; i <  fields.length; i++) {
                if ((fieldMask & 1) == 1) {
                    stamp[i] = COMPUTED;
                    isSet[i] = true;
                } else {
                    if (areAllFieldsSet && !isSet[i]) {
                        areAllFieldsSet = false;
                    }
                }
                fieldMask  > > >= 1;
            }
        }
}

Sets the state of the specified calendar fields to computed. This state means that the specified calendar fields have valid values that have been set by internal time calculation rather than by calling one of the setter methods.

 final  void setFieldsNormalized(int fieldMask) 
{
        if (fieldMask != ALL_FIELDS) {
            for (int i = 0; i <  fields.length; i++) {
                if ((fieldMask & 1) == 0) {
                    stamp[i] = fields[i] = 0; // UNSET == 0
                    isSet[i] = false;
                }
                fieldMask  > >= 1;
            }
        }
        // Some or all of the fields are in sync with the
        // milliseconds, but the stamp values are not normalized yet.
        areFieldsSet = true;
        areAllFieldsSet = false;
}

Sets the state of the calendar fields that are not specified by fieldMask to unset. If fieldMask specifies all the calendar fields, then the state of this Calendar becomes that all the calendar fields are in sync with the time value (millisecond offset from the Epoch).

 public  void setFirstDayOfWeek(int value) 
{
        if (firstDayOfWeek == value) {
            return;
        }
        firstDayOfWeek = value;
        invalidateWeekFields();
}

Sets what the first day of the week is; e.g., SUNDAY in the U.S., MONDAY in France.

 public  void setLenient(boolean lenient) 
{
        this.lenient = lenient;
}

Specifies whether or not date/time interpretation is to be lenient. With lenient interpretation, a date such as "February 942, 1996" will be treated as being equivalent to the 941st day after February 1, 1996. With strict (non-lenient) interpretation, such dates will cause an exception to be thrown. The default is lenient.

 public  void setMinimalDaysInFirstWeek(int value) 
{
        if (minimalDaysInFirstWeek == value) {
            return;
        }
        minimalDaysInFirstWeek = value;
        invalidateWeekFields();
}

Sets what the minimal days required in the first week of the year are; For example, if the first week is defined as one that contains the first day of the first month of a year, call this method with value 1. If it must be a full week, use value 7.

 public final  void setTime(Date date) 
{
        setTimeInMillis(date.getTime());
}

Sets this Calendar's time with the given Date.

Note: Calling setTime() with Date(Long.MAX_VALUE) or Date(Long.MIN_VALUE) may yield incorrect field values from get().

 public  void setTimeInMillis(long millis) 
{
        // If we don't need to recalculate the calendar field values,
        // do nothing.
        if (time == millis && isTimeSet && areFieldsSet && areAllFieldsSet
            && (zone instanceof ZoneInfo) && !((ZoneInfo)zone).isDirty()) {
            return;
        }
        time = millis;
        isTimeSet = true;
        areFieldsSet = false;
        computeFields();
        areAllFieldsSet = areFieldsSet = true;
}

Sets this Calendar's current time from the given long value.

 public  void setTimeZone(TimeZone value) 
{
        zone = value;
        sharedZone = false;
        /* Recompute the fields from the time using the new zone.  This also
         * works if isTimeSet is false (after a call to set()).  In that case
         * the time will be computed from the fields using the new zone, then
         * the fields will get recomputed from that.  Consider the sequence of
         * calls: cal.setTimeZone(EST); cal.set(HOUR, 1); cal.setTimeZone(PST).
         * Is cal set to 1 o'clock EST or 1 o'clock PST?  Answer: PST.  More
         * generally, a call to setTimeZone() affects calls to set() BEFORE AND
         * AFTER it up to the next call to complete().
         */
        areAllFieldsSet = areFieldsSet = false;
}

Sets the time zone with the given time zone value.

 final  void setUnnormalized() 
{
        areFieldsSet = areAllFieldsSet = false;
}

Marks this Calendar as not sync'd.

 public  void setWeekDate(int weekYear,
    int weekOfYear,
    int dayOfWeek) 
{
        throw new UnsupportedOperationException();
}

Sets the date of this {@code Calendar} with the the given date specifiers - week year, week of year, and day of week.

Unlike the {@code set} method, all of the calendar fields and {@code time} values are calculated upon return.

If {@code weekOfYear} is out of the valid week-of-year range in {@code weekYear}, the {@code weekYear} and {@code weekOfYear} values are adjusted in lenient mode, or an {@code IllegalArgumentException} is thrown in non-lenient mode.

The default implementation of this method throws an {@code UnsupportedOperationException}.

  void setZoneShared(boolean shared) 
{
        sharedZone = shared;
}

Sets the sharedZone flag to shared.

 public String toString() 
{
        // NOTE: BuddhistCalendar.toString() interprets the string
        // produced by this method so that the Gregorian year number
        // is substituted by its B.E. year value. It relies on
        // "...,YEAR=< year >,..." or "...,YEAR=?,...".
        StringBuilder buffer = new StringBuilder(800);
        buffer.append(getClass().getName()).append('[');
        appendValue(buffer, "time", isTimeSet, time);
        buffer.append(",areFieldsSet=").append(areFieldsSet);
        buffer.append(",areAllFieldsSet=").append(areAllFieldsSet);
        buffer.append(",lenient=").append(lenient);
        buffer.append(",zone=").append(zone);
        appendValue(buffer, ",firstDayOfWeek", true, (long) firstDayOfWeek);
        appendValue(buffer, ",minimalDaysInFirstWeek", true, (long) minimalDaysInFirstWeek);
        for (int i = 0; i <  FIELD_COUNT; ++i) {
            buffer.append(',');
            appendValue(buffer, FIELD_NAME[i], isSet(i), (long) fields[i]);
        }
        buffer.append(']');
        return buffer.toString();
}

Return a string representation of this calendar. This method is intended to be used only for debugging purposes, and the format of the returned string may vary between implementations. The returned string may be empty but may not be null.