public final class OffsetDate extends Object implements Calendrical, DateProvider, CalendricalMatcher, DateAdjuster, Comparable<OffsetDate>, Serializable
2007-12-03+01:00
.
OffsetDate
is an immutable calendrical that represents a date, often viewed
as year-month-day-offset. This object can also access other date fields such as
day-of-year, day-of-week and week-of-year.
This class does not store or represent a time.
Thus, for example, the value "2nd October 2007 +02:00" can be stored
in a OffsetDate
.
OffsetDate is immutable and thread-safe.
Modifier and Type | Method and Description |
---|---|
LocalDate |
adjustDate(LocalDate date)
Adjusts a date to have the value of the date part of this object.
|
OffsetDateTime |
atMidnight()
Returns an offset date-time formed from this date at the time of midnight.
|
ZonedDateTime |
atStartOfDayInZone(TimeZone zone)
Returns a zoned date-time from this date at the earliest valid time according
to the rules in the time-zone ignoring the current offset.
|
OffsetDateTime |
atTime(int hourOfDay,
int minuteOfHour)
Returns an offset date-time formed from this date at the specified time.
|
OffsetDateTime |
atTime(int hourOfDay,
int minuteOfHour,
int secondOfMinute)
Returns an offset date-time formed from this date at the specified time.
|
OffsetDateTime |
atTime(int hourOfDay,
int minuteOfHour,
int secondOfMinute,
int nanoOfSecond)
Returns an offset date-time formed from this date at the specified time.
|
OffsetDateTime |
atTime(LocalTime time)
Returns an offset date-time formed from this date at the specified time.
|
OffsetDateTime |
atTime(OffsetTime time)
Returns an offset date-time formed from this date at the specified time.
|
int |
compareTo(OffsetDate other)
Compares this
OffsetDate to another date based on the UTC equivalent
dates then local date. |
boolean |
equalInstant(OffsetDate other)
Checks if the instant of midnight at the start of this
OffsetDate
equals midnight at the start of the specified date. |
boolean |
equals(Object other)
Checks if this
OffsetDate is equal to the specified date. |
<T> T |
get(CalendricalRule<T> rule)
Gets the value of the specified calendrical rule.
|
ISOChronology |
getChronology()
Gets the chronology that this date uses, which is the ISO calendar system.
|
int |
getDayOfMonth()
Gets the day-of-month field.
|
DayOfWeek |
getDayOfWeek()
Gets the day-of-week field, which is an enum
DayOfWeek . |
int |
getDayOfYear()
Gets the day-of-year field.
|
MonthOfYear |
getMonthOfYear()
Gets the month-of-year field, which is an enum
MonthOfYear . |
ZoneOffset |
getOffset()
Gets the zone offset.
|
int |
getYear()
Gets the year field.
|
int |
hashCode()
A hash code for this
OffsetDate . |
boolean |
isAfter(OffsetDate other)
Checks if the instant of midnight at the start of this
OffsetDate
is after midnight at the start of the specified date. |
boolean |
isBefore(OffsetDate other)
Checks if the instant of midnight at the start of this
OffsetDate
is before midnight at the start of the specified date. |
boolean |
isLeapYear()
Checks if the year is a leap year, according to the ISO proleptic
calendar system rules.
|
boolean |
matches(CalendricalMatcher matcher)
Checks whether this
OffsetDate matches the specified matcher. |
boolean |
matchesCalendrical(Calendrical calendrical)
Checks if the date extracted from the calendrical matches this date.
|
OffsetDate |
minus(PeriodProvider periodProvider)
Returns a copy of this
OffsetDate with the specified date period subtracted. |
OffsetDate |
minusDays(long days)
Returns a copy of this
OffsetDate with the specified number of days subtracted. |
OffsetDate |
minusMonths(long months)
Returns a copy of this
OffsetDate with the specified period in months subtracted. |
OffsetDate |
minusMonths(long months,
DateResolver dateResolver)
Returns a copy of this
OffsetDate with the specified period in months subtracted. |
OffsetDate |
minusWeeks(long weeks)
Returns a copy of this
OffsetDate with the specified period in weeks subtracted. |
OffsetDate |
minusYears(long years)
Returns a copy of this
OffsetDate with the specified period in years subtracted. |
OffsetDate |
minusYears(long years,
DateResolver dateResolver)
Returns a copy of this
OffsetDate with the specified period in years subtracted. |
static OffsetDate |
now()
Obtains the current date from the system clock in the default time-zone.
|
static OffsetDate |
now(Clock clock)
Obtains the current date from the specified clock.
|
static OffsetDate |
of(DateProvider dateProvider,
ZoneOffset offset)
Obtains an instance of
OffsetDate from a date provider. |
static OffsetDate |
of(int year,
int monthOfYear,
int dayOfMonth,
ZoneOffset offset)
Obtains an instance of
OffsetDate from a year, month and day. |
static OffsetDate |
of(int year,
MonthOfYear monthOfYear,
int dayOfMonth,
ZoneOffset offset)
Obtains an instance of
OffsetDate from a year, month and day. |
static OffsetDate |
ofInstant(InstantProvider instantProvider,
ZoneOffset offset)
Obtains an instance of
OffsetDate from an InstantProvider . |
static OffsetDate |
parse(String text)
Obtains an instance of
OffsetDate from a text string such as 2007-12-03+01:00 . |
static OffsetDate |
parse(String text,
DateTimeFormatter formatter)
Obtains an instance of
OffsetDate from a text string using a specific formatter. |
OffsetDate |
plus(PeriodProvider periodProvider)
Returns a copy of this
OffsetDate with the specified date period added. |
OffsetDate |
plusDays(long days)
Returns a copy of this
OffsetDate with the specified period in days added. |
OffsetDate |
plusMonths(long months)
Returns a copy of this
OffsetDate with the specified period in months added. |
OffsetDate |
plusMonths(long months,
DateResolver dateResolver)
Returns a copy of this
OffsetDate with the specified period in months added. |
OffsetDate |
plusWeeks(long weeks)
Returns a copy of this
OffsetDate with the specified period in weeks added. |
OffsetDate |
plusYears(long years)
Returns a copy of this
OffsetDate with the specified period in years added. |
OffsetDate |
plusYears(long years,
DateResolver dateResolver)
Returns a copy of this
OffsetDate with the specified period in years added. |
static CalendricalRule<OffsetDate> |
rule()
Gets the rule for
OffsetDate . |
Instant |
toInstant()
Converts this date to an
Instant at midnight. |
LocalDate |
toLocalDate()
Converts this date to a
LocalDate . |
String |
toString()
Outputs this date as a
String , such as 2007-12-03+01:00 . |
String |
toString(DateTimeFormatter formatter)
Outputs this date as a
String using the formatter. |
OffsetDate |
with(DateAdjuster adjuster)
Returns a copy of this
OffsetDate with the date altered using the adjuster. |
OffsetDate |
with(MonthOfYear monthOfYear)
Returns a copy of this
OffsetDate with the month-of-year altered. |
OffsetDate |
with(MonthOfYear monthOfYear,
DateResolver dateResolver)
Returns a copy of this
OffsetDate with the month-of-year altered. |
OffsetDate |
withDate(DateProvider dateProvider)
Returns a copy of this
OffsetDate with a different local date. |
OffsetDate |
withDayOfMonth(int dayOfMonth)
Returns a copy of this
OffsetDate with the day-of-month altered. |
OffsetDate |
withDayOfMonth(int dayOfMonth,
DateResolver dateResolver)
Returns a copy of this
OffsetDate with the day-of-month altered. |
OffsetDate |
withDayOfYear(int dayOfYear)
Returns a copy of this
OffsetDate with the day-of-year altered. |
OffsetDate |
withMonthOfYear(int monthOfYear)
Returns a copy of this
OffsetDate with the month-of-year altered. |
OffsetDate |
withMonthOfYear(int monthOfYear,
DateResolver dateResolver)
Returns a copy of this
OffsetDate with the month-of-year altered. |
OffsetDate |
withOffset(ZoneOffset offset)
Returns a copy of this
OffsetDate with the specified offset. |
OffsetDate |
withYear(int year)
Returns a copy of this
OffsetDate with the year altered. |
OffsetDate |
withYear(int year,
DateResolver dateResolver)
Returns a copy of this
OffsetDate with the year altered. |
public static OffsetDate now()
This will query the system clock
in the default
time-zone to obtain the current date.
The offset will be calculated from 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 OffsetDate now(Clock clock)
This will query the specified clock to obtain the current date - today. The offset will be calculated from the time-zone in the clock.
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 OffsetDate of(int year, MonthOfYear monthOfYear, int dayOfMonth, ZoneOffset offset)
OffsetDate
from a year, month and day.year
- the year to represent, from MIN_YEAR to MAX_YEARmonthOfYear
- the month-of-year to represent, not nulldayOfMonth
- the day-of-month to represent, from 1 to 31offset
- the zone offset, not nullIllegalCalendarFieldValueException
- if the value of any field is out of rangeInvalidCalendarFieldException
- if the day-of-month is invalid for the month-yearpublic static OffsetDate of(int year, int monthOfYear, int dayOfMonth, ZoneOffset offset)
OffsetDate
from a year, month and day.year
- the year to represent, from MIN_YEAR to MAX_YEARmonthOfYear
- the month-of-year to represent, from 1 (January) to 12 (December)dayOfMonth
- the day-of-month to represent, from 1 to 31offset
- the zone offset, not nullIllegalCalendarFieldValueException
- if the value of any field is out of rangeInvalidCalendarFieldException
- if the day-of-month is invalid for the month-yearpublic static OffsetDate of(DateProvider dateProvider, ZoneOffset offset)
OffsetDate
from a date provider.dateProvider
- the date provider to use, not nulloffset
- the zone offset, not nullpublic static OffsetDate ofInstant(InstantProvider instantProvider, ZoneOffset offset)
OffsetDate
from an InstantProvider
.
This conversion drops the time component of the instant effectively converting at midnight at the start of the day.
instantProvider
- the instant to convert, not nulloffset
- the zone offset, not nullCalendarConversionException
- if the instant exceeds the supported date rangepublic static OffsetDate parse(String text)
OffsetDate
from a text string such as 2007-12-03+01:00
.
The following format is accepted in ASCII:
{Year}-{MonthOfYear}-{DayOfMonth}{OffsetID}
The month-of-year has 2 digits with values from 1 to 12.
The day-of-month has 2 digits with values from 1 to 31 appropriate to the month.
The offset ID is the normalized form as defined in ZoneOffset
.
text
- the text to parse such as '2007-12-03+01:00', not nullCalendricalException
- if the text cannot be parsedpublic static OffsetDate parse(String text, DateTimeFormatter formatter)
OffsetDate
from a text string using a specific formatter.
The text is parsed using the formatter, returning a date.
text
- the text to parse, not nullformatter
- the formatter to use, not nullUnsupportedOperationException
- if the formatter cannot parseCalendricalException
- if the text cannot be parsedpublic ISOChronology getChronology()
public <T> T get(CalendricalRule<T> rule)
This method queries the value of the specified calendrical rule.
If the value cannot be returned for the rule from this date then
null
will be returned.
get
in interface Calendrical
rule
- the rule to use, not nullpublic ZoneOffset getOffset()
public OffsetDate withOffset(ZoneOffset offset)
OffsetDate
with the specified offset.
This method returns an object with the same LocalDate
and the specified ZoneOffset
.
No calculation is needed or performed.
For example, if this time represents 2007-12-03+02:00
and the offset specified is
+03:00
, then this method will return 2007-12-03+03:00
.
This instance is immutable and unaffected by this method call.
offset
- the zone offset to change to, not nullOffsetDate
based on this date with the requested offset, never nullpublic int getYear()
This method returns the primitive int
value for the year.
Additional information about the year can be obtained by creating a Year
.
public MonthOfYear getMonthOfYear()
MonthOfYear
.
This method returns the enum MonthOfYear
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
.
Additional information can be obtained from the MonthOfYear
.
This includes month lengths, textual names and access to the quarter-of-year
and month-of-quarter values.
public int getDayOfMonth()
This method returns the primitive int
value for the day-of-month.
public int getDayOfYear()
This method returns the primitive int
value for the day-of-year.
public DayOfWeek getDayOfWeek()
DayOfWeek
.
This method returns the enum DayOfWeek
for the day-of-week.
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
.
Additional information can be obtained from the DayOfWeek
.
This includes textual names of the values.
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 ISO8601 standard.
public OffsetDate with(DateAdjuster adjuster)
OffsetDate
with the date altered using the adjuster.
Adjusters can be used to alter the date in various ways. A simple adjuster might simply set the one of the fields, such as the year field. A more complex adjuster might set the date to the last day of the month.
The offset does not affect the calculation and will be the same in the result.
This instance is immutable and unaffected by this method call.
adjuster
- the adjuster to use, not nullOffsetDate
based on this date adjusted as necessary, never nullNullPointerException
- if the adjuster returned nullpublic OffsetDate withDate(DateProvider dateProvider)
OffsetDate
with a different local date.
This method changes the date stored to a different date. No calculation is performed. The result simply represents the same offset and the new date.
dateProvider
- the local date to change to, not nullOffsetDate
based on this date with the requested date, never nullpublic OffsetDate withYear(int year)
OffsetDate
with the year altered.
If the resulting date is invalid, it will be resolved using DateResolvers.previousValid()
.
The offset does not affect the calculation and will be the same in the result.
This method does the same as withYear(year, DateResolvers.previousValid())
.
This instance is immutable and unaffected by this method call.
year
- the year to set in the returned date, from MIN_YEAR to MAX_YEAROffsetDate
based on this date with the requested year, never nullIllegalCalendarFieldValueException
- if the year value is invalidpublic OffsetDate withYear(int year, DateResolver dateResolver)
OffsetDate
with the year altered.
If the resulting date is invalid, it will be resolved using dateResolver
.
The offset does not affect the calculation and will be the same in the result.
This instance is immutable and unaffected by this method call.
year
- the year to set in the returned date, from MIN_YEAR to MAX_YEARdateResolver
- the DateResolver to be used if the resulting date would be invalidOffsetDate
based on this date with the requested year, never nullIllegalCalendarFieldValueException
- if the year value is invalidpublic OffsetDate withMonthOfYear(int monthOfYear)
OffsetDate
with the month-of-year altered.
If the resulting date is invalid, it will be resolved using DateResolvers.previousValid()
.
The offset does not affect the calculation and will be the same in the result.
This method does the same as withMonthOfYear(monthOfYear, DateResolvers.previousValid())
.
This instance is immutable and unaffected by this method call.
monthOfYear
- the month-of-year to set in the returned date, from 1 (January) to 12 (December)OffsetDate
based on this date with the requested month, never nullIllegalCalendarFieldValueException
- if the month-of-year value is invalidpublic OffsetDate withMonthOfYear(int monthOfYear, DateResolver dateResolver)
OffsetDate
with the month-of-year altered.
If the resulting date is invalid, it will be resolved using dateResolver
.
The offset does not affect the calculation and will be the same in the result.
This instance is immutable and unaffected by this method call.
monthOfYear
- the month-of-year to set in the returned date, from 1 (January) to 12 (December)dateResolver
- the DateResolver to be used if the resulting date would be invalidOffsetDate
based on this date with the requested month, never nullIllegalCalendarFieldValueException
- if the month-of-year value is invalidpublic OffsetDate with(MonthOfYear monthOfYear)
OffsetDate
with the month-of-year altered.
If the resulting date is invalid, it will be resolved using DateResolvers.previousValid()
.
The offset does not affect the calculation and will be the same in the result.
This method does the same as with(monthOfYear, DateResolvers.previousValid())
.
This instance is immutable and unaffected by this method call.
monthOfYear
- the month-of-year to set in the returned date, not nullOffsetDate
based on this date with the requested month, never nullpublic OffsetDate with(MonthOfYear monthOfYear, DateResolver dateResolver)
OffsetDate
with the month-of-year altered.
If the resulting date is invalid, it will be resolved using dateResolver
.
The offset does not affect the calculation and will be the same in the result.
This instance is immutable and unaffected by this method call.
monthOfYear
- the month-of-year to set in the returned date, not nulldateResolver
- the DateResolver to be used if the resulting date would be invalidOffsetDate
based on this date with the requested month, never nullpublic OffsetDate withDayOfMonth(int dayOfMonth)
OffsetDate
with the day-of-month altered.
If the resulting date is invalid, an exception is thrown.
The offset does not affect the calculation and will be the same in the result.
This instance is immutable and unaffected by this method call.
dayOfMonth
- the day-of-month to set in the returned date, from 1 to 28-31OffsetDate
based on this date with the requested day, never nullIllegalCalendarFieldValueException
- if the day-of-month value is invalidInvalidCalendarFieldException
- if the day-of-month is invalid for the month-yearpublic OffsetDate withDayOfMonth(int dayOfMonth, DateResolver dateResolver)
OffsetDate
with the day-of-month altered.
If the resulting date is invalid, it will be resolved using dateResolver
.
The offset does not affect the calculation and will be the same in the result.
This instance is immutable and unaffected by this method call.
dayOfMonth
- the day-of-month to set in the returned date, from 1 to 31dateResolver
- the DateResolver to be used if the resulting date would be invalidOffsetDate
based on this date with the requested day, never nullIllegalCalendarFieldValueException
- if the day-of-month value is invalidpublic OffsetDate withDayOfYear(int dayOfYear)
OffsetDate
with the day-of-year altered.
If the resulting date is invalid, an exception is thrown.
This instance is immutable and unaffected by this method call.
dayOfYear
- the day-of-year to set in the returned date, from 1 to 365-366OffsetDate
based on this date with the requested day, never nullIllegalCalendarFieldValueException
- if the day-of-year value is invalidInvalidCalendarFieldException
- if the day-of-year is invalid for the yearpublic OffsetDate plus(PeriodProvider periodProvider)
OffsetDate
with the specified date period added.
This adds the specified period to this date, returning a new date.
Before addition, the period is converted to a date-based Period
using
Period.ofDateFields(PeriodProvider)
.
That factory ignores any time-based ISO fields, thus adding a time-based
period to this date will have no effect. If you want to take time fields into
account, call Period.normalizedWith24HourDays()
on the input period.
The detailed rules for the addition have some complexity due to variable length months.
See LocalDate.plus(PeriodProvider)
for details.
This instance is immutable and unaffected by this method call.
periodProvider
- the period to add, not nullOffsetDate
based on this date with the period added, never nullCalendricalException
- if the specified period cannot be converted to a Period
CalendricalException
- if the result exceeds the supported date rangepublic OffsetDate plusYears(long years)
OffsetDate
with the specified period in years added.
This method adds the specified amount to the years field in three steps:
For example, 2008-02-29 (leap year) plus one year would result in the invalid date 2009-02-29 (standard year). Instead of returning an invalid result, the last valid day of the month, 2009-02-28, is selected instead.
This method does the same as plusYears(years, DateResolvers.previousValid())
.
This instance is immutable and unaffected by this method call.
years
- the years to add, may be negativeOffsetDate
based on this date with the years added, never nullCalendricalException
- if the result exceeds the supported date range#plusYears(int, javax.time.calendar.DateResolver)
public OffsetDate plusYears(long years, DateResolver dateResolver)
OffsetDate
with the specified period in years added.
This method adds the specified amount to the years field in three steps:
dateResolver
if necessaryThis instance is immutable and unaffected by this method call.
years
- the years to add, may be negativedateResolver
- the DateResolver to be used if the resulting date would be invalidOffsetDate
based on this date with the years added, never nullCalendricalException
- if the result exceeds the supported date rangepublic OffsetDate plusMonths(long months)
OffsetDate
with the specified period in months added.
This method adds the specified amount to the months field in three steps:
For example, 2007-03-31 plus one month would result in the invalid date 2007-04-31. Instead of returning an invalid result, the last valid day of the month, 2007-04-30, is selected instead.
This method does the same as plusMonths(months, DateResolvers.previousValid())
.
This instance is immutable and unaffected by this method call.
months
- the months to add, may be negativeOffsetDate
based on this date with the months added, never nullCalendricalException
- if the result exceeds the supported date range#plusMonths(int, javax.time.calendar.DateResolver)
public OffsetDate plusMonths(long months, DateResolver dateResolver)
OffsetDate
with the specified period in months added.
This method adds the specified amount to the months field in three steps:
dateResolver
if necessaryThis instance is immutable and unaffected by this method call.
months
- the months to add, may be negativedateResolver
- the DateResolver to be used if the resulting date would be invalidOffsetDate
based on this date with the months added, never nullCalendricalException
- if the result exceeds the supported date rangepublic OffsetDate plusWeeks(long weeks)
OffsetDate
with the specified period in weeks added.
This method adds the specified amount in weeks to the days field incrementing the month and year fields as necessary to ensure the result remains valid. The result is only invalid if the maximum/minimum year is exceeded.
For example, 2008-12-31 plus one week would result in 2009-01-07.
This instance is immutable and unaffected by this method call.
weeks
- the weeks to add, may be negativeOffsetDate
based on this date with the weeks added, never nullCalendricalException
- if the result exceeds the supported date rangepublic OffsetDate plusDays(long days)
OffsetDate
with the specified period in days added.
This method adds the specified amount to the days field incrementing the month and year fields as necessary to ensure the result remains valid. The result is only invalid if the maximum/minimum year is exceeded.
For example, 2008-12-31 plus one day would result in 2009-01-01.
This instance is immutable and unaffected by this method call.
days
- the days to add, may be negativeOffsetDate
based on this date with the days added, never nullCalendricalException
- if the result exceeds the supported date rangepublic OffsetDate minus(PeriodProvider periodProvider)
OffsetDate
with the specified date period subtracted.
This subtracts the specified period from this date, returning a new date.
Before subtraction, the period is converted to a date-based Period
using
Period.ofDateFields(PeriodProvider)
.
That factory ignores any time-based ISO fields, thus subtracting a time-based
period from this date will have no effect. If you want to take time fields into
account, call Period.normalizedWith24HourDays()
on the input period.
The detailed rules for the subtraction have some complexity due to variable length months.
See LocalDate.minus(PeriodProvider)
for details.
This instance is immutable and unaffected by this method call.
periodProvider
- the period to subtract, not nullOffsetDate
based on this date with the period subtracted, never nullCalendricalException
- if the specified period cannot be converted to a Period
CalendricalException
- if the result exceeds the supported date rangepublic OffsetDate minusYears(long years)
OffsetDate
with the specified period in years subtracted.
This method subtracts the specified amount from the years field in three steps:
For example, 2008-02-29 (leap year) minus one year would result in the invalid date 2007-02-29 (standard year). Instead of returning an invalid result, the last valid day of the month, 2007-02-28, is selected instead.
This method does the same as minusYears(years, DateResolvers.previousValid())
.
This instance is immutable and unaffected by this method call.
years
- the years to subtract, may be negativeOffsetDate
based on this date with the years subtracted, never nullCalendricalException
- if the result exceeds the supported date range#minusYears(int, javax.time.calendar.DateResolver)
public OffsetDate minusYears(long years, DateResolver dateResolver)
OffsetDate
with the specified period in years subtracted.
This method subtracts the specified amount from the years field in three steps:
dateResolver
if necessaryThis instance is immutable and unaffected by this method call.
years
- the years to subtract, may be negativedateResolver
- the DateResolver to be used if the resulting date would be invalidOffsetDate
based on this date with the years subtracted, never nullCalendricalException
- if the result exceeds the supported date rangepublic OffsetDate minusMonths(long months)
OffsetDate
with the specified period in months subtracted.
This method subtracts the specified amount from the months field in three steps:
For example, 2007-03-31 minus one month would result in the invalid date 2007-02-31. Instead of returning an invalid result, the last valid day of the month, 2007-02-28, is selected instead.
This method does the same as minusMonths(months, DateResolvers.previousValid())
.
This instance is immutable and unaffected by this method call.
months
- the months to subtract, may be negativeOffsetDate
based on this date with the months subtracted, never nullCalendricalException
- if the result exceeds the supported date range#minusMonths(int, javax.time.calendar.DateResolver)
public OffsetDate minusMonths(long months, DateResolver dateResolver)
OffsetDate
with the specified period in months subtracted.
This method subtracts the specified amount from the months field in three steps:
dateResolver
if necessaryThis instance is immutable and unaffected by this method call.
months
- the months to subtract, may be negativedateResolver
- the DateResolver to be used if the resulting date would be invalidOffsetDate
based on this date with the months subtracted, never nullCalendricalException
- if the result exceeds the supported date rangepublic OffsetDate minusWeeks(long weeks)
OffsetDate
with the specified period in weeks subtracted.
This method subtracts the specified amount in weeks from the days field decrementing the month and year fields as necessary to ensure the result remains valid. The result is only invalid if the maximum/minimum year is exceeded.
For example, 2009-01-07 minus one week would result in 2008-12-31.
This instance is immutable and unaffected by this method call.
weeks
- the weeks to subtract, may be negativeOffsetDate
based on this date with the weeks subtracted, never nullCalendricalException
- if the result exceeds the supported date rangepublic OffsetDate minusDays(long days)
OffsetDate
with the specified number of days subtracted.
This method subtracts the specified amount from the days field decrementing the month and year fields as necessary to ensure the result remains valid. The result is only invalid if the maximum/minimum year is exceeded.
For example, 2009-01-01 minus one day would result in 2008-12-31.
This instance is immutable and unaffected by this method call.
days
- the days to subtract, may be negativeOffsetDate
based on this date with the days subtracted, never nullCalendricalException
- if the result exceeds the supported date rangepublic boolean matches(CalendricalMatcher matcher)
OffsetDate
matches the specified matcher.
Matchers can be used to query the date. A simple matcher might simply compare one of the fields, such as the year field. A more complex matcher might check if the date is the last day of the month.
matcher
- the matcher to use, not nullpublic boolean matchesCalendrical(Calendrical calendrical)
This method implements the CalendricalMatcher
interface.
It is intended that applications use matches(javax.time.calendar.CalendricalMatcher)
rather than this method.
matchesCalendrical
in interface CalendricalMatcher
calendrical
- the calendrical to match, not nullpublic LocalDate adjustDate(LocalDate date)
This method implements the DateAdjuster
interface.
It is intended that applications use with(DateAdjuster)
rather than this method.
adjustDate
in interface DateAdjuster
date
- the date to be adjusted, not nullpublic OffsetDateTime atTime(OffsetTime time)
This merges the two objects - this
and the specified time -
to form an instance of OffsetDateTime
.
If the offset of the time differs from the offset of the date, then the
result will have the offset of the date and the time will be adjusted to match.
This instance is immutable and unaffected by this method call.
time
- the time to use, not nullpublic OffsetDateTime atTime(LocalTime time)
This merges the two objects - this
and the specified time -
to form an instance of OffsetDateTime
.
This instance is immutable and unaffected by this method call.
time
- the time to use, not nullpublic OffsetDateTime atTime(int hourOfDay, int minuteOfHour)
This merges the three values - this
and the specified time -
to form an instance of OffsetDateTime
.
This instance is immutable and unaffected by this method call.
hourOfDay
- the hour-of-day to use, from 0 to 23minuteOfHour
- the minute-of-hour to use, from 0 to 59IllegalCalendarFieldValueException
- if the value of any field is out of rangepublic OffsetDateTime atTime(int hourOfDay, int minuteOfHour, int secondOfMinute)
This merges the four values - this
and the specified time -
to form an instance of OffsetDateTime
.
This instance is immutable and unaffected by this method call.
hourOfDay
- the hour-of-day to use, from 0 to 23minuteOfHour
- the minute-of-hour to use, from 0 to 59secondOfMinute
- the second-of-minute to represent, from 0 to 59IllegalCalendarFieldValueException
- if the value of any field is out of rangepublic OffsetDateTime atTime(int hourOfDay, int minuteOfHour, int secondOfMinute, int nanoOfSecond)
This merges the five values - this
and the specified time -
to form an instance of OffsetDateTime
.
This instance is immutable and unaffected by this method call.
hourOfDay
- the hour-of-day to use, from 0 to 23minuteOfHour
- the minute-of-hour to use, from 0 to 59secondOfMinute
- the second-of-minute to represent, from 0 to 59nanoOfSecond
- the nano-of-second to represent, from 0 to 999,999,999IllegalCalendarFieldValueException
- if the value of any field is out of rangepublic OffsetDateTime atMidnight()
This merges the two objects - this
and LocalTime.MIDNIGHT
-
to form an instance of OffsetDateTime
.
This instance is immutable and unaffected by this method call.
public ZonedDateTime atStartOfDayInZone(TimeZone zone)
Time-zone rules, such as daylight savings, mean that not every time on the
local time-line exists. When this method converts the date to a date-time it
adjusts the time and offset as necessary to ensure that the time is as early
as possible on the date, which is typically midnight. Internally this is
achieved using the zone resolver
.
To convert to a specific time in a given time-zone call atTime(LocalTime)
followed by OffsetDateTime.atZoneSimilarLocal(TimeZone)
. Note that the resolver
used by atZoneSimilarLocal()
is different to that used here (it chooses
the later offset in an overlap, whereas this method chooses the earlier offset).
The offset from this date is ignored during the conversion. This ensures that the resultant date-time has the same date as this.
This instance is immutable and unaffected by this method call.
zone
- the time-zone to use, not nullpublic Instant toInstant()
Instant
at midnight.
This conversion treats the time component as midnight at the start of the day.
public LocalDate toLocalDate()
LocalDate
.toLocalDate
in interface DateProvider
public int compareTo(OffsetDate other)
OffsetDate
to another date based on the UTC equivalent
dates then local date.
This ordering is consistent with equals()
.
For example, the following is the comparator order:
equals()
.compareTo
in interface Comparable<OffsetDate>
other
- the other date to compare to, not nullpublic boolean isAfter(OffsetDate other)
OffsetDate
is after midnight at the start of the specified date.
This method differs from the comparison in compareTo(javax.time.calendar.OffsetDate)
in that it
only compares the instant of the date. This is equivalent to using
date1.toInstant().isAfter(date2.toInstant());
.
other
- the other date to compare to, not nullpublic boolean isBefore(OffsetDate other)
OffsetDate
is before midnight at the start of the specified date.
This method differs from the comparison in compareTo(javax.time.calendar.OffsetDate)
in that it
only compares the instant of the date. This is equivalent to using
date1.toInstant().isBefore(date2.toInstant());
.
other
- the other date to compare to, not nullpublic boolean equalInstant(OffsetDate other)
OffsetDate
equals midnight at the start of the specified date.
This method differs from the comparison in compareTo(javax.time.calendar.OffsetDate)
and equals(java.lang.Object)
in that it only compares the instant of the date. This is equivalent to using
date1.toInstant().equals(date2.toInstant());
.
other
- the other date to compare to, not nullpublic boolean equals(Object other)
OffsetDate
is equal to the specified date.
This method returns true if the state of the two objects are equal. The state consists of the local date and the offset.
To compare for the same instant on the time-line, use equalInstant(javax.time.calendar.OffsetDate)
.
public int hashCode()
OffsetDate
.public String toString()
String
, such as 2007-12-03+01:00
.
The output will be in the format yyyy-MM-ddZZZZ
.
public String toString(DateTimeFormatter formatter)
String
using the formatter.formatter
- the formatter to use, not nullUnsupportedOperationException
- if the formatter cannot printCalendricalPrintException
- if an error occurs during printingpublic static CalendricalRule<OffsetDate> rule()
OffsetDate
.Copyright © 2014. All rights reserved.