Period (ThreeTen Date and Time API)

java.lang.Object
- java.time.Period

All Implemented Interfaces:

java.io.Serializable, TemporalAdder, TemporalSubtractor
```
public final class Period
extends java.lang.Object
implements TemporalAdder, TemporalSubtractor, java.io.Serializable
```
A period of time, measured using the most common units, such as '3 Months, 4 Days and 7 Hours'.
A Period represents an amount of time measured in terms of the most commonly used units:
- YEARS
- MONTHS
- DAYS
- time units with an exact duration
The period may be used with any calendar system with the exception is methods with an "ISO" suffix. The meaning of a "year" or a "month" is only applied when the object is added to a date.
The period is modeled as a directed amount of time, meaning that individual parts of the period may be negative.
Specification for implementors
This class is immutable and thread-safe. The maximum number of hours that can be stored is about 2.5 million, limited by storing a single long nanoseconds for all time units internally.
Since:

1.8

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static Period ZERO
A constant for a period of zero.

Fields
Modifier and Type	Field and Description
`static Period`	`ZERO` A constant for a period of zero.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Temporal`	`addTo(Temporal temporal)` Adds this period to the specified temporal object.
`static Period`	`between(TemporalAccessor start, TemporalAccessor end)` Returns a `Period` consisting of the number of years, months, days, hours, minutes, seconds, and nanoseconds between two `TemporalAccessor` instances.
`static Period`	`betweenISO(LocalDate startDate, LocalDate endDate)` Obtains a `Period` consisting of the number of years, months, and days between two dates.
`static Period`	`betweenISO(LocalTime startTime, LocalTime endTime)` Obtains a `Period` consisting of the number of hours, minutes, seconds and nanoseconds between two times.
`boolean`	`equals(java.lang.Object obj)` Checks if this period is equal to another period.
`int`	`getDays()` Gets the amount of days of this period.
`int`	`getHours()` Gets the amount of hours of this period.
`int`	`getMinutes()` Gets the amount of minutes within an hour of this period.
`int`	`getMonths()` Gets the amount of months of this period.
`int`	`getNanos()` Gets the amount of nanoseconds within a second of this period.
`int`	`getSeconds()` Gets the amount of seconds within a minute of this period.
`long`	`getTimeNanos()` Gets the total amount of the time units of this period, measured in nanoseconds.
`int`	`getYears()` Gets the amount of years of this period.
`int`	`hashCode()` A hash code for this period.
`boolean`	`isPositive()` Checks if this period is fully positive, excluding zero.
`boolean`	`isZero()` Checks if this period is zero-length.
`Period`	`minus(long amount, TemporalUnit unit)` Returns a copy of this period with the specified period subtracted.
`Period`	`minus(Period other)` Returns a copy of this period with the specified period subtracted.
`Period`	`minusDays(long amount)`
`Period`	`minusHours(long amount)`
`Period`	`minusMinutes(long amount)`
`Period`	`minusMonths(long amount)`
`Period`	`minusNanos(long amount)`
`Period`	`minusSeconds(long amount)`
`Period`	`minusYears(long amount)`
`Period`	`multipliedBy(int scalar)` Returns a new instance with each element in this period multiplied by the specified scalar.
`Period`	`negated()` Returns a new instance with each amount in this period negated.
`Period`	`normalizedDaysToHours()` Returns a copy of this period with any days converted to hours using a 24 hour day.
`Period`	`normalizedHoursToDays()` Returns a copy of this period with the days and hours normalized using a 24 hour day.
`Period`	`normalizedMonthsISO()` Returns a copy of this period with the years and months normalized using a 12 month year.
`static Period`	`of(Duration duration)` Obtains a `Period` from a `Duration`.
`static Period`	`of(int years, int months, int days, int hours, int minutes, int seconds)` Obtains a `Period` from date-based and time-based fields.
`static Period`	`of(int years, int months, int days, int hours, int minutes, int seconds, long nanos)` Obtains a `Period` from date-based and time-based fields.
`static Period`	`of(long amount, TemporalUnit unit)` Obtains an instance of `Period` from a period in the specified unit.
`static Period`	`ofDate(int years, int months, int days)` Obtains a `Period` from date-based fields.
`static Period`	`ofTime(int hours, int minutes, int seconds)` Obtains a `Period` from time-based fields.
`static Period`	`ofTime(int hours, int minutes, int seconds, long nanos)` Obtains a `Period` from time-based fields.
`static Period`	`parse(java.lang.CharSequence text)` Obtains a `Period` from a text string such as `PnYnMnDTnHnMn.nS`.
`Period`	`plus(long amount, TemporalUnit unit)` Returns a copy of this period with the specified period added.
`Period`	`plus(Period other)` Returns a copy of this period with the specified period added.
`Period`	`plusDays(long amount)`
`Period`	`plusHours(long amount)`
`Period`	`plusMinutes(long amount)`
`Period`	`plusMonths(long amount)`
`Period`	`plusNanos(long amount)`
`Period`	`plusSeconds(long amount)`
`Period`	`plusYears(long amount)`
`Temporal`	`subtractFrom(Temporal temporal)` Subtracts this period from the specified temporal object.
`Period`	`toDateOnly()` Converts this period to one that only has date units.
`Duration`	`toDuration()` Calculates the duration of this period.
`java.lang.String`	`toString()` Outputs this period as a `String`, such as `P6Y3M1DT12H`.
`Period`	`toTimeOnly()` Converts this period to one that only has time units.
`Period`	`withDays(int days)` Returns a copy of this period with the specified amount of days.
`Period`	`withMonths(int months)` Returns a copy of this period with the specified amount of months.
`Period`	`withTimeNanos(long nanos)` Returns a copy of this period with the specified total amount of time units expressed in nanoseconds.
`Period`	`withYears(int years)` Returns a copy of this period with the specified amount of years.

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

- Field Detail
  - ZERO
```
public static final Period ZERO
```
    A constant for a period of zero.
- Method Detail
  - of
```
public static Period of(int years,
        int months,
        int days,
        int hours,
        int minutes,
        int seconds)
```
    Obtains a Period from date-based and time-based fields.
    This creates an instance based on years, months, days, hours, minutes and seconds. Within a period, the time fields are always normalized.
    
    Parameters:
    years - the amount of years, may be negative
    months - the amount of months, may be negative
    days - the amount of days, may be negative
    hours - the amount of hours, may be negative
    minutes - the amount of minutes, may be negative
    seconds - the amount of seconds, may be negative
    
    Returns:
    the period, not null
  - of
```
public static Period of(int years,
        int months,
        int days,
        int hours,
        int minutes,
        int seconds,
        long nanos)
```
    Obtains a Period from date-based and time-based fields.
    This creates an instance based on years, months, days, hours, minutes, seconds and nanoseconds. Within a period, the time fields are always normalized.
    
    Parameters:
    years - the amount of years, may be negative
    months - the amount of months, may be negative
    days - the amount of days, may be negative
    hours - the amount of hours, may be negative
    minutes - the amount of minutes, may be negative
    seconds - the amount of seconds, may be negative
    nanos - the amount of nanos, may be negative
    
    Returns:
    the period, not null
  - ofDate
```
public static Period ofDate(int years,
            int months,
            int days)
```
    Obtains a Period from date-based fields.
    This creates an instance based on years, months and days.
    
    Parameters:
    years - the amount of years, may be negative
    months - the amount of months, may be negative
    days - the amount of days, may be negative
    
    Returns:
    the period, not null
  - ofTime
```
public static Period ofTime(int hours,
            int minutes,
            int seconds)
```
    Obtains a Period from time-based fields.
    This creates an instance based on hours, minutes and seconds. Within a period, the time fields are always normalized.
    
    Parameters:
    hours - the amount of hours, may be negative
    minutes - the amount of minutes, may be negative
    seconds - the amount of seconds, may be negative
    
    Returns:
    the period, not null
  - ofTime
```
public static Period ofTime(int hours,
            int minutes,
            int seconds,
            long nanos)
```
    Obtains a Period from time-based fields.
    This creates an instance based on hours, minutes, seconds and nanoseconds. Within a period, the time fields are always normalized.
    
    Parameters:
    hours - the amount of hours, may be negative
    minutes - the amount of minutes, may be negative
    seconds - the amount of seconds, may be negative
    nanos - the amount of nanos, may be negative
    
    Returns:
    the period, not null
  - of
```
public static Period of(long amount,
        TemporalUnit unit)
```
    Obtains an instance of Period from a period in the specified unit.
    The parameters represent the two parts of a phrase like '6 Days'. For example:
```
  Period.of(3, SECONDS);
  Period.of(5, YEARS);
 
```
    The specified unit must be one of the supported units from ChronoUnit, YEARS, MONTHS or DAYS or be a time unit with an exact duration. Other units throw an exception.
    Parameters:
    amount - the amount of the period, measured in terms of the unit, positive or negative
    unit - the unit that the period is measured in, must have an exact duration, not null
    
    Returns:
    the period, not null
    
    Throws:
    
    DateTimeException - if the period unit is invalid
    
    java.lang.ArithmeticException - if a numeric overflow occurs
  - of
```
public static Period of(Duration duration)
```
    Obtains a Period from a Duration.
    This converts the duration to a period. Within a period, the time fields are always normalized. The years, months and days fields will be zero.
    To populate the days field, call normalizedHoursToDays() on the created period.
    
    Parameters:
    duration - the duration to convert, not null
    
    Returns:
    the period, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - between
```
public static Period between(TemporalAccessor start,
             TemporalAccessor end)
```
    Returns a Period consisting of the number of years, months, days, hours, minutes, seconds, and nanoseconds between two TemporalAccessor instances.
    The start date is included, but the end date is not. Only whole years count. For example, from 2010-01-15 to 2011-03-18 is one year, two months and three days.
    This method examines the fields YEAR, MONTH_OF_YEAR, DAY_OF_MONTH and NANO_OF_DAY The difference between each of the fields is calculated independently from the others. At least one of the four fields must be present.
    The four units are typically retained without normalization. However, years and months are normalized if the range of months is fixed, as it is with ISO.
    The result of this method can be a negative period if the end is before the start. The negative sign can be different in each of the four major units.
    
    Parameters:
    start - the start date, inclusive, not null
    end - the end date, exclusive, not null
    
    Returns:
    the period between the date-times, not null
    
    Throws:
    
    DateTimeException - if the two date-times do have similar available fields
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - betweenISO
```
public static Period betweenISO(LocalDate startDate,
                LocalDate endDate)
```
    Obtains a Period consisting of the number of years, months, and days between two dates.
    The start date is included, but the end date is not. The period is calculated by removing complete months, then calculating the remaining number of days, adjusting to ensure that both have the same sign. The number of months is then split into years and months based on a 12 month year. A month is considered if the end day-of-month is greater than or equal to the start day-of-month. For example, from 2010-01-15 to 2011-03-18 is one year, two months and three days.
    The result of this method can be a negative period if the end is before the start. The negative sign will be the same in each of year, month and day.
    
    Parameters:
    startDate - the start date, inclusive, not null
    endDate - the end date, exclusive, not null
    
    Returns:
    the period between the dates, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - betweenISO
```
public static Period betweenISO(LocalTime startTime,
                LocalTime endTime)
```
    Obtains a Period consisting of the number of hours, minutes, seconds and nanoseconds between two times.
    The start time is included, but the end time is not. The period is calculated from the difference between the nano-of-day values of the two times. For example, from 13:45:00 to 14:50:30.123456789 is P1H5M30.123456789S.
    The result of this method can be a negative period if the end is before the start.
    
    Parameters:
    startTime - the start time, inclusive, not null
    endTime - the end time, exclusive, not null
    
    Returns:
    the period between the times, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - parse
```
public static Period parse(java.lang.CharSequence text)
```
    Obtains a Period from a text string such as PnYnMnDTnHnMn.nS.
    This will parse the string produced by toString() which is a subset of the ISO-8601 period format PnYnMnDTnHnMn.nS.
    The string consists of a series of numbers with a suffix identifying their meaning. The values, and suffixes, must be in the sequence year, month, day, hour, minute, second. Any of the number/suffix pairs may be omitted providing at least one is present. If the period is zero, the value is normally represented as PT0S. The numbers must consist of ASCII digits. Any of the numbers may be negative. Negative zero is not accepted. The number of nanoseconds is expressed as an optional fraction of the seconds. There must be at least one digit before any decimal point. There must be between 1 and 9 inclusive digits after any decimal point. The letters will all be accepted in upper or lower case. The decimal point may be either a dot or a comma.
    
    Parameters:
    text - the text to parse, not null
    
    Returns:
    the parsed period, not null
    
    Throws:
    
    DateTimeParseException - if the text cannot be parsed to a period
  - isZero
```
public boolean isZero()
```
    Checks if this period is zero-length.
    
    Returns:
    true if this period is zero-length
  - isPositive
```
public boolean isPositive()
```
    Checks if this period is fully positive, excluding zero.
    This checks whether all the amounts in the period are positive, defined as greater than zero.
    
    Returns:
    true if this period is fully positive excluding zero
  - getYears
```
public int getYears()
```
    Gets the amount of years of this period.
    
    Returns:
    the amount of years of this period
  - getMonths
```
public int getMonths()
```
    Gets the amount of months of this period.
    
    Returns:
    the amount of months of this period
  - getDays
```
public int getDays()
```
    Gets the amount of days of this period.
    
    Returns:
    the amount of days of this period
  - getHours
```
public int getHours()
```
    Gets the amount of hours of this period.
    Within a period, the time fields are always normalized.
    
    Returns:
    the amount of hours of this period
  - getMinutes
```
public int getMinutes()
```
    Gets the amount of minutes within an hour of this period.
    Within a period, the time fields are always normalized.
    
    Returns:
    the amount of minutes within an hour of this period
  - getSeconds
```
public int getSeconds()
```
    Gets the amount of seconds within a minute of this period.
    Within a period, the time fields are always normalized.
    
    Returns:
    the amount of seconds within a minute of this period
  - getNanos
```
public int getNanos()
```
    Gets the amount of nanoseconds within a second of this period.
    Within a period, the time fields are always normalized.
    
    Returns:
    the amount of nanoseconds within a second of this period
  - getTimeNanos
```
public long getTimeNanos()
```
    Gets the total amount of the time units of this period, measured in nanoseconds.
    Within a period, the time fields are always normalized.
    
    Returns:
    the total amount of time unit nanoseconds of this period
  - withYears
```
public Period withYears(int years)
```
    Returns a copy of this period with the specified amount of years.
    This method will only affect the years field. All other units are unaffected.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    years - the years to represent
    
    Returns:
    a Period based on this period with the requested years, not null
  - withMonths
```
public Period withMonths(int months)
```
    Returns a copy of this period with the specified amount of months.
    This method will only affect the months field. All other units are unaffected.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    months - the months to represent
    
    Returns:
    a Period based on this period with the requested months, not null
  - withDays
```
public Period withDays(int days)
```
    Returns a copy of this period with the specified amount of days.
    This method will only affect the days field. All other units are unaffected.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    days - the days to represent
    
    Returns:
    a Period based on this period with the requested days, not null
  - withTimeNanos
```
public Period withTimeNanos(long nanos)
```
    Returns a copy of this period with the specified total amount of time units expressed in nanoseconds.
    Within a period, the time fields are always normalized. This method will affect all the time units - hours, minutes, seconds and nanos. The date units are unaffected.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    nanos - the nanoseconds to represent
    
    Returns:
    a Period based on this period with the requested nanoseconds, not null
  - plus
```
public Period plus(Period other)
```
    Returns a copy of this period with the specified period added.
    This operates separately on the years, months, days and the normalized time. There is no further normalization beyond the normalized time.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    other - the period to add, not null
    
    Returns:
    a Period based on this period with the requested period added, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - plus
```
public Period plus(long amount,
          TemporalUnit unit)
```
    Returns a copy of this period with the specified period added.
    The specified unit must be one of the supported units from ChronoUnit, YEARS, MONTHS or DAYS or be a time unit with an exact duration. Other units throw an exception.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    amount - the amount to add, positive or negative
    unit - the unit that the amount is expressed in, not null
    
    Returns:
    a Period based on this period with the requested amount added, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - plusYears
```
public Period plusYears(long amount)
```
  - plusMonths
```
public Period plusMonths(long amount)
```
  - plusDays
```
public Period plusDays(long amount)
```
  - plusHours
```
public Period plusHours(long amount)
```
  - plusMinutes
```
public Period plusMinutes(long amount)
```
  - plusSeconds
```
public Period plusSeconds(long amount)
```
  - plusNanos
```
public Period plusNanos(long amount)
```
  - minus
```
public Period minus(Period other)
```
    Returns a copy of this period with the specified period subtracted.
    This operates separately on the years, months, days and the normalized time. There is no further normalization beyond the normalized time.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    other - the period to subtract, not null
    
    Returns:
    a Period based on this period with the requested period subtracted, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - minus
```
public Period minus(long amount,
           TemporalUnit unit)
```
    Returns a copy of this period with the specified period subtracted.
    The specified unit must be one of the supported units from ChronoUnit, YEARS, MONTHS or DAYS or be a time unit with an exact duration. Other units throw an exception.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    amount - the amount to subtract, positive or negative
    unit - the unit that the amount is expressed in, not null
    
    Returns:
    a Period based on this period with the requested amount subtracted, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - minusYears
```
public Period minusYears(long amount)
```
  - minusMonths
```
public Period minusMonths(long amount)
```
  - minusDays
```
public Period minusDays(long amount)
```
  - minusHours
```
public Period minusHours(long amount)
```
  - minusMinutes
```
public Period minusMinutes(long amount)
```
  - minusSeconds
```
public Period minusSeconds(long amount)
```
  - minusNanos
```
public Period minusNanos(long amount)
```
  - multipliedBy
```
public Period multipliedBy(int scalar)
```
    Returns a new instance with each element in this period multiplied by the specified scalar.
    This simply multiplies each field, years, months, days and normalized time, by the scalar. No normalization is performed.
    
    Parameters:
    scalar - the scalar to multiply by, not null
    
    Returns:
    a Period based on this period with the amounts multiplied by the scalar, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - negated
```
public Period negated()
```
    Returns a new instance with each amount in this period negated.
    
    Returns:
    a Period based on this period with the amounts negated, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - normalizedHoursToDays
```
public Period normalizedHoursToDays()
```
    Returns a copy of this period with the days and hours normalized using a 24 hour day.
    This normalizes the days and hours units, leaving years and months unchanged. The hours unit is adjusted to have an absolute value less than 23, with the days unit being adjusted to compensate. For example, a period of P1DT27H will be normalized to P2DT3H.
    The sign of the days and hours units will be the same after normalization. For example, a period of P1DT-51H will be normalized to P-1DT-3H. Since all time units are always normalized, if the hours units changes sign then other time units will also be affected.
    This instance is immutable and unaffected by this method call.
    
    Returns:
    a Period based on this period with excess hours normalized to days, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - normalizedDaysToHours
```
public Period normalizedDaysToHours()
```
    Returns a copy of this period with any days converted to hours using a 24 hour day.
    The days unit is reduced to zero, with the hours unit increased by 24 times the days unit to compensate. Other units are unaffected. For example, a period of P2DT4H will be normalized to PT52H.
    This instance is immutable and unaffected by this method call.
    
    Returns:
    a Period based on this period with days normalized to hours, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - normalizedMonthsISO
```
public Period normalizedMonthsISO()
```
    Returns a copy of this period with the years and months normalized using a 12 month year.
    This normalizes the years and months units, leaving other units unchanged. The months unit is adjusted to have an absolute value less than 11, with the years unit being adjusted to compensate. For example, a period of P1Y15M will be normalized to P2Y3M.
    The sign of the years and months units will be the same after normalization. For example, a period of P1Y-25M will be normalized to P-1Y-1M.
    This normalization uses a 12 month year it is not valid for all calendar systems.
    This instance is immutable and unaffected by this method call.
    
    Returns:
    a Period based on this period with years and months normalized, not null
    
    Throws:
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - toDateOnly
```
public Period toDateOnly()
```
    Converts this period to one that only has date units.
    The resulting period will have the same years, months and days as this period but the time units will all be zero. No normalization occurs in the calculation. For example, a period of P1Y3MT12H will be converted to P1Y3M.
    This instance is immutable and unaffected by this method call.
    
    Returns:
    a Period based on this period with the time units set to zero, not null
  - addTo
```
public Temporal addTo(Temporal temporal)
```
    Adds this period to the specified temporal object.
    This returns a temporal object of the same observable type as the input with this period added.
    In most cases, it is clearer to reverse the calling pattern by using Temporal.plus(TemporalAdder).
```
   // these two lines are equivalent, but the second approach is recommended
   dateTime = thisPeriod.addTo(dateTime);
   dateTime = dateTime.plus(thisPeriod);
 
```
    The calculation will add the years, then months, then days, then nanos. Only non-zero amounts will be added. If the date-time has a calendar system with a fixed number of months in a year, then the years and months will be combined before being added.
    This instance is immutable and unaffected by this method call.
    Specified by:
    
    addTo in interface TemporalAdder
    
    Parameters:
    temporal - the temporal object to adjust, not null
    
    Returns:
    an object of the same type with the adjustment made, not null
    
    Throws:
    
    DateTimeException - if unable to add
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - subtractFrom
```
public Temporal subtractFrom(Temporal temporal)
```
    Subtracts this period from the specified temporal object.
    This returns a temporal object of the same observable type as the input with this period subtracted.
    In most cases, it is clearer to reverse the calling pattern by using Temporal.minus(TemporalSubtractor).
```
   // these two lines are equivalent, but the second approach is recommended
   dateTime = thisPeriod.subtractFrom(dateTime);
   dateTime = dateTime.minus(thisPeriod);
 
```
    The calculation will subtract the years, then months, then days, then nanos. Only non-zero amounts will be subtracted. If the date-time has a calendar system with a fixed number of months in a year, then the years and months will be combined before being subtracted.
    This instance is immutable and unaffected by this method call.
    Specified by:
    
    subtractFrom in interface TemporalSubtractor
    
    Parameters:
    temporal - the temporal object to adjust, not null
    
    Returns:
    an object of the same type with the adjustment made, not null
    
    Throws:
    
    DateTimeException - if unable to subtract
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - toTimeOnly
```
public Period toTimeOnly()
```
    Converts this period to one that only has time units.
    The resulting period will have the same time units as this period but the date units will all be zero. No normalization occurs in the calculation. For example, a period of P1Y3MT12H will be converted to PT12H.
    This instance is immutable and unaffected by this method call.
    
    Returns:
    a Period based on this period with the date units set to zero, not null
  - toDuration
```
public Duration toDuration()
```
    Calculates the duration of this period.
    The calculation uses the hours, minutes, seconds and nanoseconds fields. If years, months or days are present an exception is thrown. See toTimeOnly() for a way to remove the date units and normalizedDaysToHours() for a way to convert days to hours.
    
    Returns:
    a Duration equivalent to this period, not null
    
    Throws:
    
    DateTimeException - if the period cannot be converted as it contains years, months or days
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Checks if this period is equal to another period.
    The comparison is based on the amounts held in the period. To be equal, the years, months, days and normalized time fields must be equal.
    
    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 period
    See Also:
    Object.hashCode(), HashMap
  - hashCode
```
public int hashCode()
```
    A hash code for this period.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    a suitable hash code
    See Also:
    Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)
  - toString
```
public java.lang.String toString()
```
    Outputs this period as a String, such as P6Y3M1DT12H.
    The output will be in the ISO-8601 period format.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    a string representation of this period, not null

Class Period

Specification for implementors

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

Method Detail

of

of

ofDate

ofTime

ofTime

of

of

between

betweenISO

betweenISO

parse

isZero

isPositive

getYears

getMonths

getDays

getHours

getMinutes

getSeconds

getNanos

getTimeNanos

withYears

withMonths

withDays

withTimeNanos

plus

plus

plusYears

plusMonths

plusDays

plusHours

plusMinutes

plusSeconds

plusNanos

minus

minus

minusYears

minusMonths

minusDays

minusHours

minusMinutes

minusSeconds

minusNanos

multipliedBy

negated

normalizedHoursToDays

normalizedDaysToHours

normalizedMonthsISO

toDateOnly

addTo

subtractFrom

toTimeOnly

toDuration

equals

hashCode

toString