模块 java.base
包 java.util

类 GregorianCalendar

java.lang.Object
java.util.Calendar
java.util.GregorianCalendar
所有已实现的接口：
Serializable , Cloneable , Comparable<Calendar>
public class GregorianCalendar extends Calendar
GregorianCalendar 是 Calendar 的具体子类，提供世界上大部分地区使用的标准日历系统。

GregorianCalendar 是一种混合日历，支持儒略历和公历系统，并支持单个不连续性，默认情况下对应于公历制定时的公历日期（在某些国家/地区为 1582 年 10 月 15 日，在其他国家/地区为晚些时候）。调用者可以通过调用 setGregorianChange() 来更改切换日期。

从历史上看，在那些首先采用公历的国家中，1582 年 10 月 4 日（儒略历）随后是 1582 年 10 月 15 日（公历）。这个日历正确地模拟了这一点。在格里高利转换之前，GregorianCalendar 实施儒略历。公历和儒略历之间的唯一区别是闰年规则。儒略历每四年指定一次闰年，而公历省略了不能被 400 整除的世纪年。

GregorianCalendar 实施 proleptic 公历和儒略历。也就是说，日期是通过在时间上向后和向前无限远地外推当前规则来计算的。因此，GregorianCalendar 可用于所有年份以生成有意义且一致的结果。但是，使用 GregorianCalendar 获得的日期在历史上仅从公元 4 年 3 月 1 日开始准确，当时采用了现代儒略历规则。在此日期之前，不定期应用闰年规则，而在公元前 45 年之前，儒略历甚至不存在。

在公历建立之前，元旦是 3 月 25 日。为避免混淆，此日历始终使用 1 月 1 日。如果需要，可以对公历转换之前的日期和 1 月 1 日之间的日期进行手动调整和 3 月 24 日。

一年中的一周和一年中的一周

为 WEEK_OF_YEAR 字段计算的值范围从 1 到 53。日历年的第一周是从 getFirstDayOfWeek() 开始的最早的 7 天时间段，其中至少包含该年的 getMinimalDaysInFirstWeek() 天。因此，它取决于 getMinimalDaysInFirstWeek() 、 getFirstDayOfWeek() 的值和 1 月 1 日的星期几。一年的第 1 周和下一年的第 1 周（不包括在内）之间的周数从 2 到 52 或 53（除了参与儒略-格里高利转换的年份）。

getFirstDayOfWeek() 和 getMinimalDaysInFirstWeek() 值在构造 GregorianCalendar 时使用依赖于locale的资源进行初始化。 周确定兼容 符合 ISO 8601 标准，当 getFirstDayOfWeek() 为 MONDAY 且 getMinimalDaysInFirstWeek() 为 4 时，这些值用于首选标准的区域设置。这些值可以通过调用 setFirstDayOfWeek() 和 setMinimalDaysInFirstWeek() 来明确设置。

week year 与 WEEK_OF_YEAR 周期同步。第一周和最后一周（含）之间的所有周都具有相同的 week year 值。因此，一周的第一天和最后一天可能具有不同的日历年值。

例如，1998 年 1 月 1 日是星期四。如果 getFirstDayOfWeek() 为 MONDAY 且 getMinimalDaysInFirstWeek() 为 4（ISO 8601 标准兼容设置），则 1998 年的第 1 周从 1997 年 12 月 29 日开始，到 1998 年 1 月 4 日结束。对于 1997 日历年的最后三天，星期年份为 1998 . 但是，如果 getFirstDayOfWeek() 是 SUNDAY ，则 1998 年的第 1 周从 1998 年 1 月 4 日开始，到 1998 年 1 月 10 日结束； 1998 年的前三天是 1997 年第 53 周的一部分，他们的星期年是 1997 年。

每月的星期

为 WEEK_OF_MONTH 字段计算的值范围从 0 到 6。一个月的第 1 周（带有 WEEK_OF_MONTH = 1 的日子）是该月中最早的一组至少 getMinimalDaysInFirstWeek() 连续天数，在 getFirstDayOfWeek() 之前的一天结束。与一年的第 1 周不同，一个月的第 1 周可能短于 7 天，不需要从 getFirstDayOfWeek() 开始，并且不包括上个月的天数。第 1 周之前一个月的天数的 WEEK_OF_MONTH 为 0。

例如，如果 getFirstDayOfWeek() 为 SUNDAY 且 getMinimalDaysInFirstWeek() 为 4，则 1998 年 1 月的第一周为 1 月 4 日星期日至 1 月 10 日星期六。这些天的 WEEK_OF_MONTH 为 1。1 月 1 日星期四至 1 月 3 日星期六有 WEEK_OF_MONTH为 0。如果 getMinimalDaysInFirstWeek() 更改为 3，则从 1 月 1 日到 1 月 3 日的 WEEK_OF_MONTH 为 1。

默认字段值

clear 方法将日历字段设置为未定义。 GregorianCalendar 如果每个日历字段的值未定义，则使用以下默认值。

GregorianCalendar 默认字段值
Field 默认值
ERA AD
YEAR 1970
MONTH JANUARY
DAY_OF_MONTH 1
DAY_OF_WEEK the first day of week
WEEK_OF_MONTH 0
DAY_OF_WEEK_IN_MONTH 1
AM_PM AM
HOUR, HOUR_OF_DAY, MINUTE, SECOND, MILLISECOND 0

默认值不适用于上面未列出的字段。

Example:

 // 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
自从：
1.1
参见：

  • 字段详细信息

    • BC

      public static final int BC
      ERA 字段的值指示共同时代（基督之前）之前的时期，也称为 BCE。从 BC 到 AD 过渡的年份顺序是 ..., 2 BC, 1 BC, 1 AD, 2 AD,...
      参见：

  • 构造方法详细信息

    • GregorianCalendar

      public GregorianCalendar()
      使用默认 FORMAT 区域设置的默认时区中的当前时间构造默认 GregorianCalendar。

    • GregorianCalendar

      public GregorianCalendar(TimeZone  zone)
      使用默认的 FORMAT 区域设置，根据给定时区中的当前时间构造一个 GregorianCalendar。
      参数：
      zone - 给定的时区。

    • GregorianCalendar

      public GregorianCalendar(Locale  aLocale)
      根据给定区域设置的默认时区中的当前时间构造一个 GregorianCalendar。
      参数：
      aLocale - 给定的locale。

    • GregorianCalendar

      public GregorianCalendar(TimeZone  zone, Locale  aLocale)
      根据给定区域设置的给定时区中的当前时间构造一个 GregorianCalendar。
      参数：
      zone - 给定的时区。
      aLocale - 给定的locale。

    • GregorianCalendar

      public GregorianCalendar(int year, int month, int dayOfMonth)
      构造一个 GregorianCalendar，在默认时区和默认locale中设置给定日期。
      参数：
      year - 用于在日历中设置 YEAR 日历字段的值。
      month - 用于在日历中设置 MONTH 日历字段的值。月份值从 0 开始。例如，0 表示一月。
      dayOfMonth - 用于设置日历中 DAY_OF_MONTH 日历字段的值。

    • GregorianCalendar

      public GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute)
      使用默认区域设置为默认时区设置给定日期和时间构造GregorianCalendar。
      参数：
      year - 用于在日历中设置 YEAR 日历字段的值。
      month - 用于在日历中设置 MONTH 日历字段的值。月份值从 0 开始。例如，0 表示一月。
      dayOfMonth - 用于设置日历中 DAY_OF_MONTH 日历字段的值。
      hourOfDay - 用于在日历中设置 HOUR_OF_DAY 日历字段的值。
      minute - 用于在日历中设置 MINUTE 日历字段的值。

    • GregorianCalendar

      public GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute, int second)
      使用默认区域设置为默认时区设置给定日期和时间构造一个 GregorianCalendar。
      参数：
      year - 用于在日历中设置 YEAR 日历字段的值。
      month - 用于在日历中设置 MONTH 日历字段的值。月份值从 0 开始。例如，0 表示一月。
      dayOfMonth - 用于设置日历中 DAY_OF_MONTH 日历字段的值。
      hourOfDay - 用于在日历中设置 HOUR_OF_DAY 日历字段的值。
      minute - 用于在日历中设置 MINUTE 日历字段的值。
      second - 用于在日历中设置 SECOND 日历字段的值。

  • 方法详情

    • setGregorianChange

      public void setGregorianChange(Date  date)
      设置 GregorianCalendar 更改日期。这是从 Julian 日期转换为 Gregorian 日期的时间点。默认值为 1582 年 10 月 15 日（公历）。在此之前，日期将采用儒略历。

      要获得纯儒略历，请将更改日期设置为 Date(Long.MAX_VALUE) 。要获得纯公历，请将更改日期设置为 Date(Long.MIN_VALUE) 。

      参数：
      date - 给定的公历转换日期。

    • getGregorianChange

      public final Date  getGregorianChange()
      获取公历更改日期。这是从 Julian 日期转换为 Gregorian 日期的时间点。默认值为 1582 年 10 月 15 日（公历）。在此之前，日期将采用儒略历。
      返回：
      此 GregorianCalendar 对象的公历转换日期。

    • isLeapYear

      public boolean isLeapYear(int year)
      确定给定年份是否为闰年。如果给定年份是闰年，则返回 true。要指定 BC 年份数字，必须给出 1 - year number。例如，BC 4 年指定为 -3。
      参数：
      year - 给定年份。
      返回：
      true 如果给定年份是闰年； false否则。

    • getCalendarType

      public String  getCalendarType()
      返回 "gregory" 作为日历类型。
      重写：
      getCalendarType 在类 Calendar 中
      返回：
      "gregory"
      自从：
      1.8
      参见：

    • equals

      public boolean equals(Object  obj)
      将此 GregorianCalendar 与指定的 Object 进行比较。结果是 true 当且仅当参数是一个 GregorianCalendar 对象，该对象在与该对象相同的 Calendar 参数和公历更改日期下表示相同的时间值（与 时代 的毫秒偏移量）。
      重写：
      equals 在类 Calendar 中
      参数：
      obj - 要与之比较的对象。
      返回：
      true 如果此对象等于 obj ； false否则。
      参见：

    • hashCode

      public int hashCode()
      为此 GregorianCalendar 对象生成哈希码。
      重写：
      hashCode 在类 Calendar 中
      返回：
      此对象的哈希码值。
      参见：

    • add

      public void add(int field, int amount)
      根据日历的规则，将指定的（有符号的）时间量添加到给定的日历字段。

      Add rule 1。调用后 field 的值减去调用前 field 的值是 amount，对 field 中发生的任何溢出取模。当字段值超出其范围时会发生溢出，因此，下一个较大的字段会递增或递减，并且字段值会调整回其范围内。

      Add rule 2。如果期望一个较小的字段是不变的，但是由于field改变后它的最小值或最大值发生变化而不可能等于它的先前值，那么它的值被调整为尽可能接近它的期望值值。较小的字段代表较小的时间单位。 HOUR 是比 DAY_OF_MONTH 更小的字段。不对预计不会不变的较小字段进行任何调整。日历系统确定哪些字段应该是不变的。

      指定者：
      add 在类 Calendar 中
      参数：
      field - 日历字段。
      amount - 要添加到字段的日期或时间量。
      抛出：
      IllegalArgumentException - 如果 field 是 ZONE_OFFSET 、 DST_OFFSET 或未知，或者如果任何日历字段在非宽松模式下具有超出范围的值。
      参见：

    • roll

      public void roll(int field, boolean up)
      在给定时间字段上添加或减去（向上/向下）单个时间单位而不更改更大的字段。

      Example：考虑最初设置为 1999 年 12 月 31 日的 GregorianCalendar。调用 roll(Calendar.MONTH, true) 将日历设置为 1999 年 1 月 31 日。YEAR 字段未更改，因为它比 MONTH 的字段大。

      指定者：
      roll 在类 Calendar 中
      参数：
      field - 时间字段。
      up - 指示指定日历字段的值是向上滚动还是向下滚动。如果汇总使用 true，否则使用 false。
      抛出：
      IllegalArgumentException - 如果 field 是 ZONE_OFFSET 、 DST_OFFSET 或未知，或者如果任何日历字段在非宽松模式下具有超出范围的值。
      参见：

    • roll

      public void roll(int field, int amount)
      在不更改较大字段的情况下将带符号的金额添加到指定的日历字段。负滚动量意味着从字段中减去而不改变更大的字段。如果指定的金额为 0，则此方法不执行任何操作。

      此方法在添加金额之前调用 Calendar.complete() ，以便对所有日历字段进行规范化。如果在非宽松模式下有任何日历字段具有超出范围的值，则会抛出 IllegalArgumentException。

      Example：考虑 GregorianCalendar 最初设置为 1999 年 8 月 31 日。调用 roll(Calendar.MONTH, 8) 将日历设置为 4 月 30 日，1999。使用 GregorianCalendar ， DAY_OF_MONTH 字段在 4 月不能为 31。 DAY_OF_MONTH 设置为最接近的可能值 30。YEAR 字段保持 1999 的值，因为它比 MONTH 更大。

      Example ：考虑最初设置为 1999 年 6 月 6 日星期日的 GregorianCalendar。调用 roll(Calendar.WEEK_OF_MONTH, -1) 将日历设置为 1999 年 6 月 1 日星期二，而调用 add(Calendar.WEEK_OF_MONTH, -1) 将日历设置为 1999 年 5 月 30 日星期日。这是因为滚动规则强加了一个额外的约束：当滚动 WEEK_OF_MONTH 时，MONTH 不得更改。结合添加规则 1，结果日期必须在 6 月 1 日星期二和 6 月 5 日星期六之间。根据添加规则 2，更改 WEEK_OF_MONTH 时的不变量 DAY_OF_WEEK 设置为星期二，最接近星期日的可能值（其中星期日是一周的第一天）。

      重写：
      roll 在类 Calendar 中
      参数：
      field - 日历字段。
      amount - 要添加到 field 的已签名金额。
      抛出：
      IllegalArgumentException - 如果 field 是 ZONE_OFFSET 、 DST_OFFSET 或未知，或者如果任何日历字段在非宽松模式下具有超出范围的值。
      自从：
      1.2
      参见：

    • getMinimum

      public int getMinimum(int field)
      返回此 GregorianCalendar 实例的给定日历字段的最小值。最小值定义为 get 方法为任何可能的时间值返回的最小值，同时考虑到 getFirstDayOfWeek 、getMinimalDaysInFirstWeek 、getGregorianChange 和 getTimeZone 方法的当前值。
      指定者：
      getMinimum 在类 Calendar 中
      参数：
      field - 日历字段。
      返回：
      给定日历字段的最小值。
      参见：

    • getMaximum

      public int getMaximum(int field)
      返回此 GregorianCalendar 实例的给定日历字段的最大值。考虑到 getFirstDayOfWeek 、getMinimalDaysInFirstWeek 、getGregorianChange 和 getTimeZone 方法的当前值，最大值定义为 get 方法返回的任何可能时间值的最大值。
      指定者：
      getMaximum 在类 Calendar 中
      参数：
      field - 日历字段。
      返回：
      给定日历字段的最大值。
      参见：

    • getGreatestMinimum

      public int getGreatestMinimum(int field)
      返回此 GregorianCalendar 实例的给定日历字段的最高最小值。考虑到 getFirstDayOfWeek 、getMinimalDaysInFirstWeek 、getGregorianChange 和 getTimeZone 方法的当前值，最高最小值定义为 getActualMinimum(int) 返回的任何可能时间值的最大值。
      指定者：
      getGreatestMinimum 在类 Calendar 中
      参数：
      field - 日历字段。
      返回：
      给定日历字段的最高最小值。
      参见：

    • getLeastMaximum

      public int getLeastMaximum(int field)
      返回此 GregorianCalendar 实例的给定日历字段的最小最大值。考虑到 getFirstDayOfWeek 、getMinimalDaysInFirstWeek 、getGregorianChange 和 getTimeZone 方法的当前值，最小最大值定义为 getActualMaximum(int) 为任何可能的时间值返回的最小值。
      指定者：
      getLeastMaximum 在类 Calendar 中
      参数：
      field - 日历字段
      返回：
      给定日历字段的最小最大值。
      参见：

    • getActualMinimum

      public int getActualMinimum(int field)
      返回此日历字段可能具有的最小值，同时考虑给定的时间值和 getFirstDayOfWeek 、getMinimalDaysInFirstWeek 、getGregorianChange 和 getTimeZone 方法的当前值。

      例如，如果公历更改日期为 1970 年 1 月 10 日，而此 GregorianCalendar 的日期为 1970 年 1 月 20 日，则 DAY_OF_MONTH 字段的实际最小值为 10，因为 1970 年 1 月 10 日的前一个日期为 1996 年 12 月 27 日（在儒略历中）。因此，1969 年 12 月 28 日至 1970 年 1 月 9 日不存在。

      重写：
      getActualMinimum 在类 Calendar 中
      参数：
      field - 日历字段
      返回：
      此 GregorianCalendar 的时间值的给定字段的最小值
      自从：
      1.2
      参见：

    • getActualMaximum

      public int getActualMaximum(int field)
      返回此日历字段可能具有的最大值，同时考虑给定的时间值和 getFirstDayOfWeek 、getMinimalDaysInFirstWeek 、getGregorianChange 和 getTimeZone 方法的当前值。例如，如果本实例的日期是2004年2月1日，那么DAY_OF_MONTH字段的实际最大值是29，因为2004年是闰年，如果本实例的日期是2005年2月1日，则为28。

      此方法根据 YEAR （日历年）值而不是 周年 计算 WEEK_OF_YEAR 的最大值。调用 getWeeksInWeekYear() 以获取 WEEK_OF_YEAR 在这个 GregorianCalendar 的星期年份中的最大值。

      重写：
      getActualMaximum 在类 Calendar 中
      参数：
      field - 日历字段
      返回：
      此 GregorianCalendar 的时间值的给定字段的最大值
      自从：
      1.2
      参见：

    • isWeekDateSupported

      public final boolean isWeekDateSupported()
      返回 true 表示此 GregorianCalendar 支持周日期。
      重写：
      isWeekDateSupported 在类 Calendar 中
      返回：
      true（总是）
      自从：
      1.7
      参见：

    • getWeekYear

      public int getWeekYear()
      返回由此 GregorianCalendar 表示的 周年。在 1 和周年的最大周数之间的周中的日期具有相同的周年值，可能是 YEAR （日历年）值之前或之后的一年。

      此方法在计算周年之前调用Calendar.complete() 。

      重写：
      getWeekYear 在类 Calendar 中
      返回：
      这个 GregorianCalendar 代表的星期年。如果 ERA 值为 BC ，则年份由 0 或负数表示：BC 1 为 0，BC 2 为 -1，BC 3 为 -2，依此类推。
      抛出：
      IllegalArgumentException - 如果任何日历字段在非宽松模式下无效。
      自从：
      1.7
      参见：

    • setWeekDate

      public void setWeekDate(int weekYear, int weekOfYear, int dayOfWeek)
      将此 GregorianCalendar 设置为日期说明符 - weekYear 、weekOfYear 和 dayOfWeek 给出的日期。 weekOfYear 在 WEEK_OF_YEAR编号 之后。 dayOfWeek 值必须是 DAY_OF_WEEK 值之一：SUNDAY 到 SATURDAY 。

      请注意，星期几的数字表示与 ISO 8601 标准不同，并且当 getFirstDayOfWeek() 为 MONDAY 且 getMinimalDaysInFirstWeek() 为 4 时，weekOfYear 编号与标准兼容。

      与 set 方法不同，所有日历字段和时间值都是在返回时计算的。

      如果 weekOfYear 超出了 weekYear 中的有效星期范围，则 weekYear 和 weekOfYear 值将在宽松模式下进行调整，或者在非宽松模式下抛出 IllegalArgumentException。

      重写：
      setWeekDate 在类 Calendar 中
      参数：
      weekYear - 星期年
      weekOfYear - 基于 weekYear 的周数
      dayOfWeek - 星期几值：DAY_OF_WEEK 字段的常量之一：SUNDAY ，...，SATURDAY 。
      抛出：
      IllegalArgumentException - 如果任何给定的日期说明符无效，或者如果任何日历字段与非宽松模式下的给定日期说明符不一致
      自从：
      1.7
      参见：

    • getWeeksInWeekYear

      public int getWeeksInWeekYear()
      返回由此 GregorianCalendar 表示的 周年 中的周数。

      例如，如果此 GregorianCalendar 的日期是 2008 年 12 月 31 日和 ISO 8601 兼容设置 ，此方法将返回 53 期间：2008 年 12 月 29 日至 2010 年 1 月 3 日，而 getActualMaximum(WEEK_OF_YEAR) 将返回 52 期间：2007 年 12 月 31 日至 12 月2008 年 2 月 28 日。

      重写：
      getWeeksInWeekYear 在类 Calendar 中
      返回：
      周年中的周数。
      自从：
      1.7
      参见：

    • computeFields

      protected void computeFields()
      将时间值（从 时代 偏移的毫秒数）转换为日历字段值。 not先重新计算时间；要重新计算时间，然后是字段，请调用 complete 方法。
      指定者：
      computeFields 在类 Calendar 中
      参见：

    • computeTime

      protected void computeTime()
      将日历字段值转换为时间值（与 时代 的毫秒偏移量）。
      指定者：
      computeTime 在类 Calendar 中
      抛出：
      IllegalArgumentException - 如果任何日历字段无效。
      参见：

    • toZonedDateTime

      public ZonedDateTime  toZonedDateTime()
      将此对象转换为 ZonedDateTime，表示时间线上与此 GregorianCalendar 相同的点。

      由于此对象支持 Julian-Gregorian 转换日期而 ZonedDateTime 不支持，因此生成的年、月和日可能具有不同的值。结果将代表 ISO 日历系统中的正确日期，这对于修改后的儒略日也将是相同的值。

      返回：
      表示时间线上与此公历相同的点的分区日期时间
      自从：
      1.8

    • from

      public static GregorianCalendar  from(ZonedDateTime  zdt)
      从 ZonedDateTime 对象获取具有默认locale的 GregorianCalendar 实例。

      由于 ZonedDateTime 不支持 Julian-Gregorian 转换日期并使用 ISO 日历系统，因此返回的 GregorianCalendar 是纯公历并使用 ISO 8601 标准定义周，其中 MONDAY 作为 FirstDayOfWeek 和 4 作为 MinimalDaysInFirstWeek 的值。

      ZoneDateTime 可以将时间线上的点存储在比 GregorianCalendar 更远的未来和更远的过去。在这种情况下，此方法将抛出 IllegalArgumentException 异常。

      参数：
      zdt - 要转换的分区日期时间对象
      返回：
      公历表示时间线上与提供的分区日期时间相同的点
      抛出：
      NullPointerException - 如果 zdt 为空
      IllegalArgumentException - 如果分区日期时间太大而无法表示为 GregorianCalendar
      自从：
      1.8