YearMonth (Java Platform SE 8 )

java.lang.Object
- java.time.YearMonth

All Implemented Interfaces:

Serializable， Comparable < YearMonth >， Temporal， TemporalAccessor， TemporalAdjuster
```
public final class YearMonth
extends Object
implements Temporal, TemporalAdjuster, Comparable<YearMonth>, Serializable
```
一年中的ISO-8601日历系统月，如 2007-12。
YearMonth是不变的日期时间对象，代表一年和月的结合。任何一个可以从一年和一个月，如一年四分之一，可以得到的字段。

这个类不存储或表示一天、时间或时区。例如，值“十月2007”可以被存储在一个YearMonth。

该系统是现代民法ISO-8601日历日历系统中使用的大多数今天的世界。它相当于proleptic公历闰年的系统，在今天的规则适用于所有的时间。今天的大多数应用程序编写的，完全适合的ISO-8601规则。然而，任何应用程序，利用历史数据，并要求他们要准确找到ISO-8601方法不当。

这是一个value-based类；利用身份敏感的操作（包括引用相等（==），身份的哈希代码，或同步）的实例YearMonth可能有不可预知的结果应该是可以避免的。的equals法进行比较。

实现要求：

这个类是不可变的和线程安全的。

从以下版本开始：

一点八

另请参见：

Serialized Form

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Temporal`	`adjustInto(Temporal temporal)` 调整指定的时间对象有今年一个月。
`LocalDate`	`atDay(int dayOfMonth)` 结合今年月日月创造一个 `LocalDate`。
`LocalDate`	`atEndOfMonth()` 将在本月底 `LocalDate`。
`int`	`compareTo(YearMonth other)` 比较今年月到另一个月。
`boolean`	`equals(Object obj)` 检查，如果今年月等于另一个月。
`String`	`format(DateTimeFormatter formatter)` 今年月格式使用指定的格式化程序。
`static YearMonth`	`from(TemporalAccessor temporal)` 获得 `YearMonth`实例从一个时空对象。
`int`	`get(TemporalField field)` 从今年月获取指定字段的值作为一个 `int`。
`long`	`getLong(TemporalField field)` 从今年月获取指定字段的值作为一个 `long`。
`Month`	`getMonth()` 得到月年田间使用 `Month`枚举。
`int`	`getMonthValue()` 从1到12得到一个月的时间字段。
`int`	`getYear()` 获取年度字段。
`int`	`hashCode()` 这个月的一个哈希代码。
`boolean`	`isAfter(YearMonth other)` 是今年一个月后指定的一年。
`boolean`	`isBefore(YearMonth other)` 是在今年月前指定的一年。
`boolean`	`isLeapYear()` 检查，如果今年是闰年，根据ISO预期历法系统规则。
`boolean`	`isSupported(TemporalField field)` 检查指定字段是否被支持。
`boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否被支持。
`boolean`	`isValidDay(int dayOfMonth)` 检查月日是否有效期为本月。
`int`	`lengthOfMonth()` 返回一个月的长度，考虑到一年。
`int`	`lengthOfYear()` 返回一年的长度。
`YearMonth`	`minus(long amountToSubtract, TemporalUnit unit)` 返回一个与指定的金额减去这个月的一个副本。
`YearMonth`	`minus(TemporalAmount amountToSubtract)` 返回一个与指定的金额减去这个月的一个副本。
`YearMonth`	`minusMonths(long monthsToSubtract)` 返回一个月的副本，与指定的周期在几个月内减去。
`YearMonth`	`minusYears(long yearsToSubtract)` 返回本年月的一个副本，在年中减去指定的时间。
`static YearMonth`	`now()` 从默认时区中获得当前年月的时间。
`static YearMonth`	`now(Clock clock)` 从指定的时钟获取当前年月。
`static YearMonth`	`now(ZoneId zone)` 从指定时区中的系统时钟中获得当前年月份。
`static YearMonth`	`of(int year, int month)` 获得 `YearMonth`实例从年月。
`static YearMonth`	`of(int year, Month month)` 获得 `YearMonth`实例从年月。
`static YearMonth`	`parse(CharSequence text)` 获得 `YearMonth`实例从一个文本字符串，如 `2007-12`。
`static YearMonth`	`parse(CharSequence text, DateTimeFormatter formatter)` 获得 `YearMonth`实例从使用特定格式的文本字符串。
`YearMonth`	`plus(long amountToAdd, TemporalUnit unit)` 返回本年月的一个副本，添加指定的金额。
`YearMonth`	`plus(TemporalAmount amountToAdd)` 返回本年月的一个副本，添加指定的金额。
`YearMonth`	`plusMonths(long monthsToAdd)` 返回一个月的副本，与指定的时间在几个月内添加。
`YearMonth`	`plusYears(long yearsToAdd)` 返回本年月的副本，在指定的时间内添加。
`<R> R`	`query(TemporalQuery<R> query)` 使用指定的查询查询本月的查询。
`ValueRange`	`range(TemporalField field)` 获取指定字段的有效值的范围。
`String`	`toString()` 输出为 `String`今年月，如 `2007-12`。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 计算时间的数量，直到另一个月的指定单位。
`YearMonth`	`with(TemporalAdjuster adjuster)` 返回本月调整后的副本。
`YearMonth`	`with(TemporalField field, long newValue)` 返回一个与指定字段设置为新值的月份的副本。
`YearMonth`	`withMonth(int month)` 返回一份本 `YearMonth`与月的年变化。
`YearMonth`	`withYear(int year)` 返回一份本 `YearMonth`与年变化。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 方法详细信息
  - now
```
public static YearMonth now()
```
    从默认时区中获得当前年月的时间。
    这将查询system clock在默认时区获取当前月。该区域和偏移将基于时钟上的时区设置。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    结果
    
    当前的一个月使用系统时钟和默认时区，而不是空
  - now
```
public static YearMonth now(ZoneId zone)
```
    从指定时区中的系统时钟中获得当前年月份。
    这将查询system clock获取当前月。指定时区避免依赖于默认时区。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    参数
    
    zone -区ID使用，不为空
    
    结果
    
    当前使用系统时钟的一个月，不是空的
  - now
```
public static YearMonth now(Clock clock)
```
    从指定的时钟获取当前年月。
    这将查询指定的时钟，以获得当前的一个月。使用这种方法允许使用一个备用时钟进行测试。备用时钟可采用dependency injection。
    
    参数
    
    clock -时钟使用，不为空
    
    结果
    
    当前的一年，而不是零
  - of
```
public static YearMonth of(int year,
                           Month month)
```
    获得 YearMonth实例从年月。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月表示，不为空
    
    结果
    
    一年的月，不是空
    
    异常
    
    DateTimeException如果年值无效
  - of
```
public static YearMonth of(int year,
                           int month)
```
    获得 YearMonth实例从年月。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月为代表，从1（一月）到12（十二月）
    
    结果
    
    一年的月，不是空
    
    异常
    
    DateTimeException -如果字段的值是无效的
  - from
```
public static YearMonth from(TemporalAccessor temporal)
```
    获得 YearMonth实例从一个时空对象。
    这将获得一个年月的基础上指定的时间。一个TemporalAccessor表示日期和时间信息，任意设置，本厂将以YearMonth实例。
    
    转换提取YEAR和MONTH_OF_YEAR领域。提取只允许如果时空对象有一个ISO年表，或可以转换为一个LocalDate。
    
    这种方法相匹配的功能接口TemporalQuery可以通过方法引用查询中的签名，YearMonth::from。
    
    参数
    
    temporal -转换时间的对象，不为空
    
    结果
    
    一年的月，不是空
    
    异常
    
    DateTimeException如果无法转换为 YearMonth
  - parse
```
public static YearMonth parse(CharSequence text)
```
    获得 YearMonth实例从一个文本字符串，如 2007-12。
    该字符串必须代表一个有效的一年。格式必须uuuu-MM。年在范围0000到9999必须加上正负符号。
    
    参数
    
    text -解析”等文字，不为2007年12月”
    
    结果
    
    解析的一个月，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - parse
```
public static YearMonth parse(CharSequence text,
                              DateTimeFormatter formatter)
```
    获得 YearMonth实例从使用特定格式的文本字符串。
    文字使用格式化程序解析，返回一个月。
    
    参数
    
    text -解析文本，不空
    
    formatter -格式化程序使用，不为空
    
    结果
    
    解析的一个月，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    检查指定字段是否被支持。
    这项检查，如果今年月可以查询指定的字段。如果为false，则调用range，get和with(TemporalField, long)方法将抛出一个异常。
    
    如果该字段是ChronoField然后查询执行。支持的字段是：
    - MONTH_OF_YEAR
    - PROLEPTIC_MONTH
    - YEAR_OF_ERA
    - YEAR
    - ERA
    所有其他 ChronoField实例将返回false。
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.isSupportedBy(TemporalAccessor)得到此方法的结果。是否支持字段由字段确定。
    Specified by:
    
    isSupported 接口 TemporalAccessor
    
    参数
    
    field -现场检查null返回false
    
    结果
    
    如果这个字段是在这个月的支持，假如果不是
  - isSupported
```
public boolean isSupported(TemporalUnit unit)
```
    检查指定的单位是否被支持。
    此检查如果指定的单位可以添加到或减去，这个日期时间。如果为false，则调用plus(long, TemporalUnit)和minus方法将抛出一个异常。
    
    如果单位是一个ChronoUnit然后查询执行。所支持的单位是：
    - MONTHS
    - YEARS
    - DECADES
    - CENTURIES
    - MILLENNIA
    - ERAS
    所有其他 ChronoUnit实例将返回false。
    如果单位不ChronoUnit，然后通过调用作为参数传递this TemporalUnit.isSupportedBy(Temporal)得到此方法的结果。是否支持单位是由单位确定的。
    Specified by:
    
    isSupported 接口 Temporal
    
    参数
    
    unit -检查单元，空返回false
    
    结果
    
    如果单位可以增加/减去，如果没有的话
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值的范围。
    该范围对象表示字段的最小值和最大有效值。本月是用来提高返回范围的准确性。如果它是不可能返回的范围，因为字段不支持或其他一些原因，抛出一个异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将返回适当的范围的情况下。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.rangeRefinedBy(TemporalAccessor)得到此方法的结果。是否可以得到范围是由字段确定的。
    
    Specified by:
    
    range 接口 TemporalAccessor
    
    参数
    
    field -现场查询范围，不为空
    
    结果
    
    字段的有效值的范围，而不是空值
    
    异常
    
    DateTimeException如果不能得到的领域范围
    
    UnsupportedTemporalTypeException如果字段不支持
  - get
```
public int get(TemporalField field)
```
    从今年月获取指定字段的值作为一个 int。
    此查询为指定字段的值，此月为。返回的值将始终在字段的有效值范围内。如果不可能返回值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将基于今年月的有效值，除了PROLEPTIC_MONTH，太大的int、扔DateTimeException。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    Specified by:
    
    get 接口 TemporalAccessor
    
    参数
    
    field -领域有，不空
    
    结果
    
    字段的值
    
    异常
    
    DateTimeException如果字段的值是不能获得或值不在字段的有效值范围内
    
    UnsupportedTemporalTypeException -如果字段不支持或值的范围超过一个 int
    
    ArithmeticException如果数值溢出时
  - getLong
```
public long getLong(TemporalField field)
```
    从今年月获取指定字段的值作为一个 long。
    此查询为指定字段的值，此月为。如果不可能返回值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将基于今年月有效值。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    Specified by:
    
    getLong 接口 TemporalAccessor
    
    参数
    
    field -领域有，不空
    
    结果
    
    字段的值
    
    异常
    
    DateTimeException如果不能得到一个价值领域
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - getYear
```
public int getYear()
```
    获取年度字段。
    此方法将返回该年原始int价值。
    
    此方法返回的一年预期为每get(YEAR)。
    
    结果
    
    一年来，从min_year max_year
  - getMonthValue
```
public int getMonthValue()
```
    从1到12得到一个月的时间字段。
    这个方法返回月作为一个int从1到12。应用程序代码经常清楚如果枚举Month是通过调用getMonth()使用。
    
    结果
    
    一年中的一个月，从1到12
    
    另请参见：
    
    getMonth()
  - getMonth
```
public Month getMonth()
```
    得到月年田间使用 Month枚举。
    此方法返回的枚举Month月。这避免了混乱是什么int平均值。如果你需要访问原始int值然后枚举提供int value。
    
    结果
    
    一年中的一个月，而不是零
    
    另请参见：
    
    getMonthValue()
  - isLeapYear
```
public boolean isLeapYear()
```
    检查，如果今年是闰年，根据ISO预期历法系统规则。
    此方法适用于在整个时间线的当前规则的跨越式。一般来说，一年是闰年，如果它能被四整除而没有余数。然而，年100整除，不是闰年，以400的年分的例外。
    
    例如，1904是一个闰年是能被4整除。1900不是一个闰年为100是可分的，但是2000是一个闰年为400是可分的。
    
    计算预期的规则应用到遥远的未来和遥远的过去。这是不准确的，但正确的ISO-8601标准。
    
    结果
    
    如果一年是跳跃的，否则是错误的
  - isValidDay
```
public boolean isValidDay(int dayOfMonth)
```
    检查月日是否有效期为本月。
    这种方法检查是否今年和月和输入日形成一个有效日期。
    
    参数
    
    dayOfMonth -月验证的一天，从1到31，无效值返回false
    
    结果
    
    如果这一天是有效的，如果一天是有效的
  - lengthOfMonth
```
public int lengthOfMonth()
```
    返回一个月的长度，考虑到一年。
    这将返回一个月的长度。例如，一月的一个日期将返回31。
    
    结果
    
    在天的长度，从28到31
  - lengthOfYear
```
public int lengthOfYear()
```
    返回一年的长度。
    这将返回一年的长度，无论是365或366。
    
    结果
    
    366如果一年是跳跃，否则365
  - with
```
public YearMonth with(TemporalAdjuster adjuster)
```
    返回本月调整后的副本。
    这将返回一个YearMonth，基于此，与年月调整。调整使用指定的调整器策略对象。阅读调整器的文档，了解将要做什么调整。
    
    一个简单的调节器可以简单地设置一个字段，例如年字段。一个更复杂的调节器可以设置年月，Halley彗星将经过地球到下个月。
    
    这种方法的结果是通过调用指定的调节器，通过this作为论据的TemporalAdjuster.adjustInto(Temporal)方法得到的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    adjuster -调节器使用，不为空
    
    结果
    
    一个 YearMonth基于调整 this，不空
    
    异常
    
    DateTimeException -如果调整不能
    
    ArithmeticException如果数值溢出时
  - with
```
public YearMonth with(TemporalField field,
                      long newValue)
```
    返回一个与指定字段设置为新值的月份的副本。
    这将返回一个YearMonth，在此基础上，对指定字段的值的变化。这可以用来改变任何支持的领域，如一年或一个月。如果不可能设置值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后调整在这里实现。所支持的字段如下：
    - MONTH_OF_YEAR返回具有指定月年YearMonth。年将不变。
    - PROLEPTIC_MONTH返回具有指定预期月YearMonth。这完全取代了这个对象的一年和一个月。
    - YEAR_OF_ERA返回具有指定年时代的月和时代将是不变的YearMonth。
    - YEAR -返回与指定的年YearMonth。本月将不变。
    - ERA -返回与指定的时代YearMonth。时代的一个月和一年将是不变的。
    在所有的情况下，如果新的数值超出有效范围的领域，然后DateTimeException将抛出。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.adjustInto(Temporal, long)得到此方法的结果。在这种情况下，字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    field -现场设置的结果，不为空
    
    newValue -场的结果中的新价值
    
    结果
    
    一个 YearMonth基于指定的字段集 this，不空
    
    异常
    
    DateTimeException -如果该字段不能设置
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - withYear
```
public YearMonth withYear(int year)
```
    返回一份本 YearMonth与年变化。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    year年设置返回的年月，从min_year到max_year
    
    结果
    
    与请求年于今年月 YearMonth为主，不为空
    
    异常
    
    DateTimeException如果年值无效
  - withMonth
```
public YearMonth withMonth(int month)
```
    返回一份本 YearMonth与月的年变化。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    month -年月在返回的年月，从1（一月）到12（十二月）
    
    结果
    
    一个 YearMonth基于今年月与请求的月，不为空
    
    异常
    
    DateTimeException如果年值月是无效的
  - plus
```
public YearMonth plus(TemporalAmount amountToAdd)
```
    返回本年月的一个副本，添加指定的金额。
    这将返回一个YearMonth，在此基础上，用指定的添加量。量通常是Period但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.addTo(Temporal)数量，实现免费在任何情况下它的愿望实现，但是它通常称为回plus(long, TemporalUnit)。咨询量的执行文件以确定它是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -添加量，不为空
    
    结果
    
    加上今年月 YearMonth为主，不为空
    
    异常
    
    DateTimeException如果还不能
    
    ArithmeticException如果数值溢出时
  - plus
```
public YearMonth plus(long amountToAdd,
                      TemporalUnit unit)
```
    返回本年月的一个副本，添加指定的金额。
    这将返回一个YearMonth，基于此，在单元的添加量。如果它是不可能添加的量，因为该单元不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoUnit然后添加在这里实现。所支持的字段如下：
    - MONTHS -返回一个与指定数个月YearMonth添加。这相当于plusMonths(long)。
    - YEARS -返回一个与指定数年YearMonth添加。这相当于plusYears(long)。
    - DECADES -返回一个与指定数年YearMonth添加。这相当于用金额乘以10呼叫plusYears(long)。
    - CENTURIES -返回与指定数世纪YearMonth添加。这相当于用金额乘以100呼叫plusYears(long)。
    - MILLENNIA返回具有指定数量的千年YearMonth添加。这相当于用金额乘以1000呼叫plusYears(long)。
    - ERAS返回具有指定数量的时代YearMonth添加。只有两个时代是支持的，所以金额必须是一个，零或负一个。如果金额为非零，则年是改变的，这样的时代是不变的。
    所有其他ChronoUnit实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoUnit，然后通过调用作为参数传递this TemporalUnit.addTo(Temporal, long)得到此方法的结果。在这种情况下，该单元确定是否和如何执行加法。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -单位的数量增加的结果，可能是负面的
    
    unit -量的单位添加，不为空
    
    结果
    
    用指定的添加量在今年月 YearMonth为主，不为空
    
    异常
    
    DateTimeException如果还不能
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - plusYears
```
public YearMonth plusYears(long yearsToAdd)
```
    返回本年月的副本，在指定的时间内添加。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    yearsToAdd -加年，可能是负面的
    
    结果
    
    随着年龄的增加在今年月 YearMonth为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的范围
  - plusMonths
```
public YearMonth plusMonths(long monthsToAdd)
```
    返回一个月的副本，与指定的时间在几个月内添加。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    monthsToAdd -加个月，可能是负面的
    
    结果
    
    一个 YearMonth基于今年月与月说，不空
    
    异常
    
    DateTimeException -如果结果超过支持的范围
  - minus
```
public YearMonth minus(TemporalAmount amountToSubtract)
```
    返回一个与指定的金额减去这个月的一个副本。
    这将返回一个YearMonth，在此基础上，用指定的金额减去。量通常是Period但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.subtractFrom(Temporal)。量实现自由以任何方式希望实现减法，但它通常需要回minus(long, TemporalUnit)。咨询文档的量的实现，以确定它是否可以成功地减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去的量，不为空
    
    结果
    
    用减法，在今年月 YearMonth为主，不为空
    
    异常
    
    DateTimeException如果减法不能做
    
    ArithmeticException如果数值溢出时
  - minus
```
public YearMonth minus(long amountToSubtract,
                       TemporalUnit unit)
```
    返回一个与指定的金额减去这个月的一个副本。
    这将返回一个YearMonth，在此基础上，对单位金额减去。如果它是不可能的减去的量，因为该单位不支持或一些其他原因，一个异常被抛出。
    
    这种方法相当于plus(long, TemporalUnit)量与否定。见该方法充分说明了如何加法，从而减法，作品。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去从结果数额的单位，可能是负面的
    
    unit -金额单位减，不为空
    
    结果
    
    用指定的金额减去今年月 YearMonth为主，不为空
    
    异常
    
    DateTimeException如果减法不能做
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - minusYears
```
public YearMonth minusYears(long yearsToSubtract)
```
    返回本年月的一个副本，在年中减去指定的时间。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    yearsToSubtract -减去年，可能是负面的
    
    结果
    
    随着年中减去在今年月 YearMonth为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的范围
  - minusMonths
```
public YearMonth minusMonths(long monthsToSubtract)
```
    返回一个月的副本，与指定的周期在几个月内减去。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    monthsToSubtract -减去个月，可能是负面的
    
    结果
    
    与月减去今年月 YearMonth为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的范围
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    使用指定的查询查询本月的查询。
    这个查询使用指定的查询策略对象使用本月的一个月。的TemporalQuery对象定义了用来获得结果的逻辑。阅读查询的文档，了解该方法的结果将是什么。
    
    这种方法的结果是通过调用指定的查询通过this作为论据的TemporalQuery.queryFrom(TemporalAccessor)方法得到的。
    
    Specified by:
    
    query 接口 TemporalAccessor
    
    参数类型
    
    R -结果的类型
    
    参数
    
    query -调用查询，不空
    
    结果
    
    查询结果，可以返回（由查询所定义）
    
    异常
    
    DateTimeException如果无法查询（查询所定义）
    
    ArithmeticException如果数值溢出时（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象有今年一个月。
    这将返回一个相同的可观察类型的时间对象，作为一年和一个月的输入是相同的。
    
    调整是相当于用Temporal.with(TemporalField, long)传递ChronoField.PROLEPTIC_MONTH作为现场。如果指定的时间对象不使用ISO的日历系统，然后DateTimeException抛出。
    
    在大多数情况下，更清晰的用Temporal.with(TemporalAdjuster)反向调用模式：
```
这两条线是等价的，但第二种方法是建议时间= thisyearmonth adjustinto（时间）；时间=（thisyearmonth）与时间；
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto 接口 TemporalAdjuster
    
    参数
    
    temporal -调整目标对象，不为空
    
    结果
    
    调整后的对象，而不是空
    
    异常
    
    DateTimeException如果无法适应
    
    ArithmeticException如果数值溢出时
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    计算时间的数量，直到另一个月的指定单位。
    这两YearMonth计算对象之间的时间量在一个TemporalUnit条款。开始和结束点this和指定年、月。结果将是负的，如果结束之前开始。的Temporal传递给此方法转换为YearMonth使用from(TemporalAccessor)。例如，每年两个月之间在年内可以计算startYearMonth.until(endYearMonth, YEARS)。
    
    计算返回一个整数，表示两个月之间的完全单位数。例如，在2012-06和2032-05之间几十年的时间将只有一个十年是短二十年一个月。
    
    使用这种方法有两个等效的方法。首先是调用这个方法。二是用TemporalUnit.between(Temporal, Temporal)：
```
这两条线是等价的金额=开始，直到（结束，月）；金额=月间（开始，结束）；
```
    的选择应基于使得代码更易读。
    计算中实现该方法ChronoUnit。单位MONTHS，YEARS，DECADES，CENTURIES，MILLENNIA和ERAS支持。其他ChronoUnit值将抛出一个异常。
    
    如果单位不ChronoUnit，然后通过调用TemporalUnit.between(Temporal, Temporal) this作为第一个参数传递和转换的输入时间作为第二个参数给出了这个方法的结果。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until 接口 Temporal
    
    参数
    
    endExclusive -结束日期，排斥，这是转化为一个 YearMonth，不空
    
    unit -单位量来衡量，不为空
    
    结果
    
    今年月和年底之间的时间量
    
    异常
    
    DateTimeException如果金额无法计算，或结束时间不能转换为 YearMonth
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - format
```
public String format(DateTimeFormatter formatter)
```
    今年月格式使用指定的格式化程序。
    今年月将通过格式化程序产生一个字符串。
    
    参数
    
    formatter -格式化程序使用，不为空
    
    结果
    
    格式化的年月字符串，而不是空的
    
    异常
    
    DateTimeException如果打印时发生错误
  - atDay
```
public LocalDate atDay(int dayOfMonth)
```
    结合今年月日月创造一个 LocalDate。
    这将返回一个LocalDate从今年月形成和指定的日期。
    
    月值日必须有效期为一年。
    
    此方法可以作为链的一部分，以产生一个日期：
```
localdate日期=年。atmonth（月）。atday（天）；
```
    参数
    
    dayOfMonth -月用一天，从1到31
    
    结果
    
    日期从今年月和指定的一天，而不是空的
    
    异常
    
    DateTimeException如果日为年月无效
    
    另请参见：
    
    isValidDay(int)
  - atEndOfMonth
```
public LocalDate atEndOfMonth()
```
    将在本月底 LocalDate。
    这将返回一个LocalDate基于今年月。月之日定为本月的最后一个有效日，考虑到几年的飞跃。
    
    此方法可以作为链的一部分，以产生一个日期：
```
localdate日期=年。atmonth（月）。atendofmonth()；
```
    结果
    
    这个月的最后一个有效日期，不是空的
  - compareTo
```
public int compareTo(YearMonth other)
```
    比较今年月到另一个月。
    比较是基于一年的价值，然后对月的价值。这是“等于”一致，所定义的Comparable。
    
    Specified by:
    
    compareTo 接口 Comparable<YearMonth>
    
    参数
    
    other -其他年月来比较，不为空
    
    结果
    
    比较器的值，负的，如果少，积极的，如果更大
  - isAfter
```
public boolean isAfter(YearMonth other)
```
    是今年一个月后指定的一年。
    
    参数
    
    other -其他年月来比较，不为空
    
    结果
    
    这是真的，如果这是在指定的一年后
  - isBefore
```
public boolean isBefore(YearMonth other)
```
    是在今年月前指定的一年。
    
    参数
    
    other -其他年月来比较，不为空
    
    结果
    
    如果这一点是在指定的前一个月
  - equals
```
public boolean equals(Object obj)
```
    检查，如果今年月等于另一个月。
    比较是基于一年的时间线位置。
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    obj -检查对象，空返回false
    
    结果
    
    这是真的，如果这是等于另一个月
    
    另请参见：
    
    Object.hashCode()， HashMap
  - hashCode
```
public int hashCode()
```
    这个月的一个哈希代码。
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    一个合适的哈希代码
    
    另请参见：
    
    Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    输出为 String今年月，如 2007-12。
    将输出格式中的uuuu-MM：
    
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    一个这个月的字符串表示，不是空的

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class YearMonth

方法摘要

Methods inherited from class java.lang.Object

方法详细信息

now

now

now

of

of

from

parse

parse

isSupported

isSupported

range

get

getLong

getYear

getMonthValue

getMonth

isLeapYear

isValidDay

lengthOfMonth

lengthOfYear

with

with

withYear

withMonth

plus

plus

plusYears

plusMonths

minus

minus

minusYears

minusMonths

query

adjustInto

until

format

atDay

atEndOfMonth

compareTo

isAfter

isBefore

equals

hashCode

toString