YearMonth (ThreeTen Date and Time API)

java.lang.Object
- javax.time.temporal.YearMonth

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<YearMonth>, Temporal, Temporal.WithAdjuster, TemporalAccessor
```
public final class YearMonth
extends java.lang.Object
implements Temporal, Temporal.WithAdjuster, java.lang.Comparable<YearMonth>, java.io.Serializable
```
A year-month in the ISO-8601 calendar system, such as 2007-12.
YearMonth is an immutable date-time object that represents the combination of a year and month. Any field that can be derived from a year and month, such as quarter-of-year, can be obtained.
This class does not store or represent a day, time or time-zone. For example, the value "October 2007" can be stored in a YearMonth.
The ISO-8601 calendar system is the modern civil calendar system used today in most of the world. It is equivalent to the proleptic Gregorian calendar system, in which todays's rules for leap years are applied for all time. For most applications written today, the ISO-8601 rules are entirely suitable. Any application that uses historical dates should consider using HistoricDate.
Implementation notes
This class is immutable and thread-safe.

See Also:
Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface javax.time.temporal.Temporal
  Temporal.MinusAdjuster, Temporal.PlusAdjuster, Temporal.WithAdjuster
- Nested classes/interfaces inherited from interface javax.time.temporal.TemporalAccessor
  TemporalAccessor.Query<R>

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`LocalDate`	`atDay(int dayOfMonth)` Returns a date formed from this year-month at the specified day-of-month.
`int`	`compareTo(YearMonth other)` Compares this year-month to another year-month.
`Temporal`	`doWithAdjustment(Temporal temporal)` Implementation of the strategy to make an adjustment to the specified temporal object.
`boolean`	`equals(java.lang.Object obj)` Checks if this year-month is equal to another year-month.
`static YearMonth`	`from(TemporalAccessor temporal)` Obtains an instance of `YearMonth` from a temporal object.
`long`	`getLong(TemporalField field)` Gets the value of the specified field as a `Long`.
`Month`	`getMonth()` Gets the month-of-year field using the `Month` enum.
`int`	`getYear()` Gets the year field.
`int`	`hashCode()` A hash code for this year-month.
`boolean`	`isAfter(YearMonth other)` Is this year-month after the specified year-month.
`boolean`	`isBefore(YearMonth other)` Is this year-month before the specified year-month.
`boolean`	`isLeapYear()` Checks if the year is a leap year, according to the ISO proleptic calendar system rules.
`boolean`	`isSupported(TemporalField field)` Checks if the specified field is supported.
`boolean`	`isValidDay(int dayOfMonth)` Checks if the day-of-month is valid for this year-month.
`int`	`lengthOfMonth()` Returns the length of the month, taking account of the year.
`int`	`lengthOfYear()` Returns the length of the year.
`YearMonth`	`minus(long amountToSubtract, TemporalUnit unit)` Returns an object of the same type as this object with the specified period subtracted.
`YearMonth`	`minus(Temporal.MinusAdjuster adjuster)` Returns a copy of this year-month with the specified period subtracted.
`YearMonth`	`minusMonths(long monthsToSubtract)` Returns a copy of this year-month with the specified period in months subtracted.
`YearMonth`	`minusYears(long yearsToSubtract)` Returns a copy of this year-month with the specified period in years subtracted.
`static YearMonth`	`now()` Obtains the current year-month from the system clock in the default time-zone.
`static YearMonth`	`now(Clock clock)` Obtains the current year-month from the specified clock.
`static YearMonth`	`now(ZoneId zone)` Obtains the current year-month from the system clock in the specified time-zone.
`static YearMonth`	`of(int year, int month)` Obtains an instance of `YearMonth` from a year and month.
`static YearMonth`	`of(int year, Month month)` Obtains an instance of `YearMonth` from a year and month.
`static YearMonth`	`parse(java.lang.CharSequence text)` Obtains an instance of `YearMonth` from a text string such as `2007-12`.
`static YearMonth`	`parse(java.lang.CharSequence text, DateTimeFormatter formatter)` Obtains an instance of `YearMonth` from a text string using a specific formatter.
`long`	`periodUntil(Temporal endDateTime, TemporalUnit unit)` Calculates the period from this date-time until the given date-time in the specified unit.
`YearMonth`	`plus(long amountToAdd, TemporalUnit unit)` Returns an object of the same type as this object with the specified period added.
`YearMonth`	`plus(Temporal.PlusAdjuster adjuster)` Returns a copy of this year-month with the specified period added.
`YearMonth`	`plusMonths(long monthsToAdd)` Returns a copy of this year-month with the specified period in months added.
`YearMonth`	`plusYears(long yearsToAdd)` Returns a copy of this year-month with the specified period in years added.
`<R> R`	`query(TemporalAccessor.Query<R> query)` Queries this date-time.
`ValueRange`	`range(TemporalField field)` Gets the range of valid values for the specified field.
`java.lang.String`	`toString()` Outputs this year-month as a `String`, such as `2007-12`.
`java.lang.String`	`toString(DateTimeFormatter formatter)` Outputs this year-month as a `String` using the formatter.
`YearMonth`	`with(Temporal.WithAdjuster adjuster)` Returns an adjusted year-month based on this year-month.
`YearMonth`	`with(TemporalField field, long newValue)` Returns an object of the same type as this object with the specified field altered.
`YearMonth`	`withMonth(int month)` Returns a copy of this `YearMonth` with the month-of-year altered.
`YearMonth`	`withYear(int year)` Returns a copy of this `YearMonth` with the year altered.

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

Methods inherited from interface javax.time.temporal.TemporalAccessor
get

- Method Detail
  - now
```
public static YearMonth now()
```
    Obtains the current year-month from the system clock in the default time-zone.
    This will query the system clock in the default time-zone to obtain the current year-month. The zone and offset will be set based on the time-zone in the clock.
    Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
    
    Returns:
    the current year-month using the system clock and default time-zone, not null
  - now
```
public static YearMonth now(ZoneId zone)
```
    Obtains the current year-month from the system clock in the specified time-zone.
    This will query the system clock to obtain the current year-month. Specifying the time-zone avoids dependence on the default time-zone.
    Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
    
    Returns:
    the current year-month using the system clock, not null
  - now
```
public static YearMonth now(Clock clock)
```
    Obtains the current year-month from the specified clock.
    This will query the specified clock to obtain the current year-month. Using this method allows the use of an alternate clock for testing. The alternate clock may be introduced using dependency injection.
    
    Parameters:
    clock - the clock to use, not null
    
    Returns:
    the current year-month, not null
  - of
```
public static YearMonth of(int year,
           Month month)
```
    Obtains an instance of YearMonth from a year and month.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    month - the month-of-year to represent, not null
    
    Returns:
    the year-month, not null
    
    Throws:
    
    DateTimeException - if the year value is invalid
  - of
```
public static YearMonth of(int year,
           int month)
```
    Obtains an instance of YearMonth from a year and month.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    month - the month-of-year to represent, from 1 (January) to 12 (December)
    
    Returns:
    the year-month, not null
    
    Throws:
    
    DateTimeException - if either field value is invalid
  - from
```
public static YearMonth from(TemporalAccessor temporal)
```
    Obtains an instance of YearMonth from a temporal object.
    A TemporalAccessor represents some form of date and time information. This factory converts the arbitrary temporal object to an instance of YearMonth.
    The conversion extracts the year and month-of-year fields. The extraction is only permitted if the date-time has an ISO chronology.
    
    Parameters:
    temporal - the temporal object to convert, not null
    
    Returns:
    the year-month, not null
    
    Throws:
    
    DateTimeException - if unable to convert to a YearMonth
  - parse
```
public static YearMonth parse(java.lang.CharSequence text)
```
    Obtains an instance of YearMonth from a text string such as 2007-12.
    The string must represent a valid year-month. The format must be yyyy-MM. Years outside the range 0000 to 9999 must be prefixed by the plus or minus symbol.
    
    Parameters:
    text - the text to parse such as "2007-12", not null
    
    Returns:
    the parsed year-month, not null
    
    Throws:
    
    DateTimeParseException - if the text cannot be parsed
  - parse
```
public static YearMonth parse(java.lang.CharSequence text,
              DateTimeFormatter formatter)
```
    Obtains an instance of YearMonth from a text string using a specific formatter.
    The text is parsed using the formatter, returning a year-month.
    
    Parameters:
    text - the text to parse, not null
    formatter - the formatter to use, not null
    
    Returns:
    the parsed year-month, not null
    
    Throws:
    
    DateTimeParseException - if the text cannot be parsed
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    Description copied from interface: TemporalAccessor
    
    Checks if the specified field is supported.
    This checks if the date-time can be queried for the specified field. If false, then calling the range and get methods will throw an exception.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doRange method on the specified field.
    
    Specified by:
    
    isSupported in interface TemporalAccessor
    
    Parameters:
    field - the field to check, null returns false
    
    Returns:
    true if this date-time can be queried for the field, false if not
  - range
```
public ValueRange range(TemporalField field)
```
    Description copied from interface: TemporalAccessor
    
    Gets the range of valid values for the specified field.
    All fields can be expressed as a long integer. This method returns an object that describes the valid range for that value. If the date-time cannot return the range, because the field is unsupported or for some other reason, an exception will be thrown.
    Note that the result only describes the minimum and maximum valid values and it is important not to read too much into them. For example, there could be values within the range that are invalid for the field.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doRange method on the specified field.
    This default implementation checks the field to determine if it is a ChronoField. If the field is, then if it is supported the TemporalField.range() method is used, otherwise an exception is thrown. If it is not a ChronoField then TemporalField.doRange(TemporalAccessor) is called.
    
    Specified by:
    
    range in interface TemporalAccessor
    
    Parameters:
    field - the field to get, not null
    
    Returns:
    the range of valid values for the field, not null
  - getLong
```
public long getLong(TemporalField field)
```
    Description copied from interface: TemporalAccessor
    
    Gets the value of the specified field as a Long.
    This queries the date-time for the value for the specified field. The returned value may be outside the valid range of values for the field. If the date-time cannot return the value, because the field is unsupported or for some other reason, an exception will be thrown.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doGet method on the specified field.
    
    Specified by:
    
    getLong in interface TemporalAccessor
    
    Parameters:
    field - the field to get, not null
    
    Returns:
    the value for the field
  - getYear
```
public int getYear()
```
    Gets the year field.
    This method returns the primitive int value for the year.
    The year returned by this method is proleptic as per get(YEAR).
    
    Returns:
    the year, from MIN_YEAR to MAX_YEAR
  - getMonth
```
public Month getMonth()
```
    Gets the month-of-year field using the Month enum.
    This method returns the enum Month for the month. This avoids confusion as to what int values mean. If you need access to the primitive int value then the enum provides the int value.
    
    Returns:
    the month-of-year, not null
  - isLeapYear
```
public boolean isLeapYear()
```
    Checks if the year is a leap year, according to the ISO proleptic calendar system rules.
    This method applies the current rules for leap years across the whole time-line. In general, a year is a leap year if it is divisible by four without remainder. However, years divisible by 100, are not leap years, with the exception of years divisible by 400 which are.
    For example, 1904 is a leap year it is divisible by 4. 1900 was not a leap year as it is divisible by 100, however 2000 was a leap year as it is divisible by 400.
    The calculation is proleptic - applying the same rules into the far future and far past. This is historically inaccurate, but is correct for the ISO-8601 standard.
    
    Returns:
    true if the year is leap, false otherwise
  - lengthOfMonth
```
public int lengthOfMonth()
```
    Returns the length of the month, taking account of the year.
    This returns the length of the month in days. For example, a date in January would return 31.
    
    Returns:
    the length of the month in days, from 28 to 31
  - lengthOfYear
```
public int lengthOfYear()
```
    Returns the length of the year.
    This returns the length of the year in days, either 365 or 366.
    
    Returns:
    366 if the year is leap, 365 otherwise
  - with
```
public YearMonth with(Temporal.WithAdjuster adjuster)
```
    Returns an adjusted year-month based on this year-month.
    This adjusts the year-month according to the rules of the specified adjuster. A simple adjuster might simply set the one of the fields, such as the year field. A more complex adjuster might set the year-month to the next month that Halley's comet will pass the Earth.
    In addition, all principal classes implement the Temporal.WithAdjuster interface, including this one. For example, Month implements the adjuster interface. As such, this code will compile and run:
```
  yearMonth.with(month);
 
```
    This instance is immutable and unaffected by this method call.
    Specified by:
    
    with in interface Temporal
    
    Parameters:
    adjuster - the adjuster to use, not null
    
    Returns:
    a YearMonth based on this year-month with the adjustment made, not null
    
    Throws:
    
    DateTimeException - if the adjustment cannot be made
  - with
```
public YearMonth with(TemporalField field,
             long newValue)
```
    Description copied from interface: Temporal
    
    Returns an object of the same type as this object with the specified field altered.
    This returns a new object based on this one with the value for the specified field changed. For example, on a LocalDate, this could be used to set the year, month or day-of-month. The returned object will have the same observable type as this object.
    In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st January, then changing the month to February would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doWith method on the specified field.
    The target object must not be altered by this method. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
    
    Specified by:
    
    with in interface Temporal
    
    Parameters:
    field - the field to set in the result, not null
    newValue - the new value of the field in the result
    
    Returns:
    an object of the same type with the specified field set, not null
  - withYear
```
public YearMonth withYear(int year)
```
    Returns a copy of this YearMonth with the year altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    year - the year to set in the returned year-month, from MIN_YEAR to MAX_YEAR
    
    Returns:
    a YearMonth based on this year-month with the requested year, not null
    
    Throws:
    
    DateTimeException - if the year value is invalid
  - withMonth
```
public YearMonth withMonth(int month)
```
    Returns a copy of this YearMonth with the month-of-year altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    month - the month-of-year to set in the returned year-month, from 1 (January) to 12 (December)
    
    Returns:
    a YearMonth based on this year-month with the requested month, not null
    
    Throws:
    
    DateTimeException - if the month-of-year value is invalid
  - plus
```
public YearMonth plus(Temporal.PlusAdjuster adjuster)
```
    Returns a copy of this year-month with the specified period added.
    This method returns a new year-month based on this year-month with the specified period added. The adjuster is typically Period but may be any other type implementing the Temporal.PlusAdjuster interface. The calculation is delegated to the specified adjuster, which typically calls back to plus(long, TemporalUnit).
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    plus in interface Temporal
    
    Parameters:
    adjuster - the adjuster to use, not null
    
    Returns:
    a YearMonth based on this year-month with the addition made, not null
    
    Throws:
    
    DateTimeException - if the addition cannot be made
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - plus
```
public YearMonth plus(long amountToAdd,
             TemporalUnit unit)
```
    Description copied from interface: Temporal
    
    Returns an object of the same type as this object with the specified period added.
    This method returns a new object based on this one with the specified period added. For example, on a LocalDate, this could be used to add a number of years, months or days. The returned object will have the same observable type as this object.
    In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st January, then adding one month would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example.
    If the implementation represents a date-time that has boundaries, such as LocalTime, then the permitted units must include the boundary unit, but no multiples of the boundary unit. For example, LocalTime must accept DAYS but not WEEKS or MONTHS.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doPlus method on the specified unit.
    The target object must not be altered by this method. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
    
    Specified by:
    
    plus in interface Temporal
    
    Parameters:
    amountToAdd - the amount of the specified unit to add, may be negative
    unit - the unit of the period to add, not null
    
    Returns:
    an object of the same type with the specified period added, not null
  - plusYears
```
public YearMonth plusYears(long yearsToAdd)
```
    Returns a copy of this year-month with the specified period in years added.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    yearsToAdd - the years to add, may be negative
    
    Returns:
    a YearMonth based on this year-month with the years added, not null
    
    Throws:
    
    DateTimeException - if the result exceeds the supported range
  - plusMonths
```
public YearMonth plusMonths(long monthsToAdd)
```
    Returns a copy of this year-month with the specified period in months added.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    monthsToAdd - the months to add, may be negative
    
    Returns:
    a YearMonth based on this year-month with the months added, not null
    
    Throws:
    
    DateTimeException - if the result exceeds the supported range
  - minus
```
public YearMonth minus(Temporal.MinusAdjuster adjuster)
```
    Returns a copy of this year-month with the specified period subtracted.
    This method returns a new year-month based on this year-month with the specified period subtracted. The adjuster is typically Period but may be any other type implementing the Temporal.MinusAdjuster interface. The calculation is delegated to the specified adjuster, which typically calls back to minus(long, TemporalUnit).
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    minus in interface Temporal
    
    Parameters:
    adjuster - the adjuster to use, not null
    
    Returns:
    a YearMonth based on this year-month with the subtraction made, not null
    
    Throws:
    
    DateTimeException - if the subtraction cannot be made
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - minus
```
public YearMonth minus(long amountToSubtract,
              TemporalUnit unit)
```
    Description copied from interface: Temporal
    
    Returns an object of the same type as this object with the specified period subtracted.
    This method returns a new object based on this one with the specified period subtracted. For example, on a LocalDate, this could be used to subtract a number of years, months or days. The returned object will have the same observable type as this object.
    In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st March, then subtracting one month would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example.
    If the implementation represents a date-time that has boundaries, such as LocalTime, then the permitted units must include the boundary unit, but no multiples of the boundary unit. For example, LocalTime must accept DAYS but not WEEKS or MONTHS.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doPlus method on the specified unit.
    The target object must not be altered by this method. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
    This default implementation invokes Temporal.plus(long, TemporalUnit) with the amount negated, handling MIN_VALUE.
    
    Specified by:
    
    minus in interface Temporal
    
    Parameters:
    amountToSubtract - the amount of the specified unit to subtract, may be negative
    unit - the unit of the period to subtract, not null
    
    Returns:
    an object of the same type with the specified period subtracted, not null
  - minusYears
```
public YearMonth minusYears(long yearsToSubtract)
```
    Returns a copy of this year-month with the specified period in years subtracted.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    yearsToSubtract - the years to subtract, may be negative
    
    Returns:
    a YearMonth based on this year-month with the years subtracted, not null
    
    Throws:
    
    DateTimeException - if the result exceeds the supported range
  - minusMonths
```
public YearMonth minusMonths(long monthsToSubtract)
```
    Returns a copy of this year-month with the specified period in months subtracted.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    monthsToSubtract - the months to subtract, may be negative
    
    Returns:
    a YearMonth based on this year-month with the months subtracted, not null
    
    Throws:
    
    DateTimeException - if the result exceeds the supported range
  - isValidDay
```
public boolean isValidDay(int dayOfMonth)
```
    Checks if the day-of-month is valid for this year-month.
    This method checks whether this year and month and the input day form a valid date.
    
    Parameters:
    dayOfMonth - the day-of-month to validate, from 1 to 31, invalid value returns false
    
    Returns:
    true if the day is valid for this year-month
  - atDay
```
public LocalDate atDay(int dayOfMonth)
```
    Returns a date formed from this year-month at the specified day-of-month.
    This combines this year-month and the specified day-of-month to form a LocalDate. The day-of-month value must be valid for the year-month.
    This method can be used as part of a chain to produce a date:
```
  LocalDate date = year.atMonth(month).atDay(day);
 
```
    This instance is immutable and unaffected by this method call.
    Parameters:
    dayOfMonth - the day-of-month to use, from 1 to 31
    
    Returns:
    the date formed from this year-month and the specified day, not null
    
    Throws:
    
    DateTimeException - when the day is invalid for the year-month
    See Also:
    isValidDay(int)
  - query
```
public <R> R query(TemporalAccessor.Query<R> query)
```
    Description copied from interface: TemporalAccessor
    Queries this date-time.
    This queries this date-time using the specified query strategy object. The Query interface defines a number of useful queries. Other queries may be defined by applications.
    Implementation notes
    Queries are used for two purposes - general application specific logic, and providing a way to query those parts of a TemporalAccessor that cannot be returned as a long using a field.
    In use, there is no difference between the two purposes. However, there is a difference in implementation. It is the responsibility of implementations of this method to return a value for the three special constants if applicable.
    The three special predefined constants are TemporalAccessor.Query.ZONE_ID, TemporalAccessor.Query.CHRONO and TemporalAccessor.Query.TIME_PRECISION. Future JDKs are permitted to add further special constants.
    The standard implementation of this method will be similar to the following:
```
   public <R> R query(Query<R> type) {
     // only include an if statement if the implementation can return it
     if (query == Query.ZONE_ID)  return ... // the ZoneId
     if (query == Query.CHRONO)  return ... // the Chrono
     if (query == Query.TIME_PRECISION) return ... // the precision
     // call default method
     return super.query(query);
   }
 
```
    If the implementation class has no zone, chronology or precision, then the class can rely totally on the default implementation.
    This default implementation invokes TemporalAccessor.Query.doQuery(TemporalAccessor).
    Specified by:
    
    query in interface TemporalAccessor
    
    Type Parameters:
    R - the type of the result
    Parameters:
    query - the query to invoke, not null
    
    Returns:
    the query result, null may be returned (defined by the query)
  - doWithAdjustment
```
public Temporal doWithAdjustment(Temporal temporal)
```
    Implementation of the strategy to make an adjustment to the specified temporal object.
    This method is not intended to be called by application code directly. Applications should use the with(WithAdjuster) method on the temporal object to make the adjustment passing this as the argument.
    This instance is immutable and unaffected by this method call.
    Implementation notes
    Adjusts the specified date-time to have the value of this year-month. The temporal object must use the ISO calendar system. The adjustment is equivalent to using Temporal.with(TemporalField, long) passing EPOCH_MONTH as the field.
    
    Specified by:
    
    doWithAdjustment in interface Temporal.WithAdjuster
    
    Parameters:
    temporal - the target object to be adjusted, not null
    
    Returns:
    the adjusted object, not null
  - periodUntil
```
public long periodUntil(Temporal endDateTime,
               TemporalUnit unit)
```
    Description copied from interface: Temporal
    Calculates the period from this date-time until the given date-time in the specified unit.
    This is used to calculate the period between two date-times. This method operates in association with TemporalUnit.between(R, R). That method returns an object which can be used directly in addition/subtraction whereas this method returns the amount directly:
```
   long period = start.periodUntil(end, MONTHS);          // this method
   long period = MONTHS.between(start, end).getAmount();  // same as above
   dateTime.plus(MONTHS.between(start, end));             // directly add
 
```
    Specified by:
    
    periodUntil in interface Temporal
    
    Parameters:
    endDateTime - the end date-time, of the same type as this object, not null
    unit - the unit to measure the period in, not null
    
    Returns:
    the amount of the period between this and the end
  - compareTo
```
public int compareTo(YearMonth other)
```
    Compares this year-month to another year-month.
    The comparison is based first on the value of the year, then on the value of the month. It is "consistent with equals", as defined by Comparable.
    
    Specified by:
    
    compareTo in interface java.lang.Comparable<YearMonth>
    
    Parameters:
    other - the other year-month to compare to, not null
    
    Returns:
    the comparator value, negative if less, positive if greater
  - isAfter
```
public boolean isAfter(YearMonth other)
```
    Is this year-month after the specified year-month.
    
    Parameters:
    other - the other year-month to compare to, not null
    
    Returns:
    true if this is after the specified year-month
  - isBefore
```
public boolean isBefore(YearMonth other)
```
    Is this year-month before the specified year-month.
    
    Parameters:
    other - the other year-month to compare to, not null
    
    Returns:
    true if this point is before the specified year-month
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Checks if this year-month is equal to another year-month.
    The comparison is based on the time-line position of the year-months.
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    obj - the object to check, null returns false
    
    Returns:
    true if this is equal to the other year-month
    See Also:
    Object.hashCode(), HashMap
  - hashCode
```
public int hashCode()
```
    A hash code for this year-month.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    a suitable hash code
    See Also:
    Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)
  - toString
```
public java.lang.String toString()
```
    Outputs this year-month as a String, such as 2007-12.
    The output will be in the format yyyy-MM:
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    a string representation of this year-month, not null
  - toString
```
public java.lang.String toString(DateTimeFormatter formatter)
```
    Outputs this year-month as a String using the formatter.
    
    Parameters:
    formatter - the formatter to use, not null
    
    Returns:
    the formatted year-month string, not null
    
    Throws:
    
    DateTimeException - if an error occurs during printing

Class YearMonth

Implementation notes

Nested Class Summary

Nested classes/interfaces inherited from interface javax.time.temporal.Temporal

Nested classes/interfaces inherited from interface javax.time.temporal.TemporalAccessor

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface javax.time.temporal.TemporalAccessor

Method Detail

now

now

now

of

of

from

parse

parse

isSupported

Implementation notes

range

Implementation notes

getLong

Implementation notes

getYear

getMonth

isLeapYear

lengthOfMonth

lengthOfYear

with

with

Implementation notes

withYear

withMonth

plus

plus

Implementation notes

plusYears

plusMonths

minus

minus

Implementation notes

minusYears

minusMonths

isValidDay

atDay

query

Implementation notes

doWithAdjustment

Implementation notes

periodUntil

compareTo

isAfter

isBefore

equals

hashCode

toString

toString