SimplePeriod (ThreeTen backport 0.7.2 API)

java.lang.Object
- org.threeten.bp.temporal.SimplePeriod

All Implemented Interfaces:

Serializable, Comparable<SimplePeriod>, TemporalAdder, TemporalSubtractor
```
public final class SimplePeriod
extends Object
implements TemporalAdder, TemporalSubtractor, Comparable<SimplePeriod>, Serializable
```
A period of time, measured as an amount of a single unit, such as '3 Months'.
A SimplePeriod represents an amount of time measured in terms of a single unit. Any unit may be used with this class. An alternative period implementation is Period, which allows a combination of date and time units.
This class is the return type from TemporalUnit.between(R, R). It can be used more generally, but is designed to enable the following code:
```
  date = date.minus(MONTHS.between(start, end));
 
```
The unit determines which calendar systems it can be added to.
The period is modeled as a directed amount of time, meaning that the period may be negative. See abs() to ensure the period is positive.
Specification for implementors
This class is immutable and thread-safe, providing that the unit is immutable, which it is required to be.
See Also:
Serialized Form

Method Summary

Methods
Modifier and Type	Method and Description
`SimplePeriod`	`abs()` Returns a copy of this period with a positive amount.
`Temporal`	`addTo(Temporal temporal)` Adds this period to the specified temporal object.
`int`	`compareTo(SimplePeriod other)` Compares this `SimplePeriod` to another period.
`boolean`	`equals(Object obj)` Checks if this period is equal to another period.
`long`	`getAmount()` Gets the amount of this period.
`TemporalUnit`	`getUnit()` Gets the unit of this period.
`int`	`hashCode()` A hash code for this period.
`static SimplePeriod`	`of(long amount, TemporalUnit unit)` Obtains an instance of `SimplePeriod` from a period in the specified unit.
`Temporal`	`subtractFrom(Temporal temporal)` Subtracts this period to the specified temporal object.
`String`	`toString()` Outputs this period as a `String`, such as `2 Months`.

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

- Method Detail
  - of
```
public static SimplePeriod of(long amount,
              TemporalUnit unit)
```
    Obtains an instance of SimplePeriod from a period in the specified unit.
    The parameters represent the two parts of a phrase like '6 Days'. For example:
```
  SimplePeriod.of(3, SECONDS);
  SimplePeriod.of(5, YEARS);
 
```
    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, not null
    
    Returns:
    the period, not null
  - getAmount
```
public long getAmount()
```
    Gets the amount of this period.
    In the phrase "2 Months", the amount is 2.
    
    Returns:
    the amount of the period, may be negative
  - getUnit
```
public TemporalUnit getUnit()
```
    Gets the unit of this period.
    In the phrase "2 Months", the unit is "Months".
    
    Returns:
    the unit of the period, 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 is equivalent to invoking Temporal.plus(long, TemporalUnit).
    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
    
    ArithmeticException - if numeric overflow occurs
  - subtractFrom
```
public Temporal subtractFrom(Temporal temporal)
```
    Subtracts this period to 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.plus(TemporalAdder).
```
   // these two lines are equivalent, but the second approach is recommended
   dateTime = thisPeriod.subtractFrom(dateTime);
   dateTime = dateTime.minus(thisPeriod);
 
```
    The calculation is equivalent to invoking Temporal.minus(long, TemporalUnit).
    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
    
    ArithmeticException - if numeric overflow occurs
  - abs
```
public SimplePeriod abs()
```
    Returns a copy of this period with a positive amount.
    This returns a period with the absolute value of the amount and the same unit. If the amount of this period is positive or zero, then this period is returned. If the amount of this period is negative, then a period with the negated amount is returned. If the amount equals Long.MIN_VALUE, an ArithmeticException is thrown
    This is useful to convert the result of TemporalUnit.between(R, R) to a positive amount when you do not know which date is the earlier and which is the later.
    
    Returns:
    a period with a positive amount and the same unit, not null
    
    Throws:
    
    ArithmeticException - if the amount is Long.MIN_VALUE
  - compareTo
```
public int compareTo(SimplePeriod other)
```
    Compares this SimplePeriod to another period.
    The comparison is based on the amount within the unit. Only two periods with the same unit can be compared.
    
    Specified by:
    
    compareTo in interface Comparable<SimplePeriod>
    
    Parameters:
    other - the other period to compare to, not null
    
    Returns:
    the comparator value, negative if less, positive if greater
    
    Throws:
    
    IllegalArgumentException - if the units do not match
  - equals
```
public boolean equals(Object obj)
```
    Checks if this period is equal to another period.
    The comparison is based on the amount and unit.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    obj - the object to check, null returns false
    
    Returns:
    true if this is equal to the other period
  - hashCode
```
public int hashCode()
```
    A hash code for this period.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    a suitable hash code
  - toString
```
public String toString()
```
    Outputs this period as a String, such as 2 Months.
    The string consists of the amount, then a space, then the unit name.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    a string representation of this period, not null

Class SimplePeriod

Specification for implementors

Method Summary

Methods inherited from class java.lang.Object

Method Detail

of

getAmount

getUnit

addTo

subtractFrom

abs

compareTo

equals

hashCode

toString