OffsetDateTime (ThreeTen date and time API)

java.lang.Object
- javax.time.OffsetDateTime

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<OffsetDateTime>, CalendricalAdjuster, CalendricalObject, DateTimeCalendrical, DateTimeObject
```
public final class OffsetDateTime
extends java.lang.Object
implements DateTimeObject, java.lang.Comparable<OffsetDateTime>, java.io.Serializable
```
A date-time with a zone offset from UTC in the ISO-8601 calendar system, such as 2007-12-03T10:15:30+01:00.
OffsetDateTime is an immutable representation of a date-time with an offset. This class stores all date and time fields, to a precision of nanoseconds, as well as the offset from UTC. For example, the value "2nd October 2007 at 13:45.30.123456789 +02:00" can be stored in an OffsetDateTime.
OffsetDateTime and Instant both store an instant on the time-line to nanosecond precision. The main difference is that this class also stores the offset from UTC. Instant should be used when you only need to compare the object to other instants. OffsetDateTime should be used when you want to actively query and manipulate the date and time fields, although you should also consider using ZonedDateTime.
Implementation notes
This class is immutable and thread-safe.

See Also:
Serialized Form

Method Summary

Methods
Modifier and Type	Method and Description
`ZonedDateTime`	`atZoneSameInstant(ZoneId zone)` Returns a zoned date-time formed from the instant represented by this date-time and the specified time-zone.
`ZonedDateTime`	`atZoneSimilarLocal(ZoneId zone)` Returns a zoned date-time formed from this date-time and the specified time-zone.
`ZonedDateTime`	`atZoneSimilarLocal(ZoneId zone, ZoneResolver resolver)` Returns a zoned date-time formed from this date-time and the specified time-zone taking control of what occurs in time-line gaps and overlaps.
`int`	`compareTo(OffsetDateTime other)` Compares this `OffsetDateTime` to another date-time.
`boolean`	`equalInstant(OffsetDateTime other)` Checks if the instant of this `OffsetDateTime` is equal to that of the specified date-time.
`boolean`	`equals(java.lang.Object obj)` Checks if this date-time is equal to another date-time.
`<R> R`	`extract(java.lang.Class<R> type)` Extracts date-time information in a generic way.
`static OffsetDateTime`	`from(CalendricalObject calendrical)` Obtains an instance of `OffsetDateTime` from a calendrical.
`long`	`get(DateTimeField field)` Gets the value of the specified date-time field.
`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.
`int`	`getHourOfDay()` Gets the hour-of-day field.
`int`	`getMinuteOfHour()` Gets the minute-of-hour field.
`int`	`getMonth()` Gets the month-of-year field from 1 to 12.
`MonthOfYear`	`getMonthOfYear()` Gets the month-of-year field, which is an enum `MonthOfYear`.
`int`	`getNanoOfSecond()` Gets the nano-of-second field.
`ZoneOffset`	`getOffset()` Gets the zone offset.
`int`	`getSecondOfMinute()` Gets the second-of-minute field.
`int`	`getYear()` Gets the year field.
`int`	`hashCode()` A hash code for this date-time.
`boolean`	`isAfter(OffsetDateTime other)` Checks if the instant of this `OffsetDateTime` is after that of the specified date-time.
`boolean`	`isBefore(OffsetDateTime other)` Checks if the instant of this `OffsetDateTime` is before that of the specified date-time.
`boolean`	`isLeapYear()` Checks if the year is a leap year, according to the ISO proleptic calendar system rules.
`OffsetDateTime`	`minus(Duration duration)` Returns a copy of this date-time with the specified duration subtracted.
`OffsetDateTime`	`minus(long period, PeriodUnit unit)` Returns a copy of this date-time with the specified period subtracted.
`OffsetDateTime`	`minus(Period period)` Returns a copy of this date-time with the specified period subtracted.
`OffsetDateTime`	`minusDays(long days)` Returns a copy of this `OffsetDateTime` with the specified period in days subtracted.
`OffsetDateTime`	`minusHours(long hours)` Returns a copy of this `OffsetDateTime` with the specified period in hours subtracted.
`OffsetDateTime`	`minusMinutes(long minutes)` Returns a copy of this `OffsetDateTime` with the specified period in minutes subtracted.
`OffsetDateTime`	`minusMonths(long months)` Returns a copy of this `OffsetDateTime` with the specified period in months subtracted.
`OffsetDateTime`	`minusNanos(long nanos)` Returns a copy of this `OffsetDateTime` with the specified period in nanoseconds subtracted.
`OffsetDateTime`	`minusSeconds(long seconds)` Returns a copy of this `OffsetDateTime` with the specified period in seconds subtracted.
`OffsetDateTime`	`minusWeeks(long weeks)` Returns a copy of this `OffsetDateTime` with the specified period in weeks subtracted.
`OffsetDateTime`	`minusYears(long years)` Returns a copy of this `OffsetDateTime` with the specified period in years subtracted.
`static OffsetDateTime`	`now()` Obtains the current date-time from the system clock in the default time-zone.
`static OffsetDateTime`	`now(Clock clock)` Obtains the current date-time from the specified clock.
`static OffsetDateTime`	`of(int year, int monthOfYear, int dayOfMonth, int hourOfDay, int minuteOfHour, int secondOfMinute, int nanoOfSecond, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from year, month, day, hour, minute, second and nanosecond.
`static OffsetDateTime`	`of(int year, int monthOfYear, int dayOfMonth, int hourOfDay, int minuteOfHour, int secondOfMinute, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from year, month, day, hour, minute and second, setting the nanosecond to zero.
`static OffsetDateTime`	`of(int year, int monthOfYear, int dayOfMonth, int hourOfDay, int minuteOfHour, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from year, month, day, hour and minute, setting the second and nanosecond to zero.
`static OffsetDateTime`	`of(int year, MonthOfYear monthOfYear, int dayOfMonth, int hourOfDay, int minuteOfHour, int secondOfMinute, int nanoOfSecond, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from year, month, day, hour, minute, second and nanosecond.
`static OffsetDateTime`	`of(int year, MonthOfYear monthOfYear, int dayOfMonth, int hourOfDay, int minuteOfHour, int secondOfMinute, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from year, month, day, hour, minute and second, setting the nanosecond to zero.
`static OffsetDateTime`	`of(int year, MonthOfYear monthOfYear, int dayOfMonth, int hourOfDay, int minuteOfHour, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from year, month, day, hour and minute, setting the second and nanosecond to zero.
`static OffsetDateTime`	`of(LocalDate date, LocalTime time, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from a date, time and offset.
`static OffsetDateTime`	`of(LocalDate date, OffsetTime offsetTime)` Obtains an instance of `OffsetDateTime` from a local date and offset time.
`static OffsetDateTime`	`of(LocalDateTime dateTime, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from a date-time and offset.
`static OffsetDateTime`	`ofEpochSecond(long epochSecond, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` using seconds from the epoch of 1970-01-01T00:00:00Z.
`static OffsetDateTime`	`ofInstant(Instant instant, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from an `Instant`.
`static OffsetDateTime`	`ofInstantUTC(Instant instant)` Obtains an instance of `OffsetDateTime` from an `Instant` using the UTC offset.
`static OffsetDateTime`	`ofMidnight(int year, int monthOfYear, int dayOfMonth, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from year, month and day with the time set to midnight at the start of day.
`static OffsetDateTime`	`ofMidnight(int year, MonthOfYear monthOfYear, int dayOfMonth, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from year, month and day with the time set to midnight at the start of day.
`static OffsetDateTime`	`ofMidnight(LocalDate date, ZoneOffset offset)` Obtains an instance of `OffsetDateTime` from a date with the time set to midnight at the start of day.
`static OffsetDateTime`	`parse(java.lang.CharSequence text)` Obtains an instance of `OffsetDateTime` from a text string such as `2007-12-03T10:15:30+01:00`.
`static OffsetDateTime`	`parse(java.lang.String text, CalendricalFormatter formatter)` Obtains an instance of `OffsetDateTime` from a text string using a specific formatter.
`OffsetDateTime`	`plus(Duration duration)` Returns a copy of this date-time with the specified duration added.
`OffsetDateTime`	`plus(long period, PeriodUnit unit)` Returns a copy of this date-time with the specified period added.
`OffsetDateTime`	`plus(Period period)` Returns a copy of this date-time with the specified period added.
`OffsetDateTime`	`plusDays(long days)` Returns a copy of this OffsetDateTime with the specified period in days added.
`OffsetDateTime`	`plusHours(long hours)` Returns a copy of this `OffsetDateTime` with the specified period in hours added.
`OffsetDateTime`	`plusMinutes(long minutes)` Returns a copy of this `OffsetDateTime` with the specified period in minutes added.
`OffsetDateTime`	`plusMonths(long months)` Returns a copy of this `OffsetDateTime` with the specified period in months added.
`OffsetDateTime`	`plusNanos(long nanos)` Returns a copy of this `OffsetDateTime` with the specified period in nanoseconds added.
`OffsetDateTime`	`plusSeconds(long seconds)` Returns a copy of this `OffsetDateTime` with the specified period in seconds added.
`OffsetDateTime`	`plusWeeks(long weeks)` Returns a copy of this OffsetDateTime with the specified period in weeks added.
`OffsetDateTime`	`plusYears(long years)` Returns a copy of this `OffsetDateTime` with the specified period in years added.
`long`	`toEpochSecond()` Converts this date-time to the number of seconds from the epoch of 1970-01-01T00:00:00Z.
`Instant`	`toInstant()` Converts this date-time to an `Instant`.
`LocalDate`	`toLocalDate()` Converts this date-time to a `LocalDate`.
`LocalDateTime`	`toLocalDateTime()` Converts this date-time to a `LocalDateTime`.
`LocalTime`	`toLocalTime()` Converts this date-time to a `LocalTime`.
`OffsetDate`	`toOffsetDate()` Converts this date-time to an `OffsetDate`.
`OffsetTime`	`toOffsetTime()` Converts this date-time to an `OffsetTime`.
`java.lang.String`	`toString()` Outputs this date-time as a `String`, such as `2007-12-03T10:15:30+01:00`.
`java.lang.String`	`toString(CalendricalFormatter formatter)` Outputs this date-time as a `String` using the formatter.
`OffsetDateTime`	`with(CalendricalAdjuster adjuster)` Returns a copy of this calendrical with the specified calendrical set.
`OffsetDateTime`	`with(DateTimeField field, long newValue)` Returns a copy of this date-time with the specified field altered.
`OffsetDateTime`	`withDate(int year, int monthOfYear, int dayOfMonth)` Returns a copy of this `OffsetDateTime` with the date values altered.
`OffsetDateTime`	`withDate(int year, MonthOfYear monthOfYear, int dayOfMonth)` Returns a copy of this `OffsetDateTime` with the date values altered.
`OffsetDateTime`	`withDayOfMonth(int dayOfMonth)` Returns a copy of this `OffsetDateTime` with the day-of-month altered.
`OffsetDateTime`	`withDayOfYear(int dayOfYear)` Returns a copy of this `OffsetDateTime` with the day-of-year altered.
`OffsetDateTime`	`withHourOfDay(int hourOfDay)` Returns a copy of this `OffsetDateTime` with the hour-of-day value altered.
`OffsetDateTime`	`withMinuteOfHour(int minuteOfHour)` Returns a copy of this `OffsetDateTime` with the minute-of-hour value altered.
`OffsetDateTime`	`withMonthOfYear(int monthOfYear)` Returns a copy of this `OffsetDateTime` with the month-of-year altered.
`OffsetDateTime`	`withNanoOfSecond(int nanoOfSecond)` Returns a copy of this `OffsetDateTime` with the nano-of-second value altered.
`OffsetDateTime`	`withOffsetSameInstant(ZoneOffset offset)` Returns a copy of this `OffsetDateTime` with the specified offset ensuring that the result is at the same instant.
`OffsetDateTime`	`withOffsetSameLocal(ZoneOffset offset)` Returns a copy of this `OffsetDateTime` with the specified offset ensuring that the result has the same local date-time.
`OffsetDateTime`	`withSecondOfMinute(int secondOfMinute)` Returns a copy of this `OffsetDateTime` with the second-of-minute value altered.
`OffsetDateTime`	`withTime(int hourOfDay, int minuteOfHour)` Returns a copy of this `OffsetDateTime` with the time values altered.
`OffsetDateTime`	`withTime(int hourOfDay, int minuteOfHour, int secondOfMinute)` Returns a copy of this `OffsetDateTime` with the time values altered.
`OffsetDateTime`	`withTime(int hourOfDay, int minuteOfHour, int secondOfMinute, int nanoOfSecond)` Returns a copy of this OffsetDateTime with the time values altered.
`OffsetDateTime`	`withYear(int year)` Returns a copy of this `OffsetDateTime` with the year altered.

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

- Method Detail
  - now
```
public static OffsetDateTime now()
```
    Obtains the current date-time from the system clock in the default time-zone.
    This will query the system clock in the default time-zone to obtain the current date-time. 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.
    
    Returns:
    the current date-time using the system clock, not null
  - now
```
public static OffsetDateTime now(Clock clock)
```
    Obtains the current date-time from the specified clock.
    This will query the specified clock to obtain the current date-time. 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.
    
    Parameters:
    clock - the clock to use, not null
    
    Returns:
    the current date-time, not null
  - ofMidnight
```
public static OffsetDateTime ofMidnight(int year,
                        MonthOfYear monthOfYear,
                        int dayOfMonth,
                        ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from year, month and day with the time set to midnight at the start of day.
    The time fields will be set to zero by this factory method.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    monthOfYear - the month-of-year to represent, not null
    dayOfMonth - the day-of-month to represent, from 1 to 31
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the value of any field is out of range
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - ofMidnight
```
public static OffsetDateTime ofMidnight(int year,
                        int monthOfYear,
                        int dayOfMonth,
                        ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from year, month and day with the time set to midnight at the start of day.
    The time fields will be set to zero by this factory method.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    monthOfYear - the month-of-year to represent, from 1 (January) to 12 (December)
    dayOfMonth - the day-of-month to represent, from 1 to 31
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the value of any field is out of range
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - ofMidnight
```
public static OffsetDateTime ofMidnight(LocalDate date,
                        ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from a date with the time set to midnight at the start of day.
    The time fields will be set to zero by this factory method.
    
    Parameters:
    date - the local date, not null
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
  - of
```
public static OffsetDateTime of(int year,
                MonthOfYear monthOfYear,
                int dayOfMonth,
                int hourOfDay,
                int minuteOfHour,
                ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from year, month, day, hour and minute, setting the second and nanosecond to zero.
    The day must be valid for the year and month, otherwise an exception will be thrown. The second and nanosecond fields will be set to zero.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    monthOfYear - the month-of-year to represent, not null
    dayOfMonth - the day-of-month to represent, from 1 to 31
    hourOfDay - the hour-of-day to represent, from 0 to 23
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the value of any field is out of range
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - of
```
public static OffsetDateTime of(int year,
                MonthOfYear monthOfYear,
                int dayOfMonth,
                int hourOfDay,
                int minuteOfHour,
                int secondOfMinute,
                ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from year, month, day, hour, minute and second, setting the nanosecond to zero.
    The day must be valid for the year and month, otherwise an exception will be thrown. The nanosecond field will be set to zero.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    monthOfYear - the month-of-year to represent, not null
    dayOfMonth - the day-of-month to represent, from 1 to 31
    hourOfDay - the hour-of-day to represent, from 0 to 23
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    secondOfMinute - the second-of-minute to represent, from 0 to 59
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the value of any field is out of range
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - of
```
public static OffsetDateTime of(int year,
                MonthOfYear monthOfYear,
                int dayOfMonth,
                int hourOfDay,
                int minuteOfHour,
                int secondOfMinute,
                int nanoOfSecond,
                ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from year, month, day, hour, minute, second and nanosecond.
    The day must be valid for the year and month, otherwise an exception will be thrown.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    monthOfYear - the month-of-year to represent, not null
    dayOfMonth - the day-of-month to represent, from 1 to 31
    hourOfDay - the hour-of-day to represent, from 0 to 23
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    secondOfMinute - the second-of-minute to represent, from 0 to 59
    nanoOfSecond - the nano-of-second to represent, from 0 to 999,999,999
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the value of any field is out of range
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - of
```
public static OffsetDateTime of(int year,
                int monthOfYear,
                int dayOfMonth,
                int hourOfDay,
                int minuteOfHour,
                ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from year, month, day, hour and minute, setting the second and nanosecond to zero.
    The day must be valid for the year and month, otherwise an exception will be thrown. The second and nanosecond fields will be set to zero.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    monthOfYear - the month-of-year to represent, from 1 (January) to 12 (December)
    dayOfMonth - the day-of-month to represent, from 1 to 31
    hourOfDay - the hour-of-day to represent, from 0 to 23
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the value of any field is out of range
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - of
```
public static OffsetDateTime of(int year,
                int monthOfYear,
                int dayOfMonth,
                int hourOfDay,
                int minuteOfHour,
                int secondOfMinute,
                ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from year, month, day, hour, minute and second, setting the nanosecond to zero.
    The day must be valid for the year and month, otherwise an exception will be thrown. The nanosecond field will be set to zero.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    monthOfYear - the month-of-year to represent, from 1 (January) to 12 (December)
    dayOfMonth - the day-of-month to represent, from 1 to 31
    hourOfDay - the hour-of-day to represent, from 0 to 23
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    secondOfMinute - the second-of-minute to represent, from 0 to 59
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the value of any field is out of range
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - of
```
public static OffsetDateTime of(int year,
                int monthOfYear,
                int dayOfMonth,
                int hourOfDay,
                int minuteOfHour,
                int secondOfMinute,
                int nanoOfSecond,
                ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from year, month, day, hour, minute, second and nanosecond.
    The day must be valid for the year and month, otherwise an exception will be thrown.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    monthOfYear - the month-of-year to represent, from 1 (January) to 12 (December)
    dayOfMonth - the day-of-month to represent, from 1 to 31
    hourOfDay - the hour-of-day to represent, from 0 to 23
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    secondOfMinute - the second-of-minute to represent, from 0 to 59
    nanoOfSecond - the nano-of-second to represent, from 0 to 999,999,999
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the value of any field is out of range
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - of
```
public static OffsetDateTime of(LocalDate date,
                LocalTime time,
                ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from a date, time and offset.
    
    Parameters:
    date - the local date, not null
    time - the local time, not null
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
  - of
```
public static OffsetDateTime of(LocalDate date,
                OffsetTime offsetTime)
```
    Obtains an instance of OffsetDateTime from a local date and offset time.
    
    Parameters:
    date - the local date, not null
    offsetTime - the offset time to use, not null
    
    Returns:
    the offset date-time, not null
  - of
```
public static OffsetDateTime of(LocalDateTime dateTime,
                ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from a date-time and offset.
    
    Parameters:
    dateTime - the local date-time, not null
    offset - the zone offset, not null
    
    Returns:
    the offset date-time, not null
  - ofInstantUTC
```
public static OffsetDateTime ofInstantUTC(Instant instant)
```
    Obtains an instance of OffsetDateTime from an Instant using the UTC offset.
    The resulting date-time represents exactly the same instant on the time-line. Calling toInstant() will return an instant equal to the one used here.
    
    Parameters:
    instant - the instant to create a date-time from, not null
    
    Returns:
    the offset date-time in UTC, not null
    
    Throws:
    
    CalendricalException - if the instant exceeds the supported date range
  - ofInstant
```
public static OffsetDateTime ofInstant(Instant instant,
                       ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime from an Instant.
    The resulting date-time represents exactly the same instant on the time-line. Calling toInstant() will return an instant equal to the one used here.
    
    Parameters:
    instant - the instant to create the date-time from, not null
    offset - the zone offset to use, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the instant exceeds the supported date range
  - ofEpochSecond
```
public static OffsetDateTime ofEpochSecond(long epochSecond,
                           ZoneOffset offset)
```
    Obtains an instance of OffsetDateTime using seconds from the epoch of 1970-01-01T00:00:00Z.
    The nanosecond field is set to zero.
    
    Parameters:
    epochSecond - the number of seconds from the epoch of 1970-01-01T00:00:00Z
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported range
  - from
```
public static OffsetDateTime from(CalendricalObject calendrical)
```
    Obtains an instance of OffsetDateTime from a calendrical.
    A calendrical represents some form of date and time information. This factory converts the arbitrary calendrical to an instance of OffsetDateTime.
    
    Parameters:
    calendrical - the calendrical to convert, not null
    
    Returns:
    the offset date-time, not null
    
    Throws:
    
    CalendricalException - if unable to convert to an OffsetDateTime
  - parse
```
public static OffsetDateTime parse(java.lang.CharSequence text)
```
    Obtains an instance of OffsetDateTime from a text string such as 2007-12-03T10:15:30+01:00.
    The string must represent a valid date-time and is parsed using DateTimeFormatters.isoOffsetDateTime(). Year, month, day-of-month, hour, minute and offset are required. Seconds and fractional seconds are optional. 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-03T10:15:30+01:00", not null
    
    Returns:
    the parsed offset date-time, not null
    
    Throws:
    
    CalendricalParseException - if the text cannot be parsed
  - parse
```
public static OffsetDateTime parse(java.lang.String text,
                   CalendricalFormatter formatter)
```
    Obtains an instance of OffsetDateTime from a text string using a specific formatter.
    The text is parsed using the formatter, returning a date-time.
    
    Parameters:
    text - the text to parse, not null
    formatter - the formatter to use, not null
    
    Returns:
    the parsed offset date-time, not null
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the formatter cannot parse
    
    CalendricalParseException - if the text cannot be parsed
  - get
```
public long get(DateTimeField field)
```
    Description copied from interface: DateTimeCalendrical
    
    Gets the value of the specified date-time field.
    Implementations must check and return any fields defined in LocalDateTimeField before delegating on to the method on the specified field. Invoking this method must not change the observed state of the target.
    
    Specified by:
    
    get in interface DateTimeCalendrical
    
    Parameters:
    field - the field to get, not null
    
    Returns:
    the value for the field
  - getOffset
```
public ZoneOffset getOffset()
```
    Gets the zone offset.
    
    Returns:
    the zone offset, not null
  - withOffsetSameLocal
```
public OffsetDateTime withOffsetSameLocal(ZoneOffset offset)
```
    Returns a copy of this OffsetDateTime with the specified offset ensuring that the result has the same local date-time.
    This method returns an object with the same LocalDateTime and the specified ZoneOffset. No calculation is needed or performed. For example, if this time represents 2007-12-03T10:30+02:00 and the offset specified is +03:00, then this method will return 2007-12-03T10:30+03:00.
    To take into account the difference between the offsets, and adjust the time fields, use withOffsetSameInstant(javax.time.ZoneOffset).
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    offset - the zone offset to change to, not null
    
    Returns:
    an OffsetDateTime based on this date-time with the requested offset, not null
  - withOffsetSameInstant
```
public OffsetDateTime withOffsetSameInstant(ZoneOffset offset)
```
    Returns a copy of this OffsetDateTime with the specified offset ensuring that the result is at the same instant.
    This method returns an object with the specified ZoneOffset and a LocalDateTime adjusted by the difference between the two offsets. This will result in the old and new objects representing the same instant. This is useful for finding the local time in a different offset. For example, if this time represents 2007-12-03T10:30+02:00 and the offset specified is +03:00, then this method will return 2007-12-03T11:30+03:00.
    To change the offset without adjusting the local time use withOffsetSameLocal(javax.time.ZoneOffset).
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    offset - the zone offset to change to, not null
    
    Returns:
    an OffsetDateTime based on this date-time with the requested offset, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - getYear
```
public int getYear()
```
    Gets the year field.
    This method returns the primitive int value for the year.
    
    Returns:
    the year, from MIN_YEAR to MAX_YEAR
  - getMonth
```
public int getMonth()
```
    Gets the month-of-year field from 1 to 12.
    This method returns the month as an int from 1 to 12. Application code is frequently clearer if the enum MonthOfYear is used by calling getMonthOfYear().
    
    Returns:
    the month-of-year, from 1 to 12
    See Also:
    getMonthOfYear()
  - getMonthOfYear
```
public MonthOfYear getMonthOfYear()
```
    Gets the month-of-year field, which is an enum 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.
    
    Returns:
    the month-of-year, not null
    See Also:
    getMonth()
  - getDayOfMonth
```
public int getDayOfMonth()
```
    Gets the day-of-month field.
    This method returns the primitive int value for the day-of-month.
    
    Returns:
    the day-of-month, from 1 to 31
  - getDayOfYear
```
public int getDayOfYear()
```
    Gets the day-of-year field.
    This method returns the primitive int value for the day-of-year.
    
    Returns:
    the day-of-year, from 1 to 365, or 366 in a leap year
  - getDayOfWeek
```
public DayOfWeek getDayOfWeek()
```
    Gets the day-of-week field, which is an enum 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.
    
    Returns:
    the day-of-week, not null
  - getHourOfDay
```
public int getHourOfDay()
```
    Gets the hour-of-day field.
    
    Returns:
    the hour-of-day, from 0 to 23
  - getMinuteOfHour
```
public int getMinuteOfHour()
```
    Gets the minute-of-hour field.
    
    Returns:
    the minute-of-hour, from 0 to 59
  - getSecondOfMinute
```
public int getSecondOfMinute()
```
    Gets the second-of-minute field.
    
    Returns:
    the second-of-minute, from 0 to 59
  - getNanoOfSecond
```
public int getNanoOfSecond()
```
    Gets the nano-of-second field.
    
    Returns:
    the nano-of-second, from 0 to 999,999,999
  - 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
  - with
```
public OffsetDateTime with(DateTimeField field,
                  long newValue)
```
    Returns a copy of this date-time with the specified field altered.
    This method returns a new date-time based on this date-time with a new value for the specified field. This can be used to change any field, for example to set the year, month of day-of-month. The offset is not part of the calculation and will be unchanged in the result.
    In some cases, changing the specified field can cause the resulting date-time to become invalid, such as changing the month from January to February would make the day-of-month 31 invalid. In cases like this, the field is responsible for resolving the date. Typically it will choose the previous valid date, which would be the last valid day of February in this example.
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    with in interface DateTimeCalendrical
    
    Specified by:
    
    with in interface DateTimeObject
    
    Parameters:
    field - the field to set in the returned date-time, not null
    newValue - the new value of the field in the returned date-time, not null
    
    Returns:
    an OffsetDateTime based on this date-time with the specified field set, not null
    
    Throws:
    
    CalendricalException - if the value is invalid
  - withYear
```
public OffsetDateTime withYear(int year)
```
    Returns a copy of this OffsetDateTime with the year altered. The offset does not affect the calculation and will be the same in the result. If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    year - the year to set in the returned date, from MIN_YEAR to MAX_YEAR
    
    Returns:
    an OffsetDateTime based on this date-time with the requested year, not null
    
    Throws:
    
    CalendricalException - if the year value is invalid
  - withMonthOfYear
```
public OffsetDateTime withMonthOfYear(int monthOfYear)
```
    Returns a copy of this OffsetDateTime with the month-of-year altered. The offset does not affect the calculation and will be the same in the result. If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    monthOfYear - the month-of-year to set in the returned date, from 1 (January) to 12 (December)
    
    Returns:
    an OffsetDateTime based on this date-time with the requested month, not null
    
    Throws:
    
    CalendricalException - if the month-of-year value is invalid
  - withDayOfMonth
```
public OffsetDateTime withDayOfMonth(int dayOfMonth)
```
    Returns a copy of this OffsetDateTime with the day-of-month altered. If the resulting OffsetDateTime 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.
    
    Parameters:
    dayOfMonth - the day-of-month to set in the returned date, from 1 to 28-31
    
    Returns:
    an OffsetDateTime based on this date-time with the requested day, not null
    
    Throws:
    
    CalendricalException - if the day-of-month value is invalid
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - withDayOfYear
```
public OffsetDateTime withDayOfYear(int dayOfYear)
```
    Returns a copy of this OffsetDateTime with the day-of-year altered. If the resulting OffsetDateTime is invalid, an exception is thrown.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    dayOfYear - the day-of-year to set in the returned date, from 1 to 365-366
    
    Returns:
    an OffsetDateTime based on this date with the requested day, not null
    
    Throws:
    
    CalendricalException - if the day-of-year value is invalid
    
    CalendricalException - if the day-of-year is invalid for the year
  - withDate
```
public OffsetDateTime withDate(int year,
                      MonthOfYear monthOfYear,
                      int dayOfMonth)
```
    Returns a copy of this OffsetDateTime with the date values altered.
    This method will return a new instance with the same time fields, but altered date fields.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    year - the year to represent, from MIN_YEAR to MAX_YEAR
    monthOfYear - the month-of-year to represent, not null
    dayOfMonth - the day-of-month to represent, from 1 to 31
    
    Returns:
    an OffsetDateTime based on this date-time with the requested date, not null
    
    Throws:
    
    CalendricalException - if any field value is invalid
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - withDate
```
public OffsetDateTime withDate(int year,
                      int monthOfYear,
                      int dayOfMonth)
```
    Returns a copy of this OffsetDateTime with the date values altered.
    This method will return a new instance with the same time fields, but altered date fields.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    year - the year to represent, from MIN_VALUE + 1 to MAX_VALUE
    monthOfYear - the month-of-year to represent, from 1 (January) to 12 (December)
    dayOfMonth - the day-of-month to represent, from 1 to 31
    
    Returns:
    an OffsetDateTime based on this date-time with the requested date, not null
    
    Throws:
    
    CalendricalException - if any field value is invalid
    
    CalendricalException - if the day-of-month is invalid for the month-year
  - withHourOfDay
```
public OffsetDateTime withHourOfDay(int hourOfDay)
```
    Returns a copy of this OffsetDateTime with the hour-of-day value altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    hourOfDay - the hour-of-day to represent, from 0 to 23
    
    Returns:
    an OffsetDateTime based on this date-time with the requested hour, not null
    
    Throws:
    
    CalendricalException - if the hour value is invalid
  - withMinuteOfHour
```
public OffsetDateTime withMinuteOfHour(int minuteOfHour)
```
    Returns a copy of this OffsetDateTime with the minute-of-hour value altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    
    Returns:
    an OffsetDateTime based on this date-time with the requested minute, not null
    
    Throws:
    
    CalendricalException - if the minute value is invalid
  - withSecondOfMinute
```
public OffsetDateTime withSecondOfMinute(int secondOfMinute)
```
    Returns a copy of this OffsetDateTime with the second-of-minute value altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    secondOfMinute - the second-of-minute to represent, from 0 to 59
    
    Returns:
    an OffsetDateTime based on this date-time with the requested second, not null
    
    Throws:
    
    CalendricalException - if the second value is invalid
  - withNanoOfSecond
```
public OffsetDateTime withNanoOfSecond(int nanoOfSecond)
```
    Returns a copy of this OffsetDateTime with the nano-of-second value altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    nanoOfSecond - the nano-of-second to represent, from 0 to 999,999,999
    
    Returns:
    an OffsetDateTime based on this date-time with the requested nanosecond, not null
    
    Throws:
    
    CalendricalException - if the nanos value is invalid
  - withTime
```
public OffsetDateTime withTime(int hourOfDay,
                      int minuteOfHour)
```
    Returns a copy of this OffsetDateTime with the time values altered.
    This method will return a new instance with the same date fields, but altered time fields. This is a shorthand for withTime(int,int,int,int) and sets the second and nanosecond fields to zero.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    hourOfDay - the hour-of-day to represent, from 0 to 23
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    
    Returns:
    an OffsetDateTime based on this date-time with the requested time, not null
    
    Throws:
    
    CalendricalException - if any field value is invalid
  - withTime
```
public OffsetDateTime withTime(int hourOfDay,
                      int minuteOfHour,
                      int secondOfMinute)
```
    Returns a copy of this OffsetDateTime with the time values altered.
    This method will return a new instance with the same date fields, but altered time fields. This is a shorthand for withTime(int,int,int,int) and sets the nanosecond fields to zero.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    hourOfDay - the hour-of-day to represent, from 0 to 23
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    secondOfMinute - the second-of-minute to represent, from 0 to 59
    
    Returns:
    an OffsetDateTime based on this date-time with the requested time, not null
    
    Throws:
    
    CalendricalException - if any field value is invalid
  - withTime
```
public OffsetDateTime withTime(int hourOfDay,
                      int minuteOfHour,
                      int secondOfMinute,
                      int nanoOfSecond)
```
    Returns a copy of this OffsetDateTime with the time values altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    hourOfDay - the hour-of-day to represent, from 0 to 23
    minuteOfHour - the minute-of-hour to represent, from 0 to 59
    secondOfMinute - the second-of-minute to represent, from 0 to 59
    nanoOfSecond - the nano-of-second to represent, from 0 to 999,999,999
    
    Returns:
    an OffsetDateTime based on this date-time with the requested time, not null
    
    Throws:
    
    CalendricalException - if any field value is invalid
  - plus
```
public OffsetDateTime plus(Duration duration)
```
    Returns a copy of this date-time with the specified duration added.
    This adds the specified duration to this date-time, returning a new date-time.
    The calculation is equivalent to using plusSeconds(long) and plusNanos(long) on the two parts of the duration.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    duration - the duration to add, not null
    
    Returns:
    an OffsetDateTime based on this date-time with the duration added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plus
```
public OffsetDateTime plus(Period period)
```
    Returns a copy of this date-time with the specified period added.
    This method returns a new date-time based on this time with the specified period added. The calculation is delegated to the unit within the period. The offset is not part of the calculation and will be unchanged in the result.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    period - the period to add, not null
    
    Returns:
    an OffsetDateTime based on this date-time with the period added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plus
```
public OffsetDateTime plus(long period,
                  PeriodUnit unit)
```
    Returns a copy of this date-time with the specified period added.
    This method returns a new date-time based on this date-time with the specified period added. This can be used to add any period that is defined by a unit, for example to add years, months or days. The unit is responsible for the details of the calculation, including the resolution of any edge cases in the calculation. The offset is not part of the calculation and will be unchanged in the result.
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    plus in interface DateTimeObject
    
    Parameters:
    period - the amount of the unit to add to the returned date-time, not null
    unit - the unit of the period to add, not null
    
    Returns:
    an OffsetDateTime based on this date-time with the specified period added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plusYears
```
public OffsetDateTime plusYears(long years)
```
    Returns a copy of this OffsetDateTime with the specified period in years added.
    This method adds the specified amount to the years field in three steps:
    1. Add the input years to the year field
    2. Check if the resulting date would be invalid
    3. Adjust the day-of-month to the last valid day if necessary
    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 instance is immutable and unaffected by this method call.
    Parameters:
    years - the years to add, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the years added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plusMonths
```
public OffsetDateTime plusMonths(long months)
```
    Returns a copy of this OffsetDateTime with the specified period in months added.
    This method adds the specified amount to the months field in three steps:
    1. Add the input months to the month-of-year field
    2. Check if the resulting date would be invalid
    3. Adjust the day-of-month to the last valid day if necessary
    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 instance is immutable and unaffected by this method call.
    Parameters:
    months - the months to add, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the months added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plusWeeks
```
public OffsetDateTime plusWeeks(long weeks)
```
    Returns a copy of this OffsetDateTime 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 the 2009-01-07.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    weeks - the weeks to add, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the weeks added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plusDays
```
public OffsetDateTime plusDays(long days)
```
    Returns a copy of this OffsetDateTime 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 the 2009-01-01.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    days - the days to add, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the days added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plusHours
```
public OffsetDateTime plusHours(long hours)
```
    Returns a copy of this OffsetDateTime with the specified period in hours added.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    hours - the hours to add, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the hours added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plusMinutes
```
public OffsetDateTime plusMinutes(long minutes)
```
    Returns a copy of this OffsetDateTime with the specified period in minutes added.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    minutes - the minutes to add, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the minutes added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plusSeconds
```
public OffsetDateTime plusSeconds(long seconds)
```
    Returns a copy of this OffsetDateTime with the specified period in seconds added.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    seconds - the seconds to add, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the seconds added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - plusNanos
```
public OffsetDateTime plusNanos(long nanos)
```
    Returns a copy of this OffsetDateTime with the specified period in nanoseconds added.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    nanos - the nanos to add, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the nanoseconds added, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minus
```
public OffsetDateTime minus(Duration duration)
```
    Returns a copy of this date-time with the specified duration subtracted.
    This subtracts the specified duration from this date-time, returning a new date-time.
    The calculation is equivalent to using minusSeconds(long) and minusNanos(long) on the two parts of the duration. The offset is not part of the calculation and will be unchanged in the result.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    duration - the duration to subtract, not null
    
    Returns:
    an OffsetDateTime based on this date-time with the duration subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minus
```
public OffsetDateTime minus(Period period)
```
    Returns a copy of this date-time with the specified period subtracted.
    This method returns a new date-time based on this time with the specified period subtracted. The calculation is delegated to the unit within the period. The offset is not part of the calculation and will be unchanged in the result.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    period - the period to subtract, not null
    
    Returns:
    an OffsetDateTime based on this date-time with the period subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minus
```
public OffsetDateTime minus(long period,
                   PeriodUnit unit)
```
    Returns a copy of this date-time with the specified period subtracted.
    This method returns a new date-time based on this date-time with the specified period subtracted. This can be used to subtract any period that is defined by a unit, for example to subtract years, months or days. The unit is responsible for the details of the calculation, including the resolution of any edge cases in the calculation. The offset is not part of the calculation and will be unchanged in the result.
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    minus in interface DateTimeObject
    
    Parameters:
    period - the amount of the unit to subtract from the returned date-time, not null
    unit - the unit of the period to subtract, not null
    
    Returns:
    an OffsetDateTime based on this date-time with the specified period subtracted, not null
  - minusYears
```
public OffsetDateTime minusYears(long years)
```
    Returns a copy of this OffsetDateTime with the specified period in years subtracted.
    This method subtracts the specified amount from the years field in three steps:
    1. Subtract the input years to the year field
    2. Check if the resulting date would be invalid
    3. Adjust the day-of-month to the last valid day if necessary
    For example, 2008-02-29 (leap year) minus 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 instance is immutable and unaffected by this method call.
    Parameters:
    years - the years to subtract, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the years subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minusMonths
```
public OffsetDateTime minusMonths(long months)
```
    Returns a copy of this OffsetDateTime with the specified period in months subtracted.
    This method subtracts the specified amount from the months field in three steps:
    1. Subtract the input months to the month-of-year field
    2. Check if the resulting date would be invalid
    3. Adjust the day-of-month to the last valid day if necessary
    For example, 2007-03-31 minus 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 instance is immutable and unaffected by this method call.
    Parameters:
    months - the months to subtract, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the months subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minusWeeks
```
public OffsetDateTime minusWeeks(long weeks)
```
    Returns a copy of this OffsetDateTime 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, 2008-12-31 minus one week would result in the 2009-01-07.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    weeks - the weeks to subtract, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the weeks subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minusDays
```
public OffsetDateTime minusDays(long days)
```
    Returns a copy of this OffsetDateTime with the specified period in days subtracted.
    This method subtracts the specified amount from 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 minus one day would result in the 2009-01-01.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    days - the days to subtract, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the days subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minusHours
```
public OffsetDateTime minusHours(long hours)
```
    Returns a copy of this OffsetDateTime with the specified period in hours subtracted.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    hours - the hours to subtract, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the hours subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minusMinutes
```
public OffsetDateTime minusMinutes(long minutes)
```
    Returns a copy of this OffsetDateTime with the specified period in minutes subtracted.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    minutes - the minutes to subtract, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the minutes subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minusSeconds
```
public OffsetDateTime minusSeconds(long seconds)
```
    Returns a copy of this OffsetDateTime with the specified period in seconds subtracted.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    seconds - the seconds to subtract, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the seconds subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - minusNanos
```
public OffsetDateTime minusNanos(long nanos)
```
    Returns a copy of this OffsetDateTime with the specified period in nanoseconds subtracted.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    nanos - the nanos to subtract, may be negative
    
    Returns:
    an OffsetDateTime based on this date-time with the nanoseconds subtracted, not null
    
    Throws:
    
    CalendricalException - if the result exceeds the supported date range
  - atZoneSameInstant
```
public ZonedDateTime atZoneSameInstant(ZoneId zone)
```
    Returns a zoned date-time formed from the instant represented by this date-time and the specified time-zone.
    This conversion will ignore the visible local date-time and use the underlying instant instead. This avoids any problems with local time-line gaps or overlaps. The result might have different values for fields such as hour, minute an even day.
    To attempt to retain the values of the fields, use atZoneSimilarLocal(ZoneId).
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    zone - the time-zone to use, not null
    
    Returns:
    the zoned date-time formed from this date-time, not null
  - atZoneSimilarLocal
```
public ZonedDateTime atZoneSimilarLocal(ZoneId zone)
```
    Returns a zoned date-time formed from this date-time and the specified time-zone.
    Time-zone rules, such as daylight savings, mean that not every time on the local time-line exists. If the local date-time is in a gap or overlap according to the rules then a resolver is used to determine the resultant local time and offset. This method uses the retain-offset resolver. This selects the date-time immediately after a gap and retains the offset in overlaps where possible, selecting the earlier offset if not possible.
    Finer control over gaps and overlaps is available in two ways. If you simply want to use the later offset at overlaps then call ZonedDateTime.withLaterOffsetAtOverlap() immediately after this method. Alternately, pass a specific resolver to atZoneSimilarLocal(ZoneId, ZoneResolver).
    To create a zoned date-time at the same instant irrespective of the local time-line, use atZoneSameInstant(ZoneId).
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    zone - the time-zone to use, not null
    
    Returns:
    the zoned date-time formed from this date and the earliest valid time for the zone, not null
  - atZoneSimilarLocal
```
public ZonedDateTime atZoneSimilarLocal(ZoneId zone,
                               ZoneResolver resolver)
```
    Returns a zoned date-time formed from this date-time and the specified time-zone taking control of what occurs in time-line gaps and overlaps.
    Time-zone rules, such as daylight savings, mean that not every time on the local time-line exists. If the local date-time is in a gap or overlap according to the rules then the resolver is used to determine the resultant local time and offset.
    To create a zoned date-time at the same instant irrespective of the local time-line, use atZoneSameInstant(ZoneId).
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    zone - the time-zone to use, not null
    resolver - the zone resolver to use for gaps and overlaps, not null
    
    Returns:
    the zoned date-time formed from this date and the earliest valid time for the zone, not null
    
    Throws:
    
    CalendricalException - if the date-time cannot be resolved
  - extract
```
public <R> R extract(java.lang.Class<R> type)
```
    Extracts date-time information in a generic way.
    This method exists to fulfill the CalendricalObject interface. This implementation returns the following types:
    - LocalDate
    - LocalTime
    - LocalDateTime
    - OffsetDate
    - OffsetTime
    - OffsetDateTime
    - ZoneOffset
    - Instant
    - DateTimeBuilder
    - Class, returning OffsetDateTime
    Specified by:
    
    extract in interface CalendricalObject
    
    Type Parameters:
    R - the type to extract
    Parameters:
    type - the type to extract, null returns null
    
    Returns:
    the extracted object, null if unable to extract
  - with
```
public OffsetDateTime with(CalendricalAdjuster adjuster)
```
    Description copied from interface: CalendricalObject
    Returns a copy of this calendrical with the specified calendrical set.
    This allows the manipulation of a calendrical in a general way. For example, if this calendrical is a LocalDateTime and the specified calendrical is a LocalDate, then the implementation will return a new LocalDateTime with the date changed.
    An implementation must handle the following types if possible:
    - DateAdjuster
    - TimeAdjuster
    - LocalDate
    - LocalTime
    - LocalDateTime
    - OffsetDate
    - OffsetTime
    - OffsetDateTime
    - ZoneOffset
    - ZoneId
    - Instant
    - this object if the specified type is passed in
    Specified by:
    
    with in interface CalendricalObject
    
    Parameters:
    adjuster - the calendrical to set into this calendrical, null returns null
    
    Returns:
    a copy of this calendrical with the specified calendrical set, not null
  - toInstant
```
public Instant toInstant()
```
    Converts this date-time to an Instant.
    
    Returns:
    an Instant representing the same instant, not null
  - toLocalDate
```
public LocalDate toLocalDate()
```
    Converts this date-time to a LocalDate.
    
    Returns:
    a LocalDate representing the date fields of this date-time, not null
  - toLocalTime
```
public LocalTime toLocalTime()
```
    Converts this date-time to a LocalTime.
    
    Returns:
    a LocalTime representing the time fields of this date-time, not null
  - toLocalDateTime
```
public LocalDateTime toLocalDateTime()
```
    Converts this date-time to a LocalDateTime.
    
    Returns:
    a LocalDateTime representing the fields of this date-time, not null
  - toOffsetDate
```
public OffsetDate toOffsetDate()
```
    Converts this date-time to an OffsetDate.
    
    Returns:
    an OffsetDate representing the date and offset, not null
  - toOffsetTime
```
public OffsetTime toOffsetTime()
```
    Converts this date-time to an OffsetTime.
    
    Returns:
    an OffsetTime representing the time and offset, not null
  - toEpochSecond
```
public long toEpochSecond()
```
    Converts this date-time to the number of seconds from the epoch of 1970-01-01T00:00:00Z.
    Instants on the time-line after the epoch are positive, earlier are negative.
    
    Returns:
    the number of seconds from the epoch of 1970-01-01T00:00:00Z
  - compareTo
```
public int compareTo(OffsetDateTime other)
```
    Compares this OffsetDateTime to another date-time.
    The comparison is based on the instant then local date-time. This ordering is consistent with equals(). For example, the following is the comparator order:
    1. 2008-12-03T10:30+01:00
    2. 2008-12-03T11:00+01:00
    3. 2008-12-03T12:00+02:00
    4. 2008-12-03T11:30+01:00
    5. 2008-12-03T12:00+01:00
    6. 2008-12-03T12:30+01:00
    Values #2 and #3 represent the same instant on the time-line. When two values represent the same instant, the local date-time is compared to distinguish them. This step is needed to make the ordering consistent with equals().
    Specified by:
    
    compareTo in interface java.lang.Comparable<OffsetDateTime>
    
    Parameters:
    other - the other date-time to compare to, not null
    
    Returns:
    the comparator value, negative if less, positive if greater
  - isAfter
```
public boolean isAfter(OffsetDateTime other)
```
    Checks if the instant of this OffsetDateTime is after that of the specified date-time.
    This method differs from the comparison in compareTo(javax.time.OffsetDateTime) and equals(java.lang.Object) in that it only compares the instant of the date-time. This is equivalent to using dateTime1.toInstant().isAfter(dateTime2.toInstant());.
    
    Parameters:
    other - the other date-time to compare to, not null
    
    Returns:
    true if this is after the instant of the specified date-time
  - isBefore
```
public boolean isBefore(OffsetDateTime other)
```
    Checks if the instant of this OffsetDateTime is before that of the specified date-time.
    This method differs from the comparison in compareTo(javax.time.OffsetDateTime) in that it only compares the instant of the date-time. This is equivalent to using dateTime1.toInstant().isBefore(dateTime2.toInstant());.
    
    Parameters:
    other - the other date-time to compare to, not null
    
    Returns:
    true if this is before the instant of the specified date-time
  - equalInstant
```
public boolean equalInstant(OffsetDateTime other)
```
    Checks if the instant of this OffsetDateTime is equal to that of the specified date-time.
    This method differs from the comparison in compareTo(javax.time.OffsetDateTime) and equals(java.lang.Object) in that it only compares the instant of the date-time. This is equivalent to using dateTime1.toInstant().equals(dateTime2.toInstant());.
    
    Parameters:
    other - the other date-time to compare to, not null
    
    Returns:
    true if the instant equals the instant of the specified date-time
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Checks if this date-time is equal to another date-time.
    The comparison is based on the local date-time and the offset. To compare for the same instant on the time-line, use equalInstant(javax.time.OffsetDateTime).
    
    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 date-time
  - hashCode
```
public int hashCode()
```
    A hash code for this date-time.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    a suitable hash code
  - toString
```
public java.lang.String toString()
```
    Outputs this date-time as a String, such as 2007-12-03T10:15:30+01:00.
    The output will be one of the following ISO-8601 formats:
    - yyyy-MM-dd'T'HH:mmXXXXX
    - yyyy-MM-dd'T'HH:mm:ssXXXXX
    - yyyy-MM-dd'T'HH:mm:ssfnnnXXXXX
    - yyyy-MM-dd'T'HH:mm:ssfnnnnnnXXXXX
    - yyyy-MM-dd'T'HH:mm:ssfnnnnnnnnnXXXXX
    The format used will be the shortest that outputs the full value of the time where the omitted parts are implied to be zero.
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    a string representation of this date-time, not null
  - toString
```
public java.lang.String toString(CalendricalFormatter formatter)
```
    Outputs this date-time as a String using the formatter.
    
    Parameters:
    formatter - the formatter to use, not null
    
    Returns:
    the formatted date-time string, not null
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the formatter cannot print
    
    CalendricalException - if an error occurs during printing

Class OffsetDateTime

Implementation notes

Method Summary

Methods inherited from class java.lang.Object

Method Detail

now

now

ofMidnight

ofMidnight

ofMidnight

of

of

of

of

of

of

of

of

of

ofInstantUTC

ofInstant

ofEpochSecond

from

parse

parse

get

getOffset

withOffsetSameLocal

withOffsetSameInstant

getYear

getMonth

getMonthOfYear

getDayOfMonth

getDayOfYear

getDayOfWeek

getHourOfDay

getMinuteOfHour

getSecondOfMinute

getNanoOfSecond

isLeapYear

with

withYear

withMonthOfYear

withDayOfMonth

withDayOfYear

withDate

withDate

withHourOfDay

withMinuteOfHour

withSecondOfMinute

withNanoOfSecond

withTime

withTime

withTime

plus

plus

plus

plusYears

plusMonths

plusWeeks

plusDays

plusHours

plusMinutes

plusSeconds

plusNanos

minus

minus

minus

minusYears

minusMonths

minusWeeks

minusDays

minusHours

minusMinutes

minusSeconds

minusNanos

atZoneSameInstant

atZoneSimilarLocal

atZoneSimilarLocal

extract