public final class YearMonth extends java.lang.Object implements Temporal, TemporalAdjuster, java.lang.Comparable<YearMonth>, java.io.Serializable
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 today's rules for leap years are applied for all time. For most applications written today, the ISO-8601 rules are entirely suitable. However, any application that makes use of historical dates, and requires them to be accurate will find the ISO-8601 approach unsuitable.
Modifier and Type | Method and Description |
---|---|
Temporal |
adjustInto(Temporal temporal)
Adjusts the specified temporal object to have this year-month.
|
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.
|
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. |
int |
get(TemporalField field)
Gets the value of the specified field from this year-month as an
int . |
long |
getLong(TemporalField field)
Gets the value of the specified field from this year-month 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(TemporalSubtractor subtractor)
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 endYearMonth,
TemporalUnit unit)
Calculates the period between this year-month and another year-month in
terms of 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(TemporalAdder adder)
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(TemporalQuery<R> query)
Queries this year-month using the specified query.
|
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(TemporalAdjuster adjuster)
Returns an adjusted copy of this year-month.
|
YearMonth |
with(TemporalField field,
long newValue)
Returns a copy of this year-month with the specified field set to a new value.
|
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. |
public static YearMonth now()
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.
public static YearMonth now(ZoneId 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.
zone
- the zone ID to use, not nullpublic static YearMonth now(Clock 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
.
clock
- the clock to use, not nullpublic static YearMonth of(int year, Month month)
YearMonth
from a year and month.year
- the year to represent, from MIN_YEAR to MAX_YEARmonth
- the month-of-year to represent, not nullDateTimeException
- if the year value is invalidpublic static YearMonth of(int year, int month)
YearMonth
from a year and month.year
- the year to represent, from MIN_YEAR to MAX_YEARmonth
- the month-of-year to represent, from 1 (January) to 12 (December)DateTimeException
- if either field value is invalidpublic static YearMonth from(TemporalAccessor temporal)
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 temporal object has an ISO
chronology, or can be converted to a LocalDate
.
This method matches the signature of the functional interface TemporalQuery
allowing it to be used in queries via method reference, YearMonth::from
.
temporal
- the temporal object to convert, not nullDateTimeException
- if unable to convert to a YearMonth
public static YearMonth parse(java.lang.CharSequence text)
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.
text
- the text to parse such as "2007-12", not nullDateTimeParseException
- if the text cannot be parsedpublic static YearMonth parse(java.lang.CharSequence text, DateTimeFormatter formatter)
YearMonth
from a text string using a specific formatter.
The text is parsed using the formatter, returning a year-month.
text
- the text to parse, not nullformatter
- the formatter to use, not nullDateTimeParseException
- if the text cannot be parsedpublic boolean isSupported(TemporalField field)
This checks if this year-month can be queried for the specified field.
If false, then calling the range
and
get
methods will throw an exception.
If the field is a ChronoField
then the query is implemented here.
The supported fields
will return valid
values based on this date-time.
The supported fields are:
MONTH_OF_YEAR
EPOCH_MONTH
YEAR_OF_ERA
YEAR
ERA
ChronoField
instances will return false.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.doIsSupported(TemporalAccessor)
passing this
as the argument.
Whether the field is supported is determined by the field.
isSupported
in interface TemporalAccessor
field
- the field to check, null returns falsepublic ValueRange range(TemporalField field)
The range object expresses the minimum and maximum valid values for a field. This year-month is used to enhance the accuracy of the returned range. If it is not possible to return the range, because the field is not supported or for some other reason, an exception is thrown.
If the field is a ChronoField
then the query is implemented here.
The supported fields
will return
appropriate range instances.
All other ChronoField
instances will throw a DateTimeException
.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.doRange(TemporalAccessor)
passing this
as the argument.
Whether the range can be obtained is determined by the field.
range
in interface TemporalAccessor
field
- the field to query the range for, not nullDateTimeException
- if the range for the field cannot be obtainedpublic int get(TemporalField field)
int
.
This queries this year-month for the value for the specified field. The returned value will always be within the valid range of values for the field. If it is not possible to return the value, because the field is not supported or for some other reason, an exception is thrown.
If the field is a ChronoField
then the query is implemented here.
The supported fields
will return valid
values based on this year-month, except EPOCH_MONTH
which is too
large to fit in an int
and throw a DateTimeException
.
All other ChronoField
instances will throw a DateTimeException
.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.doGet(TemporalAccessor)
passing this
as the argument. Whether the value can be obtained,
and what the value represents, is determined by the field.
get
in interface TemporalAccessor
field
- the field to get, not nullDateTimeException
- if a value for the field cannot be obtainedjava.lang.ArithmeticException
- if numeric overflow occurspublic long getLong(TemporalField field)
long
.
This queries this year-month for the value for the specified field. If it is not possible to return the value, because the field is not supported or for some other reason, an exception is thrown.
If the field is a ChronoField
then the query is implemented here.
The supported fields
will return valid
values based on this year-month.
All other ChronoField
instances will throw a DateTimeException
.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.doGet(TemporalAccessor)
passing this
as the argument. Whether the value can be obtained,
and what the value represents, is determined by the field.
getLong
in interface TemporalAccessor
field
- the field to get, not nullDateTimeException
- if a value for the field cannot be obtainedjava.lang.ArithmeticException
- if numeric overflow occurspublic int getYear()
This method returns the primitive int
value for the year.
The year returned by this method is proleptic as per get(YEAR)
.
public Month getMonth()
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
.
public boolean isLeapYear()
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.
public boolean isValidDay(int dayOfMonth)
This method checks whether this year and month and the input day form a valid date.
dayOfMonth
- the day-of-month to validate, from 1 to 31, invalid value returns falsepublic int lengthOfMonth()
This returns the length of the month in days. For example, a date in January would return 31.
public int lengthOfYear()
This returns the length of the year in days, either 365 or 366.
public YearMonth with(TemporalAdjuster adjuster)
This returns a new YearMonth
, based on this one, with the year-month adjusted.
The adjustment takes place using the specified adjuster strategy object.
Read the documentation of the adjuster to understand what adjustment will be made.
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.
The result of this method is obtained by invoking the
TemporalAdjuster.adjustInto(Temporal)
method on the
specified adjuster passing this
as the argument.
This instance is immutable and unaffected by this method call.
with
in interface Temporal
adjuster
- the adjuster to use, not nullYearMonth
based on this
with the adjustment made, not nullDateTimeException
- if the adjustment cannot be madejava.lang.ArithmeticException
- if numeric overflow occurspublic YearMonth with(TemporalField field, long newValue)
This returns a new YearMonth
, based on this one, with the value
for the specified field changed.
This can be used to change any supported field, such as the year or month.
If it is not possible to set the value, because the field is not supported or for
some other reason, an exception is thrown.
If the field is a ChronoField
then the adjustment is implemented here.
The supported fields behave as follows:
MONTH_OF_YEAR
-
Returns a YearMonth
with the specified month-of-year.
The year will be unchanged.
EPOCH_MONTH
-
Returns a YearMonth
with the specified epoch-month.
This completely replaces the year and month of this object.
YEAR_OF_ERA
-
Returns a YearMonth
with the specified year-of-era
The month and era will be unchanged.
YEAR
-
Returns a YearMonth
with the specified year.
The month will be unchanged.
ERA
-
Returns a YearMonth
with the specified era.
The month and year-of-era will be unchanged.
In all cases, if the new value is outside the valid range of values for the field
then a DateTimeException
will be thrown.
All other ChronoField
instances will throw a DateTimeException
.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.doWith(Temporal, long)
passing this
as the argument. In this case, the field determines
whether and how to adjust the instant.
This instance is immutable and unaffected by this method call.
with
in interface Temporal
field
- the field to set in the result, not nullnewValue
- the new value of the field in the resultYearMonth
based on this
with the specified field set, not nullDateTimeException
- if the field cannot be setjava.lang.ArithmeticException
- if numeric overflow occurspublic YearMonth withYear(int year)
YearMonth
with the year altered.
This instance is immutable and unaffected by this method call.
year
- the year to set in the returned year-month, from MIN_YEAR to MAX_YEARYearMonth
based on this year-month with the requested year, not nullDateTimeException
- if the year value is invalidpublic YearMonth withMonth(int month)
YearMonth
with the month-of-year altered.
This instance is immutable and unaffected by this method call.
month
- the month-of-year to set in the returned year-month, from 1 (January) to 12 (December)YearMonth
based on this year-month with the requested month, not nullDateTimeException
- if the month-of-year value is invalidpublic YearMonth plus(TemporalAdder adder)
This method returns a new year-month based on this year-month with the specified period added.
The adder is typically Period
but may be any other type implementing
the TemporalAdder
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.
plus
in interface Temporal
adder
- the adder to use, not nullYearMonth
based on this year-month with the addition made, not nullDateTimeException
- if the addition cannot be madejava.lang.ArithmeticException
- if numeric overflow occurspublic YearMonth plus(long amountToAdd, TemporalUnit unit)
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
.
ChronoUnit
.
If the unit is supported, then the addition must be performed.
If unsupported, then a DateTimeException
must be thrown.
If the unit is not a ChronoUnit
, then the result of this method
is obtained by invoking TemporalUnit.doPlus(Temporal, long)
passing this
as the first argument.
Implementations must not alter either this object or the specified temporal object. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
plus
in interface Temporal
amountToAdd
- the amount of the specified unit to add, may be negativeunit
- the unit of the period to add, not nullDateTimeException
- if the unit cannot be addedjava.lang.ArithmeticException
- if numeric overflow occurspublic YearMonth plusYears(long yearsToAdd)
This instance is immutable and unaffected by this method call.
yearsToAdd
- the years to add, may be negativeYearMonth
based on this year-month with the years added, not nullDateTimeException
- if the result exceeds the supported rangepublic YearMonth plusMonths(long monthsToAdd)
This instance is immutable and unaffected by this method call.
monthsToAdd
- the months to add, may be negativeYearMonth
based on this year-month with the months added, not nullDateTimeException
- if the result exceeds the supported rangepublic YearMonth minus(TemporalSubtractor subtractor)
This method returns a new year-month based on this year-month with the specified period subtracted.
The subtractor is typically Period
but may be any other type implementing
the TemporalSubtractor
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.
minus
in interface Temporal
subtractor
- the subtractor to use, not nullYearMonth
based on this year-month with the subtraction made, not nullDateTimeException
- if the subtraction cannot be madejava.lang.ArithmeticException
- if numeric overflow occurspublic YearMonth minus(long amountToSubtract, TemporalUnit unit)
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
.
Implementations must not alter either this object or the specified temporal object. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
The default implementation must behave equivalent to this code:
return (amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit) : plus(-amountToSubtract, unit));
minus
in interface Temporal
amountToSubtract
- the amount of the specified unit to subtract, may be negativeunit
- the unit of the period to subtract, not nullDateTimeException
- if the unit cannot be subtractedjava.lang.ArithmeticException
- if numeric overflow occurspublic YearMonth minusYears(long yearsToSubtract)
This instance is immutable and unaffected by this method call.
yearsToSubtract
- the years to subtract, may be negativeYearMonth
based on this year-month with the years subtracted, not nullDateTimeException
- if the result exceeds the supported rangepublic YearMonth minusMonths(long monthsToSubtract)
This instance is immutable and unaffected by this method call.
monthsToSubtract
- the months to subtract, may be negativeYearMonth
based on this year-month with the months subtracted, not nullDateTimeException
- if the result exceeds the supported rangepublic <R> R query(TemporalQuery<R> query)
This queries this year-month using the specified query strategy object.
The TemporalQuery
object defines the logic to be used to
obtain the result. Read the documentation of the query to understand
what the result of this method will be.
The result of this method is obtained by invoking the
TemporalQuery.queryFrom(TemporalAccessor)
method on the
specified query passing this
as the argument.
query
in interface TemporalAccessor
R
- the type of the resultquery
- the query to invoke, not nullDateTimeException
- if unable to query (defined by the query)java.lang.ArithmeticException
- if numeric overflow occurs (defined by the query)public Temporal adjustInto(Temporal temporal)
This returns a temporal object of the same observable type as the input with the year and month changed to be the same as this.
The adjustment is equivalent to using Temporal.with(TemporalField, long)
passing ChronoField.EPOCH_MONTH
as the field.
If the specified temporal object does not use the ISO calendar system then
a DateTimeException
is thrown.
In most cases, it is clearer to reverse the calling pattern by using
Temporal.with(TemporalAdjuster)
:
// these two lines are equivalent, but the second approach is recommended temporal = thisYearMonth.adjustInto(temporal); temporal = temporal.with(thisYearMonth);
This instance is immutable and unaffected by this method call.
adjustInto
in interface TemporalAdjuster
temporal
- the target object to be adjusted, not nullDateTimeException
- if unable to make the adjustmentjava.lang.ArithmeticException
- if numeric overflow occurspublic long periodUntil(Temporal endYearMonth, TemporalUnit unit)
This calculates the period between two year-months in terms of a single unit.
The start and end points are this
and the specified year-month.
The result will be negative if the end is before the start.
The Temporal
passed to this method must be a YearMonth
.
For example, the period in years between two year-months can be calculated
using startYearMonth.periodUntil(endYearMonth, YEARS)
.
The calculation returns a whole number, representing the number of complete units between the two year-months. For example, the period in decades between 2012-06 and 2032-05 will only be one decade as it is one month short of two decades.
This method operates in association with TemporalUnit.between(R, R)
.
The result of this method is a long
representing the amount of
the specified unit. By contrast, the result of between
is an
object that can be used directly in addition/subtraction:
long period = start.periodUntil(end, YEARS); // this method dateTime.plus(YEARS.between(start, end)); // use in plus/minus
The calculation is implemented in this method for ChronoUnit
.
The units MONTHS
, YEARS
, DECADES
,
CENTURIES
, MILLENNIA
and ERAS
are supported.
Other ChronoUnit
values will throw an exception.
If the unit is not a ChronoUnit
, then the result of this method
is obtained by invoking TemporalUnit.between(Temporal, Temporal)
passing this
as the first argument and the input temporal as
the second argument.
This instance is immutable and unaffected by this method call.
periodUntil
in interface Temporal
endYearMonth
- the end year-month, which must be a YearMonth
, not nullunit
- the unit to measure the period in, not nullDateTimeException
- if the period cannot be calculatedjava.lang.ArithmeticException
- if numeric overflow occurspublic LocalDate atDay(int dayOfMonth)
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.
dayOfMonth
- the day-of-month to use, from 1 to 31DateTimeException
- when the day is invalid for the year-monthisValidDay(int)
public int compareTo(YearMonth other)
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
.
compareTo
in interface java.lang.Comparable<YearMonth>
other
- the other year-month to compare to, not nullpublic boolean isAfter(YearMonth other)
other
- the other year-month to compare to, not nullpublic boolean isBefore(YearMonth other)
other
- the other year-month to compare to, not nullpublic boolean equals(java.lang.Object obj)
The comparison is based on the time-line position of the year-months.
equals
in class java.lang.Object
obj
- the object to check, null returns falseObject.hashCode()
,
HashMap
public int hashCode()
hashCode
in class java.lang.Object
Object.equals(java.lang.Object)
,
System.identityHashCode(java.lang.Object)
public java.lang.String toString()
String
, such as 2007-12
.
The output will be in the format yyyy-MM
:
toString
in class java.lang.Object
public java.lang.String toString(DateTimeFormatter formatter)
String
using the formatter.
This year-month will be passed to the formatter
print method
.
formatter
- the formatter to use, not nullDateTimeException
- if an error occurs during printing