【GregorianCalendar】格林尼治时间GregorianCalendar[]解密
来源：互联网 发布：策略经营单机手游 知乎 编辑：程序博客网 时间：2024/06/06 07:13
1.问题：
Calendar中有一个特别烦人的东西，就是格林尼治日历时间（GreGorianCalendar[ ]）,ta到底是什么鬼？
2.源代码：
startCal:"java.util.GregorianCalendar[time=?],areFieldsSet=false,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSaving=0,useDaylight=false,transitions=19,lastRule=null],fitstDayOfWeek=1,ERA=1,YEAR=2017,MONTH=0,WEEK_OF_YEAR=24,WEEK_OF_MONTH=3,DAY_OF_MONTH17,DAY_OF_YEAR=168,DAY_OFWEEK=7,DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=3,HOUR_OF_DAY=15,MINUTE=33,SECOND=0,MILLISECOND=0,ZONE_OFFSET=28800000,DST_OFFSET=0]"这样不好看，我们给美化下：
startCal:"java.util.GregorianCalendar[time=?,areFieldsSet=false,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSaving=0,useDaylight=false,transitions=19,lastRule=null],fitstDayOfWeek=1,ERA=1,YEAR=2017,MONTH=0,WEEK_OF_YEAR=24,WEEK_OF_MONTH=3,DAY_OF_MONTH17,DAY_OF_YEAR=168,DAY_OFWEEK=7,DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=3,HOUR_OF_DAY=15,MINUTE=33,SECOND=0,MILLISECOND=0,ZONE_OFFSET=28800000,DST_OFFSET=0]"你好
官方源码：
等有空来翻译；
/* * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. *//* * (C) Copyright Taligent, Inc. 1996-1998 - All Rights Reserved * (C) Copyright IBM Corp. 1996-1998 - All Rights Reserved * * The original version of this source code and documentation is copyrighted * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These * materials are provided under terms of a License Agreement between Taligent * and Sun. This technology is protected by multiple US and International * patents. This notice and attribution to Taligent may not be removed. * Taligent is a registered trademark of Taligent, Inc. * */package java.util;import java.io.IOException;import java.io.ObjectInputStream;import java.time.Instant;import java.time.ZonedDateTime;import java.time.temporal.ChronoField;import sun.util.calendar.BaseCalendar;import sun.util.calendar.CalendarDate;import sun.util.calendar.CalendarSystem;import sun.util.calendar.CalendarUtils;import sun.util.calendar.Era;import sun.util.calendar.Gregorian;import sun.util.calendar.JulianCalendar;import sun.util.calendar.ZoneInfo;/** * <code>GregorianCalendar</code> is a concrete subclass of * <code>Calendar</code> and provides the standard calendar system * used by most of the world. * * <p> <code>GregorianCalendar</code> is a hybrid calendar that * supports both the Julian and Gregorian calendar systems with the * support of a single discontinuity, which corresponds by default to * the Gregorian date when the Gregorian calendar was instituted * (October 15, 1582 in some countries, later in others). The cutover * date may be changed by the caller by calling {@link * #setGregorianChange(Date) setGregorianChange()}. * * <p> * Historically, in those countries which adopted the Gregorian calendar first, * October 4, 1582 (Julian) was thus followed by October 15, 1582 (Gregorian). This calendar models * this correctly. Before the Gregorian cutover, <code>GregorianCalendar</code> * implements the Julian calendar. The only difference between the Gregorian * and the Julian calendar is the leap year rule. The Julian calendar specifies * leap years every four years, whereas the Gregorian calendar omits century * years which are not divisible by 400. * * <p> * <code>GregorianCalendar</code> implements <em>proleptic</em> Gregorian and * Julian calendars. That is, dates are computed by extrapolating the current * rules indefinitely far backward and forward in time. As a result, * <code>GregorianCalendar</code> may be used for all years to generate * meaningful and consistent results. However, dates obtained using * <code>GregorianCalendar</code> are historically accurate only from March 1, 4 * AD onward, when modern Julian calendar rules were adopted. Before this date, * leap year rules were applied irregularly, and before 45 BC the Julian * calendar did not even exist. * * <p> * Prior to the institution of the Gregorian calendar, New Year's Day was * March 25. To avoid confusion, this calendar always uses January 1. A manual * adjustment may be made if desired for dates that are prior to the Gregorian * changeover and which fall between January 1 and March 24. * * <h3><a name="week_and_year">Week Of Year and Week Year</a></h3> * * <p>Values calculated for the {@link Calendar#WEEK_OF_YEAR * WEEK_OF_YEAR} field range from 1 to 53. The first week of a * calendar year is the earliest seven day period starting on {@link * Calendar#getFirstDayOfWeek() getFirstDayOfWeek()} that contains at * least {@link Calendar#getMinimalDaysInFirstWeek() * getMinimalDaysInFirstWeek()} days from that year. It thus depends * on the values of {@code getMinimalDaysInFirstWeek()}, {@code * getFirstDayOfWeek()}, and the day of the week of January 1. Weeks * between week 1 of one year and week 1 of the following year * (exclusive) are numbered sequentially from 2 to 52 or 53 (except * for year(s) involved in the Julian-Gregorian transition). * * <p>The {@code getFirstDayOfWeek()} and {@code * getMinimalDaysInFirstWeek()} values are initialized using * locale-dependent resources when constructing a {@code * GregorianCalendar}. <a name="iso8601_compatible_setting">The week * determination is compatible</a> with the ISO 8601 standard when {@code * getFirstDayOfWeek()} is {@code MONDAY} and {@code * getMinimalDaysInFirstWeek()} is 4, which values are used in locales * where the standard is preferred. These values can explicitly be set by * calling {@link Calendar#setFirstDayOfWeek(int) setFirstDayOfWeek()} and * {@link Calendar#setMinimalDaysInFirstWeek(int) * setMinimalDaysInFirstWeek()}. * * <p>A <a name="week_year"><em>week year</em></a> is in sync with a * {@code WEEK_OF_YEAR} cycle. All weeks between the first and last * weeks (inclusive) have the same <em>week year</em> value. * Therefore, the first and last days of a week year may have * different calendar year values. * * <p>For example, January 1, 1998 is a Thursday. If {@code * getFirstDayOfWeek()} is {@code MONDAY} and {@code * getMinimalDaysInFirstWeek()} is 4 (ISO 8601 standard compatible * setting), then week 1 of 1998 starts on December 29, 1997, and ends * on January 4, 1998. The week year is 1998 for the last three days * of calendar year 1997. If, however, {@code getFirstDayOfWeek()} is * {@code SUNDAY}, then week 1 of 1998 starts on January 4, 1998, and * ends on January 10, 1998; the first three days of 1998 then are * part of week 53 of 1997 and their week year is 1997. * * <h4>Week Of Month</h4> * * <p>Values calculated for the <code>WEEK_OF_MONTH</code> field range from 0 * to 6. Week 1 of a month (the days with <code>WEEK_OF_MONTH = * 1</code>) is the earliest set of at least * <code>getMinimalDaysInFirstWeek()</code> contiguous days in that month, * ending on the day before <code>getFirstDayOfWeek()</code>. Unlike * week 1 of a year, week 1 of a month may be shorter than 7 days, need * not start on <code>getFirstDayOfWeek()</code>, and will not include days of * the previous month. Days of a month before week 1 have a * <code>WEEK_OF_MONTH</code> of 0. * * <p>For example, if <code>getFirstDayOfWeek()</code> is <code>SUNDAY</code> * and <code>getMinimalDaysInFirstWeek()</code> is 4, then the first week of * January 1998 is Sunday, January 4 through Saturday, January 10. These days * have a <code>WEEK_OF_MONTH</code> of 1. Thursday, January 1 through * Saturday, January 3 have a <code>WEEK_OF_MONTH</code> of 0. If * <code>getMinimalDaysInFirstWeek()</code> is changed to 3, then January 1 * through January 3 have a <code>WEEK_OF_MONTH</code> of 1. * * <h4>Default Fields Values</h4> * * <p>The <code>clear</code> method sets calendar field(s) * undefined. <code>GregorianCalendar</code> uses the following * default value for each calendar field if its value is undefined. * * <table cellpadding="0" cellspacing="3" border="0" * summary="GregorianCalendar default field values" * style="text-align: left; width: 66%;"> * <tbody> * <tr> * <th style="vertical-align: top; background-color: rgb(204, 204, 255); * text-align: center;">Field<br> * </th> * <th style="vertical-align: top; background-color: rgb(204, 204, 255); * text-align: center;">Default Value<br> * </th> * </tr> * <tr> * <td style="vertical-align: middle;"> * <code>ERA<br></code> * </td> * <td style="vertical-align: middle;"> * <code>AD<br></code> * </td> * </tr> * <tr> * <td style="vertical-align: middle; background-color: rgb(238, 238, 255);"> * <code>YEAR<br></code> * </td> * <td style="vertical-align: middle; background-color: rgb(238, 238, 255);"> * <code>1970<br></code> * </td> * </tr> * <tr> * <td style="vertical-align: middle;"> * <code>MONTH<br></code> * </td> * <td style="vertical-align: middle;"> * <code>JANUARY<br></code> * </td> * </tr> * <tr> * <td style="vertical-align: top; background-color: rgb(238, 238, 255);"> * <code>DAY_OF_MONTH<br></code> * </td> * <td style="vertical-align: top; background-color: rgb(238, 238, 255);"> * <code>1<br></code> * </td> * </tr> * <tr> * <td style="vertical-align: middle;"> * <code>DAY_OF_WEEK<br></code> * </td> * <td style="vertical-align: middle;"> * <code>the first day of week<br></code> * </td> * </tr> * <tr> * <td style="vertical-align: top; background-color: rgb(238, 238, 255);"> * <code>WEEK_OF_MONTH<br></code> * </td> * <td style="vertical-align: top; background-color: rgb(238, 238, 255);"> * <code>0<br></code> * </td> * </tr> * <tr> * <td style="vertical-align: top;"> * <code>DAY_OF_WEEK_IN_MONTH<br></code> * </td> * <td style="vertical-align: top;"> * <code>1<br></code> * </td> * </tr> * <tr> * <td style="vertical-align: middle; background-color: rgb(238, 238, 255);"> * <code>AM_PM<br></code> * </td> * <td style="vertical-align: middle; background-color: rgb(238, 238, 255);"> * <code>AM<br></code> * </td> * </tr> * <tr> * <td style="vertical-align: middle;"> * <code>HOUR, HOUR_OF_DAY, MINUTE, SECOND, MILLISECOND<br></code> * </td> * <td style="vertical-align: middle;"> * <code>0<br></code> * </td> * </tr> * </tbody> * </table> * <br>Default values are not applicable for the fields not listed above. * * <p> * <strong>Example:</strong> * <blockquote> * <pre> * // get the supported ids for GMT-08:00 (Pacific Standard Time) * String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000); * // if no ids were returned, something is wrong. get out. * if (ids.length == 0) * System.exit(0); * * // begin output * System.out.println("Current Time"); * * // create a Pacific Standard Time time zone * SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]); * * // set up rules for Daylight Saving Time * pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2 * 60 * 60 * 1000); * pdt.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2 * 60 * 60 * 1000); * * // create a GregorianCalendar with the Pacific Daylight time zone * // and the current date and time * Calendar calendar = new GregorianCalendar(pdt); * Date trialTime = new Date(); * calendar.setTime(trialTime); * * // print out a bunch of interesting things * System.out.println("ERA: " + calendar.get(Calendar.ERA)); * System.out.println("YEAR: " + calendar.get(Calendar.YEAR)); * System.out.println("MONTH: " + calendar.get(Calendar.MONTH)); * System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR)); * System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH)); * System.out.println("DATE: " + calendar.get(Calendar.DATE)); * System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH)); * System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR)); * System.out.println("DAY_OF_WEEK: " + calendar.get(Calendar.DAY_OF_WEEK)); * System.out.println("DAY_OF_WEEK_IN_MONTH: " * + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH)); * System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM)); * System.out.println("HOUR: " + calendar.get(Calendar.HOUR)); * System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY)); * System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE)); * System.out.println("SECOND: " + calendar.get(Calendar.SECOND)); * System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND)); * System.out.println("ZONE_OFFSET: " * + (calendar.get(Calendar.ZONE_OFFSET)/(60*60*1000))); * System.out.println("DST_OFFSET: " * + (calendar.get(Calendar.DST_OFFSET)/(60*60*1000))); * System.out.println("Current Time, with hour reset to 3"); * calendar.clear(Calendar.HOUR_OF_DAY); // so doesn't override * calendar.set(Calendar.HOUR, 3); * System.out.println("ERA: " + calendar.get(Calendar.ERA)); * System.out.println("YEAR: " + calendar.get(Calendar.YEAR)); * System.out.println("MONTH: " + calendar.get(Calendar.MONTH)); * System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR)); * System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH)); * System.out.println("DATE: " + calendar.get(Calendar.DATE)); * System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH)); * System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR)); * System.out.println("DAY_OF_WEEK: " + calendar.get(Calendar.DAY_OF_WEEK)); * System.out.println("DAY_OF_WEEK_IN_MONTH: " * + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH)); * System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM)); * System.out.println("HOUR: " + calendar.get(Calendar.HOUR)); * System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY)); * System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE)); * System.out.println("SECOND: " + calendar.get(Calendar.SECOND)); * System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND)); * System.out.println("ZONE_OFFSET: " * + (calendar.get(Calendar.ZONE_OFFSET)/(60*60*1000))); // in hours * System.out.println("DST_OFFSET: " * + (calendar.get(Calendar.DST_OFFSET)/(60*60*1000))); // in hours * </pre> * </blockquote> * * @see TimeZone * @author David Goldsmith, Mark Davis, Chen-Lieh Huang, Alan Liu * @since JDK1.1 */public class GregorianCalendar extends Calendar { /* * Implementation Notes * * The epoch is the number of days or milliseconds from some defined * starting point. The epoch for java.util.Date is used here; that is, * milliseconds from January 1, 1970 (Gregorian), midnight UTC. Other * epochs which are used are January 1, year 1 (Gregorian), which is day 1 * of the Gregorian calendar, and December 30, year 0 (Gregorian), which is * day 1 of the Julian calendar. * * We implement the proleptic Julian and Gregorian calendars. This means we * implement the modern definition of the calendar even though the * historical usage differs. For example, if the Gregorian change is set * to new Date(Long.MIN_VALUE), we have a pure Gregorian calendar which * labels dates preceding the invention of the Gregorian calendar in 1582 as * if the calendar existed then. * * Likewise, with the Julian calendar, we assume a consistent * 4-year leap year rule, even though the historical pattern of * leap years is irregular, being every 3 years from 45 BCE * through 9 BCE, then every 4 years from 8 CE onwards, with no * leap years in-between. Thus date computations and functions * such as isLeapYear() are not intended to be historically * accurate. *///////////////////// Class Variables////////////////// /** * Value of the <code>ERA</code> field indicating * the period before the common era (before Christ), also known as BCE. * The sequence of years at the transition from <code>BC</code> to <code>AD</code> is * ..., 2 BC, 1 BC, 1 AD, 2 AD,... * * @see #ERA */ public static final int BC = 0; /** * Value of the {@link #ERA} field indicating * the period before the common era, the same value as {@link #BC}. * * @see #CE */ static final int BCE = 0; /** * Value of the <code>ERA</code> field indicating * the common era (Anno Domini), also known as CE. * The sequence of years at the transition from <code>BC</code> to <code>AD</code> is * ..., 2 BC, 1 BC, 1 AD, 2 AD,... * * @see #ERA */ public static final int AD = 1; /** * Value of the {@link #ERA} field indicating * the common era, the same value as {@link #AD}. * * @see #BCE */ static final int CE = 1; private static final int EPOCH_OFFSET = 719163; // Fixed date of January 1, 1970 (Gregorian) private static final int EPOCH_YEAR = 1970; static final int MONTH_LENGTH[] = {31,28,31,30,31,30,31,31,30,31,30,31}; // 0-based static final int LEAP_MONTH_LENGTH[] = {31,29,31,30,31,30,31,31,30,31,30,31}; // 0-based // Useful millisecond constants. Although ONE_DAY and ONE_WEEK can fit // into ints, they must be longs in order to prevent arithmetic overflow // when performing (bug 4173516). private static final int ONE_SECOND = 1000; private static final int ONE_MINUTE = 60*ONE_SECOND; private static final int ONE_HOUR = 60*ONE_MINUTE; private static final long ONE_DAY = 24*ONE_HOUR; private static final long ONE_WEEK = 7*ONE_DAY; /* * <pre> * Greatest Least * Field name Minimum Minimum Maximum Maximum * ---------- ------- ------- ------- ------- * ERA 0 0 1 1 * YEAR 1 1 292269054 292278994 * MONTH 0 0 11 11 * WEEK_OF_YEAR 1 1 52* 53 * WEEK_OF_MONTH 0 0 4* 6 * DAY_OF_MONTH 1 1 28* 31 * DAY_OF_YEAR 1 1 365* 366 * DAY_OF_WEEK 1 1 7 7 * DAY_OF_WEEK_IN_MONTH -1 -1 4* 6 * AM_PM 0 0 1 1 * HOUR 0 0 11 11 * HOUR_OF_DAY 0 0 23 23 * MINUTE 0 0 59 59 * SECOND 0 0 59 59 * MILLISECOND 0 0 999 999 * ZONE_OFFSET -13:00 -13:00 14:00 14:00 * DST_OFFSET 0:00 0:00 0:20 2:00 * </pre> * *: depends on the Gregorian change date */ static final int MIN_VALUES[] = { BCE, // ERA 1, // YEAR JANUARY, // MONTH 1, // WEEK_OF_YEAR 0, // WEEK_OF_MONTH 1, // DAY_OF_MONTH 1, // DAY_OF_YEAR SUNDAY, // DAY_OF_WEEK 1, // DAY_OF_WEEK_IN_MONTH AM, // AM_PM 0, // HOUR 0, // HOUR_OF_DAY 0, // MINUTE 0, // SECOND 0, // MILLISECOND -13*ONE_HOUR, // ZONE_OFFSET (UNIX compatibility) 0 // DST_OFFSET }; static final int LEAST_MAX_VALUES[] = { CE, // ERA 292269054, // YEAR DECEMBER, // MONTH 52, // WEEK_OF_YEAR 4, // WEEK_OF_MONTH 28, // DAY_OF_MONTH 365, // DAY_OF_YEAR SATURDAY, // DAY_OF_WEEK 4, // DAY_OF_WEEK_IN PM, // AM_PM 11, // HOUR 23, // HOUR_OF_DAY 59, // MINUTE 59, // SECOND 999, // MILLISECOND 14*ONE_HOUR, // ZONE_OFFSET 20*ONE_MINUTE // DST_OFFSET (historical least maximum) }; static final int MAX_VALUES[] = { CE, // ERA 292278994, // YEAR DECEMBER, // MONTH 53, // WEEK_OF_YEAR 6, // WEEK_OF_MONTH 31, // DAY_OF_MONTH 366, // DAY_OF_YEAR SATURDAY, // DAY_OF_WEEK 6, // DAY_OF_WEEK_IN PM, // AM_PM 11, // HOUR 23, // HOUR_OF_DAY 59, // MINUTE 59, // SECOND 999, // MILLISECOND 14*ONE_HOUR, // ZONE_OFFSET 2*ONE_HOUR // DST_OFFSET (double summer time) }; // Proclaim serialization compatibility with JDK 1.1 @SuppressWarnings("FieldNameHidesFieldInSuperclass") static final long serialVersionUID = -8125100834729963327L; // Reference to the sun.util.calendar.Gregorian instance (singleton). private static final Gregorian gcal = CalendarSystem.getGregorianCalendar(); // Reference to the JulianCalendar instance (singleton), set as needed. See // getJulianCalendarSystem(). private static JulianCalendar jcal; // JulianCalendar eras. See getJulianCalendarSystem(). private static Era[] jeras; // The default value of gregorianCutover. static final long DEFAULT_GREGORIAN_CUTOVER = -12219292800000L;/////////////////////// Instance Variables///////////////////// /** * The point at which the Gregorian calendar rules are used, measured in * milliseconds from the standard epoch. Default is October 15, 1582 * (Gregorian) 00:00:00 UTC or -12219292800000L. For this value, October 4, * 1582 (Julian) is followed by October 15, 1582 (Gregorian). This * corresponds to Julian day number 2299161. * @serial */ private long gregorianCutover = DEFAULT_GREGORIAN_CUTOVER; /** * The fixed date of the gregorianCutover. */ private transient long gregorianCutoverDate = (((DEFAULT_GREGORIAN_CUTOVER + 1)/ONE_DAY) - 1) + EPOCH_OFFSET; // == 577736 /** * The normalized year of the gregorianCutover in Gregorian, with * 0 representing 1 BCE, -1 representing 2 BCE, etc. */ private transient int gregorianCutoverYear = 1582; /** * The normalized year of the gregorianCutover in Julian, with 0 * representing 1 BCE, -1 representing 2 BCE, etc. */ private transient int gregorianCutoverYearJulian = 1582; /** * gdate always has a sun.util.calendar.Gregorian.Date instance to * avoid overhead of creating it. The assumption is that most * applications will need only Gregorian calendar calculations. */ private transient BaseCalendar.Date gdate; /** * Reference to either gdate or a JulianCalendar.Date * instance. After calling complete(), this value is guaranteed to * be set. */ private transient BaseCalendar.Date cdate; /** * The CalendarSystem used to calculate the date in cdate. After * calling complete(), this value is guaranteed to be set and * consistent with the cdate value. */ private transient BaseCalendar calsys; /** * Temporary int[2] to get time zone offsets. zoneOffsets[0] gets * the GMT offset value and zoneOffsets[1] gets the DST saving * value. */ private transient int[] zoneOffsets; /** * Temporary storage for saving original fields[] values in * non-lenient mode. */ private transient int[] originalFields;///////////////// Constructors/////////////// /** * Constructs a default <code>GregorianCalendar</code> using the current time * in the default time zone with the default * {@link Locale.Category#FORMAT FORMAT} locale. */ public GregorianCalendar() { this(TimeZone.getDefaultRef(), Locale.getDefault(Locale.Category.FORMAT)); setZoneShared(true); } /** * Constructs a <code>GregorianCalendar</code> based on the current time * in the given time zone with the default * {@link Locale.Category#FORMAT FORMAT} locale. * * @param zone the given time zone. */ public GregorianCalendar(TimeZone zone) { this(zone, Locale.getDefault(Locale.Category.FORMAT)); } /** * Constructs a <code>GregorianCalendar</code> based on the current time * in the default time zone with the given locale. * * @param aLocale the given locale. */ public GregorianCalendar(Locale aLocale) { this(TimeZone.getDefaultRef(), aLocale); setZoneShared(true); } /** * Constructs a <code>GregorianCalendar</code> based on the current time * in the given time zone with the given locale. * * @param zone the given time zone. * @param aLocale the given locale. */ public GregorianCalendar(TimeZone zone, Locale aLocale) { super(zone, aLocale); gdate = (BaseCalendar.Date) gcal.newCalendarDate(zone); setTimeInMillis(System.currentTimeMillis()); } /** * Constructs a <code>GregorianCalendar</code> with the given date set * in the default time zone with the default locale. * * @param year the value used to set the <code>YEAR</code> calendar field in the calendar. * @param month the value used to set the <code>MONTH</code> calendar field in the calendar. * Month value is 0-based. e.g., 0 for January. * @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar. */ public GregorianCalendar(int year, int month, int dayOfMonth) { this(year, month, dayOfMonth, 0, 0, 0, 0); } /** * Constructs a <code>GregorianCalendar</code> with the given date * and time set for the default time zone with the default locale. * * @param year the value used to set the <code>YEAR</code> calendar field in the calendar. * @param month the value used to set the <code>MONTH</code> calendar field in the calendar. * Month value is 0-based. e.g., 0 for January. * @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar. * @param hourOfDay the value used to set the <code>HOUR_OF_DAY</code> calendar field * in the calendar. * @param minute the value used to set the <code>MINUTE</code> calendar field * in the calendar. */ public GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute) { this(year, month, dayOfMonth, hourOfDay, minute, 0, 0); } /** * Constructs a GregorianCalendar with the given date * and time set for the default time zone with the default locale. * * @param year the value used to set the <code>YEAR</code> calendar field in the calendar. * @param month the value used to set the <code>MONTH</code> calendar field in the calendar. * Month value is 0-based. e.g., 0 for January. * @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar. * @param hourOfDay the value used to set the <code>HOUR_OF_DAY</code> calendar field * in the calendar. * @param minute the value used to set the <code>MINUTE</code> calendar field * in the calendar. * @param second the value used to set the <code>SECOND</code> calendar field * in the calendar. */ public GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute, int second) { this(year, month, dayOfMonth, hourOfDay, minute, second, 0); } /** * Constructs a <code>GregorianCalendar</code> with the given date * and time set for the default time zone with the default locale. * * @param year the value used to set the <code>YEAR</code> calendar field in the calendar. * @param month the value used to set the <code>MONTH</code> calendar field in the calendar. * Month value is 0-based. e.g., 0 for January. * @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar. * @param hourOfDay the value used to set the <code>HOUR_OF_DAY</code> calendar field * in the calendar. * @param minute the value used to set the <code>MINUTE</code> calendar field * in the calendar. * @param second the value used to set the <code>SECOND</code> calendar field * in the calendar. * @param millis the value used to set the <code>MILLISECOND</code> calendar field */ GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute, int second, int millis) { super(); gdate = (BaseCalendar.Date) gcal.newCalendarDate(getZone()); this.set(YEAR, year); this.set(MONTH, month); this.set(DAY_OF_MONTH, dayOfMonth); // Set AM_PM and HOUR here to set their stamp values before // setting HOUR_OF_DAY (6178071). if (hourOfDay >= 12 && hourOfDay <= 23) { // If hourOfDay is a valid PM hour, set the correct PM values // so that it won't throw an exception in case it's set to // non-lenient later. this.internalSet(AM_PM, PM); this.internalSet(HOUR, hourOfDay - 12); } else { // The default value for AM_PM is AM. // We don't care any out of range value here for leniency. this.internalSet(HOUR, hourOfDay); } // The stamp values of AM_PM and HOUR must be COMPUTED. (6440854) setFieldsComputed(HOUR_MASK|AM_PM_MASK); this.set(HOUR_OF_DAY, hourOfDay); this.set(MINUTE, minute); this.set(SECOND, second); // should be changed to set() when this constructor is made // public. this.internalSet(MILLISECOND, millis); } /** * Constructs an empty GregorianCalendar. * * @param zone the given time zone * @param aLocale the given locale * @param flag the flag requesting an empty instance */ GregorianCalendar(TimeZone zone, Locale locale, boolean flag) { super(zone, locale); gdate = (BaseCalendar.Date) gcal.newCalendarDate(getZone()); }/////////////////// Public methods///////////////// /** * Sets the <code>GregorianCalendar</code> change date. This is the point when the switch * from Julian dates to Gregorian dates occurred. Default is October 15, * 1582 (Gregorian). Previous to this, dates will be in the Julian calendar. * <p> * To obtain a pure Julian calendar, set the change date to * <code>Date(Long.MAX_VALUE)</code>. To obtain a pure Gregorian calendar, * set the change date to <code>Date(Long.MIN_VALUE)</code>. * * @param date the given Gregorian cutover date. */ public void setGregorianChange(Date date) { long cutoverTime = date.getTime(); if (cutoverTime == gregorianCutover) { return; } // Before changing the cutover date, make sure to have the // time of this calendar. complete(); setGregorianChange(cutoverTime); } private void setGregorianChange(long cutoverTime) { gregorianCutover = cutoverTime; gregorianCutoverDate = CalendarUtils.floorDivide(cutoverTime, ONE_DAY) + EPOCH_OFFSET; // To provide the "pure" Julian calendar as advertised. // Strictly speaking, the last millisecond should be a // Gregorian date. However, the API doc specifies that setting // the cutover date to Long.MAX_VALUE will make this calendar // a pure Julian calendar. (See 4167995) if (cutoverTime == Long.MAX_VALUE) { gregorianCutoverDate++; } BaseCalendar.Date d = getGregorianCutoverDate(); // Set the cutover year (in the Gregorian year numbering) gregorianCutoverYear = d.getYear(); BaseCalendar julianCal = getJulianCalendarSystem(); d = (BaseCalendar.Date) julianCal.newCalendarDate(TimeZone.NO_TIMEZONE); julianCal.getCalendarDateFromFixedDate(d, gregorianCutoverDate - 1); gregorianCutoverYearJulian = d.getNormalizedYear(); if (time < gregorianCutover) { // The field values are no longer valid under the new // cutover date. setUnnormalized(); } } /** * Gets the Gregorian Calendar change date. This is the point when the * switch from Julian dates to Gregorian dates occurred. Default is * October 15, 1582 (Gregorian). Previous to this, dates will be in the Julian * calendar. * * @return the Gregorian cutover date for this <code>GregorianCalendar</code> object. */ public final Date getGregorianChange() { return new Date(gregorianCutover); } /** * Determines if the given year is a leap year. Returns <code>true</code> if * the given year is a leap year. To specify BC year numbers, * <code>1 - year number</code> must be given. For example, year BC 4 is * specified as -3. * * @param year the given year. * @return <code>true</code> if the given year is a leap year; <code>false</code> otherwise. */ public boolean isLeapYear(int year) { if ((year & 3) != 0) { return false; } if (year > gregorianCutoverYear) { return (year%100 != 0) || (year%400 == 0); // Gregorian } if (year < gregorianCutoverYearJulian) { return true; // Julian } boolean gregorian; // If the given year is the Gregorian cutover year, we need to // determine which calendar system to be applied to February in the year. if (gregorianCutoverYear == gregorianCutoverYearJulian) { BaseCalendar.Date d = getCalendarDate(gregorianCutoverDate); // Gregorian gregorian = d.getMonth() < BaseCalendar.MARCH; } else { gregorian = year == gregorianCutoverYear; } return gregorian ? (year%100 != 0) || (year%400 == 0) : true; } /** * Returns {@code "gregory"} as the calendar type. * * @return {@code "gregory"} * @since 1.8 */ @Override public String getCalendarType() { return "gregory"; } /** * Compares this <code>GregorianCalendar</code> to the specified * <code>Object</code>. The result is <code>true</code> if and * only if the argument is a <code>GregorianCalendar</code> object * that represents the same time value (millisecond offset from * the <a href="Calendar.html#Epoch">Epoch</a>) under the same * <code>Calendar</code> parameters and Gregorian change date as * this object. * * @param obj the object to compare with. * @return <code>true</code> if this object is equal to <code>obj</code>; * <code>false</code> otherwise. * @see Calendar#compareTo(Calendar) */ @Override public boolean equals(Object obj) { return obj instanceof GregorianCalendar && super.equals(obj) && gregorianCutover == ((GregorianCalendar)obj).gregorianCutover; } /** * Generates the hash code for this <code>GregorianCalendar</code> object. */ @Override public int hashCode() { return super.hashCode() ^ (int)gregorianCutoverDate; } /** * Adds the specified (signed) amount of time to the given calendar field, * based on the calendar's rules. * * <p><em>Add rule 1</em>. The value of <code>field</code> * after the call minus the value of <code>field</code> before the * call is <code>amount</code>, modulo any overflow that has occurred in * <code>field</code>. Overflow occurs when a field value exceeds its * range and, as a result, the next larger field is incremented or * decremented and the field value is adjusted back into its range.</p> * * <p><em>Add rule 2</em>. If a smaller field is expected to be * invariant, but it is impossible for it to be equal to its * prior value because of changes in its minimum or maximum after * <code>field</code> is changed, then its value is adjusted to be as close * as possible to its expected value. A smaller field represents a * smaller unit of time. <code>HOUR</code> is a smaller field than * <code>DAY_OF_MONTH</code>. No adjustment is made to smaller fields * that are not expected to be invariant. The calendar system * determines what fields are expected to be invariant.</p> * * @param field the calendar field. * @param amount the amount of date or time to be added to the field. * @exception IllegalArgumentException if <code>field</code> is * <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or unknown, * or if any calendar fields have out-of-range values in * non-lenient mode. */ @Override public void add(int field, int amount) { // If amount == 0, do nothing even the given field is out of // range. This is tested by JCK. if (amount == 0) { return; // Do nothing! } if (field < 0 || field >= ZONE_OFFSET) { throw new IllegalArgumentException(); } // Sync the time and calendar fields. complete(); if (field == YEAR) { int year = internalGet(YEAR); if (internalGetEra() == CE) { year += amount; if (year > 0) { set(YEAR, year); } else { // year <= 0 set(YEAR, 1 - year); // if year == 0, you get 1 BCE. set(ERA, BCE); } } else { // era == BCE year -= amount; if (year > 0) { set(YEAR, year); } else { // year <= 0 set(YEAR, 1 - year); // if year == 0, you get 1 CE set(ERA, CE); } } pinDayOfMonth(); } else if (field == MONTH) { int month = internalGet(MONTH) + amount; int year = internalGet(YEAR); int y_amount; if (month >= 0) { y_amount = month/12; } else { y_amount = (month+1)/12 - 1; } if (y_amount != 0) { if (internalGetEra() == CE) { year += y_amount; if (year > 0) { set(YEAR, year); } else { // year <= 0 set(YEAR, 1 - year); // if year == 0, you get 1 BCE set(ERA, BCE); } } else { // era == BCE year -= y_amount; if (year > 0) { set(YEAR, year); } else { // year <= 0 set(YEAR, 1 - year); // if year == 0, you get 1 CE set(ERA, CE); } } } if (month >= 0) { set(MONTH, month % 12); } else { // month < 0 month %= 12; if (month < 0) { month += 12; } set(MONTH, JANUARY + month); } pinDayOfMonth(); } else if (field == ERA) { int era = internalGet(ERA) + amount; if (era < 0) { era = 0; } if (era > 1) { era = 1; } set(ERA, era); } else { long delta = amount; long timeOfDay = 0; switch (field) { // Handle the time fields here. Convert the given // amount to milliseconds and call setTimeInMillis. case HOUR: case HOUR_OF_DAY: delta *= 60 * 60 * 1000; // hours to minutes break; case MINUTE: delta *= 60 * 1000; // minutes to seconds break; case SECOND: delta *= 1000; // seconds to milliseconds break; case MILLISECOND: break; // Handle week, day and AM_PM fields which involves // time zone offset change adjustment. Convert the // given amount to the number of days. case WEEK_OF_YEAR: case WEEK_OF_MONTH: case DAY_OF_WEEK_IN_MONTH: delta *= 7; break; case DAY_OF_MONTH: // synonym of DATE case DAY_OF_YEAR: case DAY_OF_WEEK: break; case AM_PM: // Convert the amount to the number of days (delta) // and +12 or -12 hours (timeOfDay). delta = amount / 2; timeOfDay = 12 * (amount % 2); break; } // The time fields don't require time zone offset change // adjustment. if (field >= HOUR) { setTimeInMillis(time + delta); return; } // The rest of the fields (week, day or AM_PM fields) // require time zone offset (both GMT and DST) change // adjustment. // Translate the current time to the fixed date and time // of the day. long fd = getCurrentFixedDate(); timeOfDay += internalGet(HOUR_OF_DAY); timeOfDay *= 60; timeOfDay += internalGet(MINUTE); timeOfDay *= 60; timeOfDay += internalGet(SECOND); timeOfDay *= 1000; timeOfDay += internalGet(MILLISECOND); if (timeOfDay >= ONE_DAY) { fd++; timeOfDay -= ONE_DAY; } else if (timeOfDay < 0) { fd--; timeOfDay += ONE_DAY; } fd += delta; // fd is the expected fixed date after the calculation int zoneOffset = internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET); setTimeInMillis((fd - EPOCH_OFFSET) * ONE_DAY + timeOfDay - zoneOffset); zoneOffset -= internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET); // If the time zone offset has changed, then adjust the difference. if (zoneOffset != 0) { setTimeInMillis(time + zoneOffset); long fd2 = getCurrentFixedDate(); // If the adjustment has changed the date, then take // the previous one. if (fd2 != fd) { setTimeInMillis(time - zoneOffset); } } } } /** * Adds or subtracts (up/down) a single unit of time on the given time * field without changing larger fields. * <p> * <em>Example</em>: Consider a <code>GregorianCalendar</code> * originally set to December 31, 1999. Calling {@link #roll(int,boolean) roll(Calendar.MONTH, true)} * sets the calendar to January 31, 1999. The <code>YEAR</code> field is unchanged * because it is a larger field than <code>MONTH</code>.</p> * * @param up indicates if the value of the specified calendar field is to be * rolled up or rolled down. Use <code>true</code> if rolling up, <code>false</code> otherwise. * @exception IllegalArgumentException if <code>field</code> is * <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or unknown, * or if any calendar fields have out-of-range values in * non-lenient mode. * @see #add(int,int) * @see #set(int,int) */ @Override public void roll(int field, boolean up) { roll(field, up ? +1 : -1); } /** * Adds a signed amount to the specified calendar field without changing larger fields. * A negative roll amount means to subtract from field without changing * larger fields. If the specified amount is 0, this method performs nothing. * * <p>This method calls {@link #complete()} before adding the * amount so that all the calendar fields are normalized. If there * is any calendar field having an out-of-range value in non-lenient mode, then an * <code>IllegalArgumentException</code> is thrown. * * <p> * <em>Example</em>: Consider a <code>GregorianCalendar</code> * originally set to August 31, 1999. Calling <code>roll(Calendar.MONTH, * 8)</code> sets the calendar to April 30, <strong>1999</strong>. Using a * <code>GregorianCalendar</code>, the <code>DAY_OF_MONTH</code> field cannot * be 31 in the month April. <code>DAY_OF_MONTH</code> is set to the closest possible * value, 30. The <code>YEAR</code> field maintains the value of 1999 because it * is a larger field than <code>MONTH</code>. * <p> * <em>Example</em>: Consider a <code>GregorianCalendar</code> * originally set to Sunday June 6, 1999. Calling * <code>roll(Calendar.WEEK_OF_MONTH, -1)</code> sets the calendar to * Tuesday June 1, 1999, whereas calling * <code>add(Calendar.WEEK_OF_MONTH, -1)</code> sets the calendar to * Sunday May 30, 1999. This is because the roll rule imposes an * additional constraint: The <code>MONTH</code> must not change when the * <code>WEEK_OF_MONTH</code> is rolled. Taken together with add rule 1, * the resultant date must be between Tuesday June 1 and Saturday June * 5. According to add rule 2, the <code>DAY_OF_WEEK</code>, an invariant * when changing the <code>WEEK_OF_MONTH</code>, is set to Tuesday, the * closest possible value to Sunday (where Sunday is the first day of the * week).</p> * * @param field the calendar field. * @param amount the signed amount to add to <code>field</code>. * @exception IllegalArgumentException if <code>field</code> is * <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or unknown, * or if any calendar fields have out-of-range values in * non-lenient mode. * @see #roll(int,boolean) * @see #add(int,int) * @see #set(int,int) * @since 1.2 */ @Override public void roll(int field, int amount) { // If amount == 0, do nothing even the given field is out of // range. This is tested by JCK. if (amount == 0) { return; } if (field < 0 || field >= ZONE_OFFSET) { throw new IllegalArgumentException(); } // Sync the time and calendar fields. complete(); int min = getMinimum(field); int max = getMaximum(field); switch (field) { case AM_PM: case ERA: case YEAR: case MINUTE: case SECOND: case MILLISECOND: // These fields are handled simply, since they have fixed minima // and maxima. The field DAY_OF_MONTH is almost as simple. Other // fields are complicated, since the range within they must roll // varies depending on the date. break; case HOUR: case HOUR_OF_DAY: { int unit = max + 1; // 12 or 24 hours int h = internalGet(field); int nh = (h + amount) % unit; if (nh < 0) { nh += unit; } time += ONE_HOUR * (nh - h); // The day might have changed, which could happen if // the daylight saving time transition brings it to // the next day, although it's very unlikely. But we // have to make sure not to change the larger fields. CalendarDate d = calsys.getCalendarDate(time, getZone()); if (internalGet(DAY_OF_MONTH) != d.getDayOfMonth()) { d.setDate(internalGet(YEAR), internalGet(MONTH) + 1, internalGet(DAY_OF_MONTH)); if (field == HOUR) { assert (internalGet(AM_PM) == PM); d.addHours(+12); // restore PM } time = calsys.getTime(d); } int hourOfDay = d.getHours(); internalSet(field, hourOfDay % unit); if (field == HOUR) { internalSet(HOUR_OF_DAY, hourOfDay); } else { internalSet(AM_PM, hourOfDay / 12); internalSet(HOUR, hourOfDay % 12); } // Time zone offset and/or daylight saving might have changed. int zoneOffset = d.getZoneOffset(); int saving = d.getDaylightSaving(); internalSet(ZONE_OFFSET, zoneOffset - saving); internalSet(DST_OFFSET, saving); return; } case MONTH: // Rolling the month involves both pinning the final value to [0, 11] // and adjusting the DAY_OF_MONTH if necessary. We only adjust the // DAY_OF_MONTH if, after updating the MONTH field, it is illegal. // E.g., <jan31>.roll(MONTH, 1) -> <feb28> or <feb29>. { if (!isCutoverYear(cdate.getNormalizedYear())) { int mon = (internalGet(MONTH) + amount) % 12; if (mon < 0) { mon += 12; } set(MONTH, mon); // Keep the day of month in the range. We don't want to spill over // into the next month; e.g., we don't want jan31 + 1 mo -> feb31 -> // mar3. int monthLen = monthLength(mon); if (internalGet(DAY_OF_MONTH) > monthLen) { set(DAY_OF_MONTH, monthLen); } } else { // We need to take care of different lengths in // year and month due to the cutover. int yearLength = getActualMaximum(MONTH) + 1; int mon = (internalGet(MONTH) + amount) % yearLength; if (mon < 0) { mon += yearLength; } set(MONTH, mon); int monthLen = getActualMaximum(DAY_OF_MONTH); if (internalGet(DAY_OF_MONTH) > monthLen) { set(DAY_OF_MONTH, monthLen); } } return; } case WEEK_OF_YEAR: { int y = cdate.getNormalizedYear(); max = getActualMaximum(WEEK_OF_YEAR); set(DAY_OF_WEEK, internalGet(DAY_OF_WEEK)); int woy = internalGet(WEEK_OF_YEAR); int value = woy + amount; if (!isCutoverYear(y)) { int weekYear = getWeekYear(); if (weekYear == y) { // If the new value is in between min and max // (exclusive), then we can use the value. if (value > min && value < max) { set(WEEK_OF_YEAR, value); return; } long fd = getCurrentFixedDate(); // Make sure that the min week has the current DAY_OF_WEEK // in the calendar year long day1 = fd - (7 * (woy - min)); if (calsys.getYearFromFixedDate(day1) != y) { min++; } // Make sure the same thing for the max week fd += 7 * (max - internalGet(WEEK_OF_YEAR)); if (calsys.getYearFromFixedDate(fd) != y) { max--; } } else { // When WEEK_OF_YEAR and YEAR are out of sync, // adjust woy and amount to stay in the calendar year. if (weekYear > y) { if (amount < 0) { amount++; } woy = max; } else { if (amount > 0) { amount -= woy - max; } woy = min; } } set(field, getRolledValue(woy, amount, min, max)); return; } // Handle cutover here. long fd = getCurrentFixedDate(); BaseCalendar cal; if (gregorianCutoverYear == gregorianCutoverYearJulian) { cal = getCutoverCalendarSystem(); } else if (y == gregorianCutoverYear) { cal = gcal; } else { cal = getJulianCalendarSystem(); } long day1 = fd - (7 * (woy - min)); // Make sure that the min week has the current DAY_OF_WEEK if (cal.getYearFromFixedDate(day1) != y) { min++; } // Make sure the same thing for the max week fd += 7 * (max - woy); cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem(); if (cal.getYearFromFixedDate(fd) != y) { max--; } // value: the new WEEK_OF_YEAR which must be converted // to month and day of month. value = getRolledValue(woy, amount, min, max) - 1; BaseCalendar.Date d = getCalendarDate(day1 + value * 7); set(MONTH, d.getMonth() - 1); set(DAY_OF_MONTH, d.getDayOfMonth()); return; } case WEEK_OF_MONTH: { boolean isCutoverYear = isCutoverYear(cdate.getNormalizedYear()); // dow: relative day of week from first day of week int dow = internalGet(DAY_OF_WEEK) - getFirstDayOfWeek(); if (dow < 0) { dow += 7; } long fd = getCurrentFixedDate(); long month1; // fixed date of the first day (usually 1) of the month int monthLength; // actual month length if (isCutoverYear) { month1 = getFixedDateMonth1(cdate, fd); monthLength = actualMonthLength(); } else { month1 = fd - internalGet(DAY_OF_MONTH) + 1; monthLength = calsys.getMonthLength(cdate); } // the first day of week of the month. long monthDay1st = BaseCalendar.getDayOfWeekDateOnOrBefore(month1 + 6, getFirstDayOfWeek()); // if the week has enough days to form a week, the // week starts from the previous month. if ((int)(monthDay1st - month1) >= getMinimalDaysInFirstWeek()) { monthDay1st -= 7; } max = getActualMaximum(field); // value: the new WEEK_OF_MONTH value int value = getRolledValue(internalGet(field), amount, 1, max) - 1; // nfd: fixed date of the rolled date long nfd = monthDay1st + value * 7 + dow; // Unlike WEEK_OF_YEAR, we need to change day of week if the // nfd is out of the month. if (nfd < month1) { nfd = month1; } else if (nfd >= (month1 + monthLength)) { nfd = month1 + monthLength - 1; } int dayOfMonth; if (isCutoverYear) { // If we are in the cutover year, convert nfd to // its calendar date and use dayOfMonth. BaseCalendar.Date d = getCalendarDate(nfd); dayOfMonth = d.getDayOfMonth(); } else { dayOfMonth = (int)(nfd - month1) + 1; } set(DAY_OF_MONTH, dayOfMonth); return; } case DAY_OF_MONTH: { if (!isCutoverYear(cdate.getNormalizedYear())) { max = calsys.getMonthLength(cdate); break; } // Cutover year handling long fd = getCurrentFixedDate(); long month1 = getFixedDateMonth1(cdate, fd); // It may not be a regular month. Convert the date and range to // the relative values, perform the roll, and // convert the result back to the rolled date. int value = getRolledValue((int)(fd - month1), amount, 0, actualMonthLength() - 1); BaseCalendar.Date d = getCalendarDate(month1 + value); assert d.getMonth()-1 == internalGet(MONTH); set(DAY_OF_MONTH, d.getDayOfMonth()); return; } case DAY_OF_YEAR: { max = getActualMaximum(field); if (!isCutoverYear(cdate.getNormalizedYear())) { break; } // Handle cutover here. long fd = getCurrentFixedDate(); long jan1 = fd - internalGet(DAY_OF_YEAR) + 1; int value = getRolledValue((int)(fd - jan1) + 1, amount, min, max); BaseCalendar.Date d = getCalendarDate(jan1 + value - 1); set(MONTH, d.getMonth() - 1); set(DAY_OF_MONTH, d.getDayOfMonth()); return; } case DAY_OF_WEEK: { if (!isCutoverYear(cdate.getNormalizedYear())) { // If the week of year is in the same year, we can // just change DAY_OF_WEEK. int weekOfYear = internalGet(WEEK_OF_YEAR); if (weekOfYear > 1 && weekOfYear < 52) { set(WEEK_OF_YEAR, weekOfYear); // update stamp[WEEK_OF_YEAR] max = SATURDAY; break; } } // We need to handle it in a different way around year // boundaries and in the cutover year. Note that // changing era and year values violates the roll // rule: not changing larger calendar fields... amount %= 7; if (amount == 0) { return; } long fd = getCurrentFixedDate(); long dowFirst = BaseCalendar.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek()); fd += amount; if (fd < dowFirst) { fd += 7; } else if (fd >= dowFirst + 7) { fd -= 7; } BaseCalendar.Date d = getCalendarDate(fd); set(ERA, (d.getNormalizedYear() <= 0 ? BCE : CE)); set(d.getYear(), d.getMonth() - 1, d.getDayOfMonth()); return; } case DAY_OF_WEEK_IN_MONTH: { min = 1; // after normalized, min should be 1. if (!isCutoverYear(cdate.getNormalizedYear())) { int dom = internalGet(DAY_OF_MONTH); int monthLength = calsys.getMonthLength(cdate); int lastDays = monthLength % 7; max = monthLength / 7; int x = (dom - 1) % 7; if (x < lastDays) { max++; } set(DAY_OF_WEEK, internalGet(DAY_OF_WEEK)); break; } // Cutover year handling long fd = getCurrentFixedDate(); long month1 = getFixedDateMonth1(cdate, fd); int monthLength = actualMonthLength(); int lastDays = monthLength % 7; max = monthLength / 7; int x = (int)(fd - month1) % 7; if (x < lastDays) { max++; } int value = getRolledValue(internalGet(field), amount, min, max) - 1; fd = month1 + value * 7 + x; BaseCalendar cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem(); BaseCalendar.Date d = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.NO_TIMEZONE); cal.getCalendarDateFromFixedDate(d, fd); set(DAY_OF_MONTH, d.getDayOfMonth()); return; } } set(field, getRolledValue(internalGet(field), amount, min, max)); } /** * Returns the minimum value for the given calendar field of this * <code>GregorianCalendar</code> instance. The minimum value is * defined as the smallest value returned by the {@link * Calendar#get(int) get} method for any possible time value, * taking into consideration the current values of the * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek}, * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek}, * {@link #getGregorianChange() getGregorianChange} and * {@link Calendar#getTimeZone() getTimeZone} methods. * * @param field the calendar field. * @return the minimum value for the given calendar field. * @see #getMaximum(int) * @see #getGreatestMinimum(int) * @see #getLeastMaximum(int) * @see #getActualMinimum(int) * @see #getActualMaximum(int) */ @Override public int getMinimum(int field) { return MIN_VALUES[field]; } /** * Returns the maximum value for the given calendar field of this * <code>GregorianCalendar</code> instance. The maximum value is * defined as the largest value returned by the {@link * Calendar#get(int) get} method for any possible time value, * taking into consideration the current values of the * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek}, * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek}, * {@link #getGregorianChange() getGregorianChange} and * {@link Calendar#getTimeZone() getTimeZone} methods. * * @param field the calendar field. * @return the maximum value for the given calendar field. * @see #getMinimum(int) * @see #getGreatestMinimum(int) * @see #getLeastMaximum(int) * @see #getActualMinimum(int) * @see #getActualMaximum(int) */ @Override public int getMaximum(int field) { switch (field) { case MONTH: case DAY_OF_MONTH: case DAY_OF_YEAR: case WEEK_OF_YEAR: case WEEK_OF_MONTH: case DAY_OF_WEEK_IN_MONTH: case YEAR: { // On or after Gregorian 200-3-1, Julian and Gregorian // calendar dates are the same or Gregorian dates are // larger (i.e., there is a "gap") after 300-3-1. if (gregorianCutoverYear > 200) { break; } // There might be "overlapping" dates. GregorianCalendar gc = (GregorianCalendar) clone(); gc.setLenient(true); gc.setTimeInMillis(gregorianCutover); int v1 = gc.getActualMaximum(field); gc.setTimeInMillis(gregorianCutover-1); int v2 = gc.getActualMaximum(field); return Math.max(MAX_VALUES[field], Math.max(v1, v2)); } } return MAX_VALUES[field]; } /** * Returns the highest minimum value for the given calendar field * of this <code>GregorianCalendar</code> instance. The highest * minimum value is defined as the largest value returned by * {@link #getActualMinimum(int)} for any possible time value, * taking into consideration the current values of the * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek}, * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek}, * {@link #getGregorianChange() getGregorianChange} and * {@link Calendar#getTimeZone() getTimeZone} methods. * * @param field the calendar field. * @return the highest minimum value for the given calendar field. * @see #getMinimum(int) * @see #getMaximum(int) * @see #getLeastMaximum(int) * @see #getActualMinimum(int) * @see #getActualMaximum(int) */ @Override public int getGreatestMinimum(int field) { if (field == DAY_OF_MONTH) { BaseCalendar.Date d = getGregorianCutoverDate(); long mon1 = getFixedDateMonth1(d, gregorianCutoverDate); d = getCalendarDate(mon1); return Math.max(MIN_VALUES[field], d.getDayOfMonth()); } return MIN_VALUES[field]; } /** * Returns the lowest maximum value for the given calendar field * of this <code>GregorianCalendar</code> instance. The lowest * maximum value is defined as the smallest value returned by * {@link #getActualMaximum(int)} for any possible time value, * taking into consideration the current values of the * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek}, * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek}, * {@link #getGregorianChange() getGregorianChange} and * {@link Calendar#getTimeZone() getTimeZone} methods. * * @param field the calendar field * @return the lowest maximum value for the given calendar field. * @see #getMinimum(int) * @see #getMaximum(int) * @see #getGreatestMinimum(int) * @see #getActualMinimum(int) * @see #getActualMaximum(int) */ @Override public int getLeastMaximum(int field) { switch (field) { case MONTH: case DAY_OF_MONTH: case DAY_OF_YEAR: case WEEK_OF_YEAR: case WEEK_OF_MONTH: case DAY_OF_WEEK_IN_MONTH: case YEAR: { GregorianCalendar gc = (GregorianCalendar) clone(); gc.setLenient(true); gc.setTimeInMillis(gregorianCutover); int v1 = gc.getActualMaximum(field); gc.setTimeInMillis(gregorianCutover-1); int v2 = gc.getActualMaximum(field); return Math.min(LEAST_MAX_VALUES[field], Math.min(v1, v2)); } } return LEAST_MAX_VALUES[field]; } /** * Returns the minimum value that this calendar field could have, * taking into consideration the given time value and the current * values of the * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek}, * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek}, * {@link #getGregorianChange() getGregorianChange} and * {@link Calendar#getTimeZone() getTimeZone} methods. * * <p>For example, if the Gregorian change date is January 10, * 1970 and the date of this <code>GregorianCalendar</code> is * January 20, 1970, the actual minimum value of the * <code>DAY_OF_MONTH</code> field is 10 because the previous date * of January 10, 1970 is December 27, 1996 (in the Julian * calendar). Therefore, December 28, 1969 to January 9, 1970 * don't exist. * * @param field the calendar field * @return the minimum of the given field for the time value of * this <code>GregorianCalendar</code> * @see #getMinimum(int) * @see #getMaximum(int) * @see #getGreatestMinimum(int) * @see #getLeastMaximum(int) * @see #getActualMaximum(int) * @since 1.2 */ @Override public int getActualMinimum(int field) { if (field == DAY_OF_MONTH) { GregorianCalendar gc = getNormalizedCalendar(); int year = gc.cdate.getNormalizedYear(); if (year == gregorianCutoverYear || year == gregorianCutoverYearJulian) { long month1 = getFixedDateMonth1(gc.cdate, gc.calsys.getFixedDate(gc.cdate)); BaseCalendar.Date d = getCalendarDate(month1); return d.getDayOfMonth(); } } return getMinimum(field); } /** * Returns the maximum value that this calendar field could have, * taking into consideration the given time value and the current * values of the * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek}, * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek}, * {@link #getGregorianChange() getGregorianChange} and * {@link Calendar#getTimeZone() getTimeZone} methods. * For example, if the date of this instance is February 1, 2004, * the actual maximum value of the <code>DAY_OF_MONTH</code> field * is 29 because 2004 is a leap year, and if the date of this * instance is February 1, 2005, it's 28. * * <p>This method calculates the maximum value of {@link * Calendar#WEEK_OF_YEAR WEEK_OF_YEAR} based on the {@link * Calendar#YEAR YEAR} (calendar year) value, not the <a * href="#week_year">week year</a>. Call {@link * #getWeeksInWeekYear()} to get the maximum value of {@code * WEEK_OF_YEAR} in the week year of this {@code GregorianCalendar}. * * @param field the calendar field * @return the maximum of the given field for the time value of * this <code>GregorianCalendar</code> * @see #getMinimum(int) * @see #getMaximum(int) * @see #getGreatestMinimum(int) * @see #getLeastMaximum(int) * @see #getActualMinimum(int) * @since 1.2 */ @Override public int getActualMaximum(int field) { final int fieldsForFixedMax = ERA_MASK|DAY_OF_WEEK_MASK|HOUR_MASK|AM_PM_MASK| HOUR_OF_DAY_MASK|MINUTE_MASK|SECOND_MASK|MILLISECOND_MASK| ZONE_OFFSET_MASK|DST_OFFSET_MASK; if ((fieldsForFixedMax & (1<<field)) != 0) { return getMaximum(field); } GregorianCalendar gc = getNormalizedCalendar(); BaseCalendar.Date date = gc.cdate; BaseCalendar cal = gc.calsys; int normalizedYear = date.getNormalizedYear(); int value = -1; switch (field) { case MONTH: { if (!gc.isCutoverYear(normalizedYear)) { value = DECEMBER; break; } // January 1 of the next year may or may not exist. long nextJan1; do { nextJan1 = gcal.getFixedDate(++normalizedYear, BaseCalendar.JANUARY, 1, null); } while (nextJan1 < gregorianCutoverDate); BaseCalendar.Date d = (BaseCalendar.Date) date.clone(); cal.getCalendarDateFromFixedDate(d, nextJan1 - 1); value = d.getMonth() - 1; } break; case DAY_OF_MONTH: { value = cal.getMonthLength(date); if (!gc.isCutoverYear(normalizedYear) || date.getDayOfMonth() == value) { break; } // Handle cutover year. long fd = gc.getCurrentFixedDate(); if (fd >= gregorianCutoverDate) { break; } int monthLength = gc.actualMonthLength(); long monthEnd = gc.getFixedDateMonth1(gc.cdate, fd) + monthLength - 1; // Convert the fixed date to its calendar date. BaseCalendar.Date d = gc.getCalendarDate(monthEnd); value = d.getDayOfMonth(); } break; case DAY_OF_YEAR: { if (!gc.isCutoverYear(normalizedYear)) { value = cal.getYearLength(date); break; } // Handle cutover year. long jan1; if (gregorianCutoverYear == gregorianCutoverYearJulian) { BaseCalendar cocal = gc.getCutoverCalendarSystem(); jan1 = cocal.getFixedDate(normalizedYear, 1, 1, null); } else if (normalizedYear == gregorianCutoverYearJulian) { jan1 = cal.getFixedDate(normalizedYear, 1, 1, null); } else { jan1 = gregorianCutoverDate; } // January 1 of the next year may or may not exist. long nextJan1 = gcal.getFixedDate(++normalizedYear, 1, 1, null); if (nextJan1 < gregorianCutoverDate) { nextJan1 = gregorianCutoverDate; } assert jan1 <= cal.getFixedDate(date.getNormalizedYear(), date.getMonth(), date.getDayOfMonth(), date); assert nextJan1 >= cal.getFixedDate(date.getNormalizedYear(), date.getMonth(), date.getDayOfMonth(), date); value = (int)(nextJan1 - jan1); } break; case WEEK_OF_YEAR: { if (!gc.isCutoverYear(normalizedYear)) { // Get the day of week of January 1 of the year CalendarDate d = cal.newCalendarDate(TimeZone.NO_TIMEZONE); d.setDate(date.getYear(), BaseCalendar.JANUARY, 1); int dayOfWeek = cal.getDayOfWeek(d); // Normalize the day of week with the firstDayOfWeek value dayOfWeek -= getFirstDayOfWeek(); if (dayOfWeek < 0) { dayOfWeek += 7; } value = 52; int magic = dayOfWeek + getMinimalDaysInFirstWeek() - 1; if ((magic == 6) || (date.isLeapYear() && (magic == 5 || magic == 12))) { value++; } break; } if (gc == this) { gc = (GregorianCalendar) gc.clone(); } int maxDayOfYear = getActualMaximum(DAY_OF_YEAR); gc.set(DAY_OF_YEAR, maxDayOfYear); value = gc.get(WEEK_OF_YEAR); if (internalGet(YEAR) != gc.getWeekYear()) { gc.set(DAY_OF_YEAR, maxDayOfYear - 7); value = gc.get(WEEK_OF_YEAR); } } break; case WEEK_OF_MONTH: { if (!gc.isCutoverYear(normalizedYear)) { CalendarDate d = cal.newCalendarDate(null); d.setDate(date.getYear(), date.getMonth(), 1); int dayOfWeek = cal.getDayOfWeek(d); int monthLength = cal.getMonthLength(d); dayOfWeek -= getFirstDayOfWeek(); if (dayOfWeek < 0) { dayOfWeek += 7; } int nDaysFirstWeek = 7 - dayOfWeek; // # of days in the first week value = 3; if (nDaysFirstWeek >= getMinimalDaysInFirstWeek()) { value++; } monthLength -= nDaysFirstWeek + 7 * 3; if (monthLength > 0) { value++; if (monthLength > 7) { value++; } } break; } // Cutover year handling if (gc == this) { gc = (GregorianCalendar) gc.clone(); } int y = gc.internalGet(YEAR); int m = gc.internalGet(MONTH); do { value = gc.get(WEEK_OF_MONTH); gc.add(WEEK_OF_MONTH, +1); } while (gc.get(YEAR) == y && gc.get(MONTH) == m); } break; case DAY_OF_WEEK_IN_MONTH: { // may be in the Gregorian cutover month int ndays, dow1; int dow = date.getDayOfWeek(); if (!gc.isCutoverYear(normalizedYear)) { BaseCalendar.Date d = (BaseCalendar.Date) date.clone(); ndays = cal.getMonthLength(d); d.setDayOfMonth(1); cal.normalize(d); dow1 = d.getDayOfWeek(); } else { // Let a cloned GregorianCalendar take care of the cutover cases. if (gc == this) { gc = (GregorianCalendar) clone(); } ndays = gc.actualMonthLength(); gc.set(DAY_OF_MONTH, gc.getActualMinimum(DAY_OF_MONTH)); dow1 = gc.get(DAY_OF_WEEK); } int x = dow - dow1; if (x < 0) { x += 7; } ndays -= x; value = (ndays + 6) / 7; } break; case YEAR: /* The year computation is no different, in principle, from the * others, however, the range of possible maxima is large. In * addition, the way we know we've exceeded the range is different. * For these reasons, we use the special case code below to handle * this field. * * The actual maxima for YEAR depend on the type of calendar: * * Gregorian = May 17, 292275056 BCE - Aug 17, 292278994 CE * Julian = Dec 2, 292269055 BCE - Jan 3, 292272993 CE * Hybrid = Dec 2, 292269055 BCE - Aug 17, 292278994 CE * * We know we've exceeded the maximum when either the month, date, * time, or era changes in response to setting the year. We don't * check for month, date, and time here because the year and era are * sufficient to detect an invalid year setting. NOTE: If code is * added to check the month and date in the future for some reason, * Feb 29 must be allowed to shift to Mar 1 when setting the year. */ { if (gc == this) { gc = (GregorianCalendar) clone(); } // Calculate the millisecond offset from the beginning // of the year of this calendar and adjust the max // year value if we are beyond the limit in the max // year. long current = gc.getYearOffsetInMillis(); if (gc.internalGetEra() == CE) { gc.setTimeInMillis(Long.MAX_VALUE); value = gc.get(YEAR); long maxEnd = gc.getYearOffsetInMillis(); if (current > maxEnd) { value--; } } else { CalendarSystem mincal = gc.getTimeInMillis() >= gregorianCutover ? gcal : getJulianCalendarSystem(); CalendarDate d = mincal.getCalendarDate(Long.MIN_VALUE, getZone()); long maxEnd = (cal.getDayOfYear(d) - 1) * 24 + d.getHours(); maxEnd *= 60; maxEnd += d.getMinutes(); maxEnd *= 60; maxEnd += d.getSeconds(); maxEnd *= 1000; maxEnd += d.getMillis(); value = d.getYear(); if (value <= 0) { assert mincal == gcal; value = 1 - value; } if (current < maxEnd) { value--; } } } break; default: throw new ArrayIndexOutOfBoundsException(field); } return value; } /** * Returns the millisecond offset from the beginning of this * year. This Calendar object must have been normalized. */ private long getYearOffsetInMillis() { long t = (internalGet(DAY_OF_YEAR) - 1) * 24; t += internalGet(HOUR_OF_DAY); t *= 60; t += internalGet(MINUTE); t *= 60; t += internalGet(SECOND); t *= 1000; return t + internalGet(MILLISECOND) - (internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET)); } @Override public Object clone() { GregorianCalendar other = (GregorianCalendar) super.clone(); other.gdate = (BaseCalendar.Date) gdate.clone(); if (cdate != null) { if (cdate != gdate) { other.cdate = (BaseCalendar.Date) cdate.clone(); } else { other.cdate = other.gdate; } } other.originalFields = null; other.zoneOffsets = null; return other; } @Override public TimeZone getTimeZone() { TimeZone zone = super.getTimeZone(); // To share the zone by CalendarDates gdate.setZone(zone); if (cdate != null && cdate != gdate) { cdate.setZone(zone); } return zone; } @Override public void setTimeZone(TimeZone zone) { super.setTimeZone(zone); // To share the zone by CalendarDates gdate.setZone(zone); if (cdate != null && cdate != gdate) { cdate.setZone(zone); } } /** * Returns {@code true} indicating this {@code GregorianCalendar} * supports week dates. * * @return {@code true} (always) * @see #getWeekYear() * @see #setWeekDate(int,int,int) * @see #getWeeksInWeekYear() * @since 1.7 */ @Override public final boolean isWeekDateSupported() { return true; } /** * Returns the <a href="#week_year">week year</a> represented by this * {@code GregorianCalendar}. The dates in the weeks between 1 and the * maximum week number of the week year have the same week year value * that may be one year before or after the {@link Calendar#YEAR YEAR} * (calendar year) value. * * <p>This method calls {@link Calendar#complete()} before * calculating the week year. * * @return the week year represented by this {@code GregorianCalendar}. * If the {@link Calendar#ERA ERA} value is {@link #BC}, the year is * represented by 0 or a negative number: BC 1 is 0, BC 2 * is -1, BC 3 is -2, and so on. * @throws IllegalArgumentException * if any of the calendar fields is invalid in non-lenient mode. * @see #isWeekDateSupported() * @see #getWeeksInWeekYear() * @see Calendar#getFirstDayOfWeek() * @see Calendar#getMinimalDaysInFirstWeek() * @since 1.7 */ @Override public int getWeekYear() { int year = get(YEAR); // implicitly calls complete() if (internalGetEra() == BCE) { year = 1 - year; } // Fast path for the Gregorian calendar years that are never // affected by the Julian-Gregorian transition if (year > gregorianCutoverYear + 1) { int weekOfYear = internalGet(WEEK_OF_YEAR); if (internalGet(MONTH) == JANUARY) { if (weekOfYear >= 52) { --year; } } else { if (weekOfYear == 1) { ++year; } } return year; } // General (slow) path int dayOfYear = internalGet(DAY_OF_YEAR); int maxDayOfYear = getActualMaximum(DAY_OF_YEAR); int minimalDays = getMinimalDaysInFirstWeek(); // Quickly check the possibility of year adjustments before // cloning this GregorianCalendar. if (dayOfYear > minimalDays && dayOfYear < (maxDayOfYear - 6)) { return year; } // Create a clone to work on the calculation GregorianCalendar cal = (GregorianCalendar) clone(); cal.setLenient(true); // Use GMT so that intermediate date calculations won't // affect the time of day fields. cal.setTimeZone(TimeZone.getTimeZone("GMT")); // Go to the first day of the year, which is usually January 1. cal.set(DAY_OF_YEAR, 1); cal.complete(); // Get the first day of the first day-of-week in the year. int delta = getFirstDayOfWeek() - cal.get(DAY_OF_WEEK); if (delta != 0) { if (delta < 0) { delta += 7; } cal.add(DAY_OF_YEAR, delta); } int minDayOfYear = cal.get(DAY_OF_YEAR); if (dayOfYear < minDayOfYear) { if (minDayOfYear <= minimalDays) { --year; } } else { cal.set(YEAR, year + 1); cal.set(DAY_OF_YEAR, 1); cal.complete(); int del = getFirstDayOfWeek() - cal.get(DAY_OF_WEEK); if (del != 0) { if (del < 0) { del += 7; } cal.add(DAY_OF_YEAR, del); } minDayOfYear = cal.get(DAY_OF_YEAR) - 1; if (minDayOfYear == 0) { minDayOfYear = 7; } if (minDayOfYear >= minimalDays) { int days = maxDayOfYear - dayOfYear + 1; if (days <= (7 - minDayOfYear)) { ++year; } } } return year; } /** * Sets this {@code GregorianCalendar} to the date given by the * date specifiers - <a href="#week_year">{@code weekYear}</a>, * {@code weekOfYear}, and {@code dayOfWeek}. {@code weekOfYear} * follows the <a href="#week_and_year">{@code WEEK_OF_YEAR} * numbering</a>. The {@code dayOfWeek} value must be one of the * {@link Calendar#DAY_OF_WEEK DAY_OF_WEEK} values: {@link * Calendar#SUNDAY SUNDAY} to {@link Calendar#SATURDAY SATURDAY}. * * <p>Note that the numeric day-of-week representation differs from * the ISO 8601 standard, and that the {@code weekOfYear} * numbering is compatible with the standard when {@code * getFirstDayOfWeek()} is {@code MONDAY} and {@code * getMinimalDaysInFirstWeek()} is 4. * * <p>Unlike the {@code set} method, all of the calendar fields * and the instant of time value are calculated upon return. * * <p>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. * * @param weekYear the week year * @param weekOfYear the week number based on {@code weekYear} * @param dayOfWeek the day of week value: one of the constants * for the {@link #DAY_OF_WEEK DAY_OF_WEEK} field: * {@link Calendar#SUNDAY SUNDAY}, ..., * {@link Calendar#SATURDAY SATURDAY}. * @exception IllegalArgumentException * if any of the given date specifiers is invalid, * or if any of the calendar fields are inconsistent * with the given date specifiers in non-lenient mode * @see GregorianCalendar#isWeekDateSupported() * @see Calendar#getFirstDayOfWeek() * @see Calendar#getMinimalDaysInFirstWeek() * @since 1.7 */ @Override public void setWeekDate(int weekYear, int weekOfYear, int dayOfWeek) { if (dayOfWeek < SUNDAY || dayOfWeek > SATURDAY) { throw new IllegalArgumentException("invalid dayOfWeek: " + dayOfWeek); } // To avoid changing the time of day fields by date // calculations, use a clone with the GMT time zone. GregorianCalendar gc = (GregorianCalendar) clone(); gc.setLenient(true); int era = gc.get(ERA); gc.clear(); gc.setTimeZone(TimeZone.getTimeZone("GMT")); gc.set(ERA, era); gc.set(YEAR, weekYear); gc.set(WEEK_OF_YEAR, 1); gc.set(DAY_OF_WEEK, getFirstDayOfWeek()); int days = dayOfWeek - getFirstDayOfWeek(); if (days < 0) { days += 7; } days += 7 * (weekOfYear - 1); if (days != 0) { gc.add(DAY_OF_YEAR, days); } else { gc.complete(); } if (!isLenient() && (gc.getWeekYear() != weekYear || gc.internalGet(WEEK_OF_YEAR) != weekOfYear || gc.internalGet(DAY_OF_WEEK) != dayOfWeek)) { throw new IllegalArgumentException(); } set(ERA, gc.internalGet(ERA)); set(YEAR, gc.internalGet(YEAR)); set(MONTH, gc.internalGet(MONTH)); set(DAY_OF_MONTH, gc.internalGet(DAY_OF_MONTH)); // to avoid throwing an IllegalArgumentException in // non-lenient, set WEEK_OF_YEAR internally internalSet(WEEK_OF_YEAR, weekOfYear); complete(); } /** * Returns the number of weeks in the <a href="#week_year">week year</a> * represented by this {@code GregorianCalendar}. * * <p>For example, if this {@code GregorianCalendar}'s date is * December 31, 2008 with <a href="#iso8601_compatible_setting">the ISO * 8601 compatible setting</a>, this method will return 53 for the * period: December 29, 2008 to January 3, 2010 while {@link * #getActualMaximum(int) getActualMaximum(WEEK_OF_YEAR)} will return * 52 for the period: December 31, 2007 to December 28, 2008. * * @return the number of weeks in the week year. * @see Calendar#WEEK_OF_YEAR * @see #getWeekYear() * @see #getActualMaximum(int) * @since 1.7 */ @Override public int getWeeksInWeekYear() { GregorianCalendar gc = getNormalizedCalendar(); int weekYear = gc.getWeekYear(); if (weekYear == gc.internalGet(YEAR)) { return gc.getActualMaximum(WEEK_OF_YEAR); } // Use the 2nd week for calculating the max of WEEK_OF_YEAR if (gc == this) { gc = (GregorianCalendar) gc.clone(); } gc.setWeekDate(weekYear, 2, internalGet(DAY_OF_WEEK)); return gc.getActualMaximum(WEEK_OF_YEAR); }/////////////////////////////// Time => Fields computation///////////////////////////// /** * The fixed date corresponding to gdate. If the value is * Long.MIN_VALUE, the fixed date value is unknown. Currently, * Julian calendar dates are not cached. */ transient private long cachedFixedDate = Long.MIN_VALUE; /** * Converts the time value (millisecond offset from the <a * href="Calendar.html#Epoch">Epoch</a>) to calendar field values. * The time is <em>not</em> * recomputed first; to recompute the time, then the fields, call the * <code>complete</code> method. * * @see Calendar#complete */ @Override protected void computeFields() { int mask; if (isPartiallyNormalized()) { // Determine which calendar fields need to be computed. mask = getSetStateFields(); int fieldMask = ~mask & ALL_FIELDS; // We have to call computTime in case calsys == null in // order to set calsys and cdate. (6263644) if (fieldMask != 0 || calsys == null) { mask |= computeFields(fieldMask, mask & (ZONE_OFFSET_MASK|DST_OFFSET_MASK)); assert mask == ALL_FIELDS; } } else { mask = ALL_FIELDS; computeFields(mask, 0); } // After computing all the fields, set the field state to `COMPUTED'. setFieldsComputed(mask); } /** * This computeFields implements the conversion from UTC * (millisecond offset from the Epoch) to calendar * field values. fieldMask specifies which fields to change the * setting state to COMPUTED, although all fields are set to * the correct values. This is required to fix 4685354. * * @param fieldMask a bit mask to specify which fields to change * the setting state. * @param tzMask a bit mask to specify which time zone offset * fields to be used for time calculations * @return a new field mask that indicates what field values have * actually been set. */ private int computeFields(int fieldMask, int tzMask) { int zoneOffset = 0; TimeZone tz = getZone(); if (zoneOffsets == null) { zoneOffsets = new int[2]; } if (tzMask != (ZONE_OFFSET_MASK|DST_OFFSET_MASK)) { if (tz instanceof ZoneInfo) { zoneOffset = ((ZoneInfo)tz).getOffsets(time, zoneOffsets); } else { zoneOffset = tz.getOffset(time); zoneOffsets[0] = tz.getRawOffset(); zoneOffsets[1] = zoneOffset - zoneOffsets[0]; } } if (tzMask != 0) { if (isFieldSet(tzMask, ZONE_OFFSET)) { zoneOffsets[0] = internalGet(ZONE_OFFSET); } if (isFieldSet(tzMask, DST_OFFSET)) { zoneOffsets[1] = internalGet(DST_OFFSET); } zoneOffset = zoneOffsets[0] + zoneOffsets[1]; } // By computing time and zoneOffset separately, we can take // the wider range of time+zoneOffset than the previous // implementation. long fixedDate = zoneOffset / ONE_DAY; int timeOfDay = zoneOffset % (int)ONE_DAY; fixedDate += time / ONE_DAY; timeOfDay += (int) (time % ONE_DAY); if (timeOfDay >= ONE_DAY) { timeOfDay -= ONE_DAY; ++fixedDate; } else { while (timeOfDay < 0) { timeOfDay += ONE_DAY; --fixedDate; } } fixedDate += EPOCH_OFFSET; int era = CE; int year; if (fixedDate >= gregorianCutoverDate) { // Handle Gregorian dates. assert cachedFixedDate == Long.MIN_VALUE || gdate.isNormalized() : "cache control: not normalized"; assert cachedFixedDate == Long.MIN_VALUE || gcal.getFixedDate(gdate.getNormalizedYear(), gdate.getMonth(), gdate.getDayOfMonth(), gdate) == cachedFixedDate : "cache control: inconsictency" + ", cachedFixedDate=" + cachedFixedDate + ", computed=" + gcal.getFixedDate(gdate.getNormalizedYear(), gdate.getMonth(), gdate.getDayOfMonth(), gdate) + ", date=" + gdate; // See if we can use gdate to avoid date calculation. if (fixedDate != cachedFixedDate) { gcal.getCalendarDateFromFixedDate(gdate, fixedDate); cachedFixedDate = fixedDate; } year = gdate.getYear(); if (year <= 0) { year = 1 - year; era = BCE; } calsys = gcal; cdate = gdate; assert cdate.getDayOfWeek() > 0 : "dow="+cdate.getDayOfWeek()+", date="+cdate; } else { // Handle Julian calendar dates. calsys = getJulianCalendarSystem(); cdate = (BaseCalendar.Date) jcal.newCalendarDate(getZone()); jcal.getCalendarDateFromFixedDate(cdate, fixedDate); Era e = cdate.getEra(); if (e == jeras[0]) { era = BCE; } year = cdate.getYear(); } // Always set the ERA and YEAR values. internalSet(ERA, era); internalSet(YEAR, year); int mask = fieldMask | (ERA_MASK|YEAR_MASK); int month = cdate.getMonth() - 1; // 0-based int dayOfMonth = cdate.getDayOfMonth(); // Set the basic date fields. if ((fieldMask & (MONTH_MASK|DAY_OF_MONTH_MASK|DAY_OF_WEEK_MASK)) != 0) { internalSet(MONTH, month); internalSet(DAY_OF_MONTH, dayOfMonth); internalSet(DAY_OF_WEEK, cdate.getDayOfWeek()); mask |= MONTH_MASK|DAY_OF_MONTH_MASK|DAY_OF_WEEK_MASK; } if ((fieldMask & (HOUR_OF_DAY_MASK|AM_PM_MASK|HOUR_MASK |MINUTE_MASK|SECOND_MASK|MILLISECOND_MASK)) != 0) { if (timeOfDay != 0) { int hours = timeOfDay / ONE_HOUR; internalSet(HOUR_OF_DAY, hours); internalSet(AM_PM, hours / 12); // Assume AM == 0 internalSet(HOUR, hours % 12); int r = timeOfDay % ONE_HOUR; internalSet(MINUTE, r / ONE_MINUTE); r %= ONE_MINUTE; internalSet(SECOND, r / ONE_SECOND); internalSet(MILLISECOND, r % ONE_SECOND); } else { internalSet(HOUR_OF_DAY, 0); internalSet(AM_PM, AM); internalSet(HOUR, 0); internalSet(MINUTE, 0); internalSet(SECOND, 0); internalSet(MILLISECOND, 0); } mask |= (HOUR_OF_DAY_MASK|AM_PM_MASK|HOUR_MASK |MINUTE_MASK|SECOND_MASK|MILLISECOND_MASK); } if ((fieldMask & (ZONE_OFFSET_MASK|DST_OFFSET_MASK)) != 0) { internalSet(ZONE_OFFSET, zoneOffsets[0]); internalSet(DST_OFFSET, zoneOffsets[1]); mask |= (ZONE_OFFSET_MASK|DST_OFFSET_MASK); } if ((fieldMask & (DAY_OF_YEAR_MASK|WEEK_OF_YEAR_MASK|WEEK_OF_MONTH_MASK|DAY_OF_WEEK_IN_MONTH_MASK)) != 0) { int normalizedYear = cdate.getNormalizedYear(); long fixedDateJan1 = calsys.getFixedDate(normalizedYear, 1, 1, cdate); int dayOfYear = (int)(fixedDate - fixedDateJan1) + 1; long fixedDateMonth1 = fixedDate - dayOfMonth + 1; int cutoverGap = 0; int cutoverYear = (calsys == gcal) ? gregorianCutoverYear : gregorianCutoverYearJulian; int relativeDayOfMonth = dayOfMonth - 1; // If we are in the cutover year, we need some special handling. if (normalizedYear == cutoverYear) { // Need to take care of the "missing" days. if (gregorianCutoverYearJulian <= gregorianCutoverYear) { // We need to find out where we are. The cutover // gap could even be more than one year. (One // year difference in ~48667 years.) fixedDateJan1 = getFixedDateJan1(cdate, fixedDate); if (fixedDate >= gregorianCutoverDate) { fixedDateMonth1 = getFixedDateMonth1(cdate, fixedDate); } } int realDayOfYear = (int)(fixedDate - fixedDateJan1) + 1; cutoverGap = dayOfYear - realDayOfYear; dayOfYear = realDayOfYear; relativeDayOfMonth = (int)(fixedDate - fixedDateMonth1); } internalSet(DAY_OF_YEAR, dayOfYear); internalSet(DAY_OF_WEEK_IN_MONTH, relativeDayOfMonth / 7 + 1); int weekOfYear = getWeekNumber(fixedDateJan1, fixedDate); // The spec is to calculate WEEK_OF_YEAR in the // ISO8601-style. This creates problems, though. if (weekOfYear == 0) { // If the date belongs to the last week of the // previous year, use the week number of "12/31" of // the "previous" year. Again, if the previous year is // the Gregorian cutover year, we need to take care of // it. Usually the previous day of January 1 is // December 31, which is not always true in // GregorianCalendar. long fixedDec31 = fixedDateJan1 - 1; long prevJan1 = fixedDateJan1 - 365; if (normalizedYear > (cutoverYear + 1)) { if (CalendarUtils.isGregorianLeapYear(normalizedYear - 1)) { --prevJan1; } } else if (normalizedYear <= gregorianCutoverYearJulian) { if (CalendarUtils.isJulianLeapYear(normalizedYear - 1)) { --prevJan1; } } else { BaseCalendar calForJan1 = calsys; //int prevYear = normalizedYear - 1; int prevYear = getCalendarDate(fixedDec31).getNormalizedYear(); if (prevYear == gregorianCutoverYear) { calForJan1 = getCutoverCalendarSystem(); if (calForJan1 == jcal) { prevJan1 = calForJan1.getFixedDate(prevYear, BaseCalendar.JANUARY, 1, null); } else { prevJan1 = gregorianCutoverDate; calForJan1 = gcal; } } else if (prevYear <= gregorianCutoverYearJulian) { calForJan1 = getJulianCalendarSystem(); prevJan1 = calForJan1.getFixedDate(prevYear, BaseCalendar.JANUARY, 1, null); } } weekOfYear = getWeekNumber(prevJan1, fixedDec31); } else { if (normalizedYear > gregorianCutoverYear || normalizedYear < (gregorianCutoverYearJulian - 1)) { // Regular years if (weekOfYear >= 52) { long nextJan1 = fixedDateJan1 + 365; if (cdate.isLeapYear()) { nextJan1++; } long nextJan1st = BaseCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6, getFirstDayOfWeek()); int ndays = (int)(nextJan1st - nextJan1); if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) { // The first days forms a week in which the date is included. weekOfYear = 1; } } } else { BaseCalendar calForJan1 = calsys; int nextYear = normalizedYear + 1; if (nextYear == (gregorianCutoverYearJulian + 1) && nextYear < gregorianCutoverYear) { // In case the gap is more than one year. nextYear = gregorianCutoverYear; } if (nextYear == gregorianCutoverYear) { calForJan1 = getCutoverCalendarSystem(); } long nextJan1; if (nextYear > gregorianCutoverYear || gregorianCutoverYearJulian == gregorianCutoverYear || nextYear == gregorianCutoverYearJulian) { nextJan1 = calForJan1.getFixedDate(nextYear, BaseCalendar.JANUARY, 1, null); } else { nextJan1 = gregorianCutoverDate; calForJan1 = gcal; } long nextJan1st = BaseCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6, getFirstDayOfWeek()); int ndays = (int)(nextJan1st - nextJan1); if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) { // The first days forms a week in which the date is included. weekOfYear = 1; } } } internalSet(WEEK_OF_YEAR, weekOfYear); internalSet(WEEK_OF_MONTH, getWeekNumber(fixedDateMonth1, fixedDate)); mask |= (DAY_OF_YEAR_MASK|WEEK_OF_YEAR_MASK|WEEK_OF_MONTH_MASK|DAY_OF_WEEK_IN_MONTH_MASK); } return mask; } /** * Returns the number of weeks in a period between fixedDay1 and * fixedDate. The getFirstDayOfWeek-getMinimalDaysInFirstWeek rule * is applied to calculate the number of weeks. * * @param fixedDay1 the fixed date of the first day of the period * @param fixedDate the fixed date of the last day of the period * @return the number of weeks of the given period */ private int getWeekNumber(long fixedDay1, long fixedDate) { // We can always use `gcal' since Julian and Gregorian are the // same thing for this calculation. long fixedDay1st = Gregorian.getDayOfWeekDateOnOrBefore(fixedDay1 + 6, getFirstDayOfWeek()); int ndays = (int)(fixedDay1st - fixedDay1); assert ndays <= 7; if (ndays >= getMinimalDaysInFirstWeek()) { fixedDay1st -= 7; } int normalizedDayOfPeriod = (int)(fixedDate - fixedDay1st); if (normalizedDayOfPeriod >= 0) { return normalizedDayOfPeriod / 7 + 1; } return CalendarUtils.floorDivide(normalizedDayOfPeriod, 7) + 1; } /** * Converts calendar field values to the time value (millisecond * offset from the <a href="Calendar.html#Epoch">Epoch</a>). * * @exception IllegalArgumentException if any calendar fields are invalid. */ @Override 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 = jfd; } else { jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask); gfd = fixedDate + getFixedDate(gcal, year, fieldMask); } // Now we have to determine which calendar date it is. // If the date is relative from the beginning of the year // in the Julian calendar, then use jfd; if (isFieldSet(fieldMask, DAY_OF_YEAR) || isFieldSet(fieldMask, WEEK_OF_YEAR)) { if (gregorianCutoverYear == gregorianCutoverYearJulian) { fixedDate = jfd; break calculateFixedDate; } else if (year == gregorianCutoverYear) { fixedDate = gfd; break calculateFixedDate; } } 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)) { String s = originalFields[field] + " -> " + internalGet(field); // Restore the original field values System.arraycopy(originalFields, 0, fields, 0, fields.length); throw new IllegalArgumentException(getFieldName(field) + ": " + s); } } } setFieldsNormalized(mask); } /** * Computes the fixed date under either the Gregorian or the * Julian calendar, using the given year and the specified calendar fields. * * @param cal the CalendarSystem to be used for the date calculation * @param year the normalized year number, with 0 indicating the * year 1 BCE, -1 indicating 2 BCE, etc. * @param fieldMask the calendar fields to be used for the date calculation * @return the fixed date * @see Calendar#selectFields */ private long getFixedDate(BaseCalendar cal, int year, int fieldMask) { int month = JANUARY; if (isFieldSet(fieldMask, MONTH)) { // No need to check if MONTH has been set (no isSet(MONTH) // call) since its unset value happens to be JANUARY (0). month = internalGet(MONTH); // If the month is out of range, adjust it into range if (month > DECEMBER) { year += month / 12; month %= 12; } else if (month < JANUARY) { int[] rem = new int[1]; year += CalendarUtils.floorDivide(month, 12, rem); month = rem[0]; } } // Get the fixed date since Jan 1, 1 (Gregorian). We are on // the first day of either `month' or January in 'year'. long fixedDate = cal.getFixedDate(year, month + 1, 1, cal == gcal ? gdate : null); if (isFieldSet(fieldMask, MONTH)) { // Month-based calculations if (isFieldSet(fieldMask, DAY_OF_MONTH)) { // We are on the first day of the month. Just add the // offset if DAY_OF_MONTH is set. If the isSet call // returns false, that means DAY_OF_MONTH has been // selected just because of the selected // combination. We don't need to add any since the // default value is the 1st. if (isSet(DAY_OF_MONTH)) { // To avoid underflow with DAY_OF_MONTH-1, add // DAY_OF_MONTH, then subtract 1. fixedDate += internalGet(DAY_OF_MONTH); fixedDate--; } } else { if (isFieldSet(fieldMask, WEEK_OF_MONTH)) { long firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6, getFirstDayOfWeek()); // If we have enough days in the first week, then // move to the previous week. if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) { firstDayOfWeek -= 7; } if (isFieldSet(fieldMask, DAY_OF_WEEK)) { firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6, internalGet(DAY_OF_WEEK)); } // In lenient mode, we treat days of the previous // months as a part of the specified // WEEK_OF_MONTH. See 4633646. fixedDate = firstDayOfWeek + 7 * (internalGet(WEEK_OF_MONTH) - 1); } else { int dayOfWeek; if (isFieldSet(fieldMask, DAY_OF_WEEK)) { dayOfWeek = internalGet(DAY_OF_WEEK); } else { dayOfWeek = getFirstDayOfWeek(); } // We are basing this on the day-of-week-in-month. The only // trickiness occurs if the day-of-week-in-month is // negative. int dowim; if (isFieldSet(fieldMask, DAY_OF_WEEK_IN_MONTH)) { dowim = internalGet(DAY_OF_WEEK_IN_MONTH); } else { dowim = 1; } if (dowim >= 0) { fixedDate = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + (7 * dowim) - 1, dayOfWeek); } else { // Go to the first day of the next week of // the specified week boundary. int lastDate = monthLength(month, year) + (7 * (dowim + 1)); // Then, get the day of week date on or before the last date. fixedDate = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + lastDate - 1, dayOfWeek); } } } } else { if (year == gregorianCutoverYear && cal == gcal && fixedDate < gregorianCutoverDate && gregorianCutoverYear != gregorianCutoverYearJulian) { // January 1 of the year doesn't exist. Use // gregorianCutoverDate as the first day of the // year. fixedDate = gregorianCutoverDate; } // We are on the first day of the year. if (isFieldSet(fieldMask, DAY_OF_YEAR)) { // Add the offset, then subtract 1. (Make sure to avoid underflow.) fixedDate += internalGet(DAY_OF_YEAR); fixedDate--; } else { long firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6, getFirstDayOfWeek()); // If we have enough days in the first week, then move // to the previous week. if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) { firstDayOfWeek -= 7; } if (isFieldSet(fieldMask, DAY_OF_WEEK)) { int dayOfWeek = internalGet(DAY_OF_WEEK); if (dayOfWeek != getFirstDayOfWeek()) { firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6, dayOfWeek); } } fixedDate = firstDayOfWeek + 7 * ((long)internalGet(WEEK_OF_YEAR) - 1); } } return fixedDate; } /** * Returns this object if it's normalized (all fields and time are * in sync). Otherwise, a cloned object is returned after calling * complete() in lenient mode. */ private GregorianCalendar getNormalizedCalendar() { GregorianCalendar gc; if (isFullyNormalized()) { gc = this; } else { // Create a clone and normalize the calendar fields gc = (GregorianCalendar) this.clone(); gc.setLenient(true); gc.complete(); } return gc; } /** * Returns the Julian calendar system instance (singleton). 'jcal' * and 'jeras' are set upon the return. */ private static synchronized BaseCalendar getJulianCalendarSystem() { if (jcal == null) { jcal = (JulianCalendar) CalendarSystem.forName("julian"); jeras = jcal.getEras(); } return jcal; } /** * Returns the calendar system for dates before the cutover date * in the cutover year. If the cutover date is January 1, the * method returns Gregorian. Otherwise, Julian. */ private BaseCalendar getCutoverCalendarSystem() { if (gregorianCutoverYearJulian < gregorianCutoverYear) { return gcal; } return getJulianCalendarSystem(); } /** * Determines if the specified year (normalized) is the Gregorian * cutover year. This object must have been normalized. */ private boolean isCutoverYear(int normalizedYear) { int cutoverYear = (calsys == gcal) ? gregorianCutoverYear : gregorianCutoverYearJulian; return normalizedYear == cutoverYear; } /** * Returns the fixed date of the first day of the year (usually * January 1) before the specified date. * * @param date the date for which the first day of the year is * calculated. The date has to be in the cut-over year (Gregorian * or Julian). * @param fixedDate the fixed date representation of the date */ private long getFixedDateJan1(BaseCalendar.Date date, long fixedDate) { assert date.getNormalizedYear() == gregorianCutoverYear || date.getNormalizedYear() == gregorianCutoverYearJulian; if (gregorianCutoverYear != gregorianCutoverYearJulian) { if (fixedDate >= gregorianCutoverDate) { // Dates before the cutover date don't exist // in the same (Gregorian) year. So, no // January 1 exists in the year. Use the // cutover date as the first day of the year. return gregorianCutoverDate; } } // January 1 of the normalized year should exist. BaseCalendar juliancal = getJulianCalendarSystem(); return juliancal.getFixedDate(date.getNormalizedYear(), BaseCalendar.JANUARY, 1, null); } /** * Returns the fixed date of the first date of the month (usually * the 1st of the month) before the specified date. * * @param date the date for which the first day of the month is * calculated. The date has to be in the cut-over year (Gregorian * or Julian). * @param fixedDate the fixed date representation of the date */ private long getFixedDateMonth1(BaseCalendar.Date date, long fixedDate) { assert date.getNormalizedYear() == gregorianCutoverYear || date.getNormalizedYear() == gregorianCutoverYearJulian; BaseCalendar.Date gCutover = getGregorianCutoverDate(); if (gCutover.getMonth() == BaseCalendar.JANUARY && gCutover.getDayOfMonth() == 1) { // The cutover happened on January 1. return fixedDate - date.getDayOfMonth() + 1; } long fixedDateMonth1; // The cutover happened sometime during the year. if (date.getMonth() == gCutover.getMonth()) { // The cutover happened in the month. BaseCalendar.Date jLastDate = getLastJulianDate(); if (gregorianCutoverYear == gregorianCutoverYearJulian && gCutover.getMonth() == jLastDate.getMonth()) { // The "gap" fits in the same month. fixedDateMonth1 = jcal.getFixedDate(date.getNormalizedYear(), date.getMonth(), 1, null); } else { // Use the cutover date as the first day of the month. fixedDateMonth1 = gregorianCutoverDate; } } else { // The cutover happened before the month. fixedDateMonth1 = fixedDate - date.getDayOfMonth() + 1; } return fixedDateMonth1; } /** * Returns a CalendarDate produced from the specified fixed date. * * @param fd the fixed date */ private BaseCalendar.Date getCalendarDate(long fd) { BaseCalendar cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem(); BaseCalendar.Date d = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.NO_TIMEZONE); cal.getCalendarDateFromFixedDate(d, fd); return d; } /** * Returns the Gregorian cutover date as a BaseCalendar.Date. The * date is a Gregorian date. */ private BaseCalendar.Date getGregorianCutoverDate() { return getCalendarDate(gregorianCutoverDate); } /** * Returns the day before the Gregorian cutover date as a * BaseCalendar.Date. The date is a Julian date. */ private BaseCalendar.Date getLastJulianDate() { return getCalendarDate(gregorianCutoverDate - 1); } /** * Returns the length of the specified month in the specified * year. The year number must be normalized. * * @see #isLeapYear(int) */ private int monthLength(int month, int year) { return isLeapYear(year) ? LEAP_MONTH_LENGTH[month] : MONTH_LENGTH[month]; } /** * Returns the length of the specified month in the year provided * by internalGet(YEAR). * * @see #isLeapYear(int) */ private int monthLength(int month) { int year = internalGet(YEAR); if (internalGetEra() == BCE) { year = 1 - year; } return monthLength(month, year); } private int actualMonthLength() { int year = cdate.getNormalizedYear(); if (year != gregorianCutoverYear && year != gregorianCutoverYearJulian) { return calsys.getMonthLength(cdate); } BaseCalendar.Date date = (BaseCalendar.Date) cdate.clone(); long fd = calsys.getFixedDate(date); long month1 = getFixedDateMonth1(date, fd); long next1 = month1 + calsys.getMonthLength(date); if (next1 < gregorianCutoverDate) { return (int)(next1 - month1); } if (cdate != gdate) { date = (BaseCalendar.Date) gcal.newCalendarDate(TimeZone.NO_TIMEZONE); } gcal.getCalendarDateFromFixedDate(date, next1); next1 = getFixedDateMonth1(date, next1); return (int)(next1 - month1); } /** * Returns the length (in days) of the specified year. The year * must be normalized. */ private int yearLength(int year) { return isLeapYear(year) ? 366 : 365; } /** * Returns the length (in days) of the year provided by * internalGet(YEAR). */ private int yearLength() { int year = internalGet(YEAR); if (internalGetEra() == BCE) { year = 1 - year; } return yearLength(year); } /** * After adjustments such as add(MONTH), add(YEAR), we don't want the * month to jump around. E.g., we don't want Jan 31 + 1 month to go to Mar * 3, we want it to go to Feb 28. Adjustments which might run into this * problem call this method to retain the proper month. */ private void pinDayOfMonth() { int year = internalGet(YEAR); int monthLen; if (year > gregorianCutoverYear || year < gregorianCutoverYearJulian) { monthLen = monthLength(internalGet(MONTH)); } else { GregorianCalendar gc = getNormalizedCalendar(); monthLen = gc.getActualMaximum(DAY_OF_MONTH); } int dom = internalGet(DAY_OF_MONTH); if (dom > monthLen) { set(DAY_OF_MONTH, monthLen); } } /** * Returns the fixed date value of this object. The time value and * calendar fields must be in synch. */ private long getCurrentFixedDate() { return (calsys == gcal) ? cachedFixedDate : calsys.getFixedDate(cdate); } /** * Returns the new value after 'roll'ing the specified value and amount. */ private static int getRolledValue(int value, int amount, int min, int max) { assert value >= min && value <= max; int range = max - min + 1; amount %= range; int n = value + amount; if (n > max) { n -= range; } else if (n < min) { n += range; } assert n >= min && n <= max; return n; } /** * Returns the ERA. We need a special method for this because the * default ERA is CE, but a zero (unset) ERA is BCE. */ private int internalGetEra() { return isSet(ERA) ? internalGet(ERA) : CE; } /** * Updates internal state. */ private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException { stream.defaultReadObject(); if (gdate == null) { gdate = (BaseCalendar.Date) gcal.newCalendarDate(getZone()); cachedFixedDate = Long.MIN_VALUE; } setGregorianChange(gregorianCutover); } /** * Converts this object to a {@code ZonedDateTime} that represents * the same point on the time-line as this {@code GregorianCalendar}. * <p> * Since this object supports a Julian-Gregorian cutover date and * {@code ZonedDateTime} does not, it is possible that the resulting year, * month and day will have different values. The result will represent the * correct date in the ISO calendar system, which will also be the same value * for Modified Julian Days. * * @return a zoned date-time representing the same point on the time-line * as this gregorian calendar * @since 1.8 */ public ZonedDateTime toZonedDateTime() { return ZonedDateTime.ofInstant(Instant.ofEpochMilli(getTimeInMillis()), getTimeZone().toZoneId()); } /** * Obtains an instance of {@code GregorianCalendar} with the default locale * from a {@code ZonedDateTime} object. * <p> * Since {@code ZonedDateTime} does not support a Julian-Gregorian cutover * date and uses ISO calendar system, the return GregorianCalendar is a pure * Gregorian calendar and uses ISO 8601 standard for week definitions, * which has {@code MONDAY} as the {@link Calendar#getFirstDayOfWeek() * FirstDayOfWeek} and {@code 4} as the value of the * {@link Calendar#getMinimalDaysInFirstWeek() MinimalDaysInFirstWeek}. * <p> * {@code ZoneDateTime} can store points on the time-line further in the * future and further in the past than {@code GregorianCalendar}. In this * scenario, this method will throw an {@code IllegalArgumentException} * exception. * * @param zdt the zoned date-time object to convert * @return the gregorian calendar representing the same point on the * time-line as the zoned date-time provided * @exception NullPointerException if {@code zdt} is null * @exception IllegalArgumentException if the zoned date-time is too * large to represent as a {@code GregorianCalendar} * @since 1.8 */ public static GregorianCalendar from(ZonedDateTime zdt) { GregorianCalendar cal = new GregorianCalendar(TimeZone.getTimeZone(zdt.getZone())); cal.setGregorianChange(new Date(Long.MIN_VALUE)); cal.setFirstDayOfWeek(MONDAY); cal.setMinimalDaysInFirstWeek(4); try { cal.setTimeInMillis(Math.addExact(Math.multiplyExact(zdt.toEpochSecond(), 1000), zdt.get(ChronoField.MILLI_OF_SECOND))); } catch (ArithmeticException ex) { throw new IllegalArgumentException(ex); } return cal; }}3.截图：
4.总结：
1.ERA=1,表示公元；ERA=0，表示公元前；
2.
“java.util.GregorianCalendar
[time=?,
areFieldsSet=false,
areAllFieldsSet=true,
lenient=true,
zone=sun.util.calendar.ZoneInfo
[id=”Asia/Shanghai”,
offset=28800000,
dstSaving=0,
useDaylight=false,
transitions=19,
lastRule=null],
这里介绍的是时区信息，id为“Asia/Shanghai”
firtstDayOfWeek=1,
一周中的第一天是周几？？？？
/** * Gets what the first day of the week is; e.g., <code>SUNDAY</code> in the U.S., * <code>MONDAY</code> in France. * * @return the first day of the week. * @see #setFirstDayOfWeek(int) * @see #getMinimalDaysInFirstWeek() */ public int getFirstDayOfWeek() { return firstDayOfWeek; }获取本周第一天是星期几？例如，美国是周日（SUNDAY），法国是周一（MONDAY）；
这里，我把2017-6-17，把6改成了0；即2017-01-17；虽然6变成了0，但是其他的逻辑没有改过来；所以，可以知道，这些字段不是联动的；大家除了月份，其他的都当2017年6月17日来理解；
ERA=1,
1是公元，0是公元前；
YEAR=2017,
年；
MONTH=0,
月，月份1-12分别用0-11表示；
WEEK_OF_YEAR=24,
这是本年第24周；
WEEK_OF_MONTH=3,
这是本月第3周；
DAY_OF_MONTH=17,
这是本周第17天；
DAY_OF_YEAR=168,
这是本年的第168天；
DAY_OF_WEEK=7,
这是本周的第7天（2017年6月17号周六）；
DAY_OF_WEEK_IN_MONTH=3,
这是本月这周的第三天； 
这里怎么理解，这个就表示，在这个月中，按照完整周算，这是第几天，这里等于3，说明，第一天是按照6月1日，周四那天开始的；到6月7号是第一周，到6月14号是第二周；接下来是15,16,17；17号是新一周的第三天；
AM_PM=1,HOUR=3,
按照12小时制，现在是下午；AM_PM=1表示下午.AM_PM=0表示上午；
HOUR_OF_DAY=15,
本天当中第15个小时；
MINUTE=33,
分钟；
SECOND=0,
秒数；
MILLISECOND=0,
毫秒数；
ZONE_OFFSET=28800000,
时间偏移量；
DST_OFFSET=0]”
夏令时差；
阅读全文
0 0
- 【GregorianCalendar】格林尼治时间GregorianCalendar[]解密
- GregorianCalendar
- Calendar GregorianCalendar
- Calendar GregorianCalendar
- GregorianCalendar类
- GregorianCalendar(标准阳历) 示例
- 总结一下GregorianCalendar
- 总结一下GregorianCalendar
- GregorianCalendar的使用
- GregorianCalendar类的学习
- 使用GregorianCalendar输出日历
- GregorianCalendar类的学习
- GregorianCalendar 的使用方法
- Java GregorianCalendar类学习
- GregorianCalendar用法[转]
- GregorianCalendar相关属性
- java Date GregorianCalendar
- java中的GregorianCalendar类
- 线性表
- C# DataSet和DataTable详解
- java 日期转换校验
- Java+Selenium3方法篇24-单选和多选按钮操作
- SQL：结构化查询语言(Structured Query Language)。
- 【GregorianCalendar】格林尼治时间GregorianCalendar[]解密
- mybatis-04 小结
- 项目概述
- 学渣眼中的软件工程
- C#连接oracle实例
- 【Mybatis】Mybatis中IFNULL（P1，P2）函数的用法；
- Mac版mongodb安装
- execl表邮箱导入
- 我的Hadoop安装——使用Cloudera部署，管理Hadoop集群（离线安装CDH5.7.0）
