codestory

Die Anleitung zu Java Period

  1. Period
  2. Static Factory Methods
  3. Other methods
  4. get(TemporalUnit)
  5. getX() *
  6. getUnits()
  7. getChronology()
  8. withX(..) *
  9. plus(TemporalAmount)
  10. plusX(..) *
  11. minus(TemporalAmount)
  12. minusX(..) *
  13. isZero()
  14. isNegative()
  15. multipliedBy(int)
  16. negated()
  17. normalized()
  18. toTotalMonths()
  19. addTo(Temporal)
  20. subtractFrom(Temporal)

1. Period

Die Klasse Period verwendet Jahr-, Monats- und Tageseinheiten, um einen Zeitraum darzustellen. Zum Beispiel "3 Jahre 2 Monate 15 Tage". Wenn Sie eine Zeitdauer basierend auf Stunden, Minuten und Sekunden wünschen, verwenden Sie die Klasse Duration.
Die Jahres-, Monats- und Tageswerte in der Period sind unabhängig, d. h. wenn Sie der Period einige Tage hinzufügen oder davon subtrahieren, hat dies keinen Einfluss auf Jahr und Monat. Der Grund dafür ist, dass die Länge des Monats und des Jahres nicht festgelegt ist.
public final class Period implements ChronoPeriod, Serializable
Beispiel: Fußballspieler Cristiano Ronaldo wurde am 5. Februar 1985 geboren. Am 29. September 2002 debütierte Ronaldo in der Primeira Liga, war also 17 Jahre alt, und 7 Monate 24 Tage.
Period_ronaldo_ex1.java
// 1985-02-05 (Ronaldo's birthday).
LocalDate startInclusiveDate = LocalDate.of(1985, 2, 5);

// 2002-09-29 (First time playing in Primeira Liga ).
LocalDate endExclusiveDate = LocalDate.of(2002, 9, 29);

Period period = Period.between(startInclusiveDate, endExclusiveDate);

System.out.println(period); // P17Y7M24D
System.out.println("Years: " + period.getYears());  // 17
System.out.println("Months: " + period.getMonths()); // 7
System.out.println("Days: " + period.getDays()); // 24

2. Static Factory Methods

Statische Fabrikmethoden:
public static final Period ZERO = new Period(0, 0, 0);

public static Period ofYears(int years)  
public static Period ofMonths(int months)
public static Period ofWeeks(int weeks)
public static Period ofDays(int days)  
public static Period of(int years, int months, int days)
public static Period from(TemporalAmount amount)
public static Period parse(CharSequence text)  
public static Period between(LocalDate startDateInclusive, LocalDate endDateExclusive)

3. Other methods

Die weiteren Methode:
// -----------------------------------------------------------------
// getX()
// -----------------------------------------------------------------

// Inherited from ChronoPeriod interface
public long get(TemporalUnit unit)

// Inherited from ChronoPeriod interface
public List<TemporalUnit> getUnits()  

// Inherited from ChronoPeriod interface
public IsoChronology getChronology()

public int getYears()  
public int getMonths()  
public int getDays()  

// -----------------------------------------------------------------
// withX()
// -----------------------------------------------------------------

public Period withYears(int years)
public Period withMonths(int months)  
public Period withDays(int days)  

// -----------------------------------------------------------------
// plusX()
// -----------------------------------------------------------------

// Inherited from ChronoPeriod interface
public Period plus(TemporalAmount amountToAdd)

public Period plusYears(long yearsToAdd)  
public Period plusMonths(long monthsToAdd)
public Period plusDays(long daysToAdd)

// -----------------------------------------------------------------
// minusX()
// -----------------------------------------------------------------

// Inherited from ChronoPeriod interface
public Period minus(TemporalAmount amountToSubtract)  

public Period minusYears(long yearsToSubtract)  
public Period minusMonths(long monthsToSubtract)
public Period minusDays(long daysToSubtract)  

// -----------------------------------------------------------------

public long toTotalMonths()  

// -----------------------------------------------------------------
//  Other method inherited from ChronoPeriod interface
// -----------------------------------------------------------------
 
public boolean isZero()   
public boolean isNegative()   
public Period multipliedBy(int scalar)  
public Period negated()   
public Period normalized()  
public Temporal addTo(Temporal temporal)
public Temporal subtractFrom(Temporal temporal)

4. get(TemporalUnit)

Gibt den Wert der angegebenen Einheit zurück.
// Inherited from ChronoPeriod interface
public long get(TemporalUnit unit) {
Nur die folgenden drei Standardeinheiten werden unterstützt, die anderen lösen eine UnsupportedTemporalTypeException aus
  • ChronoUnit.YEARS
  • ChronoUnit.MONTHS
  • ChronoUnit.DAYS
Zum Beispiel:
Period_get_unit_ex1.java
// 20 years 5 months 115 days.
Period period = Period.of(20, 5, 115);

long years = period.get(ChronoUnit.YEARS); // 20
long months = period.get(ChronoUnit.MONTHS); // 5
long days = period.get(ChronoUnit.DAYS); // 115

System.out.printf("%d years, %d months %d days", years, months, days);

5. getX() *

Die Methode getDays() gibt die Anzahl der Tage zurück, die in diesem Period dargestellt werden. Die Tages-, Monats- und Jahreswerte in Period sind unabhängig voneinander, sie können nicht ineinander umgerechnet werden, da die Länge von Monat und Jahr nicht festgelegt ist.
Als Namen werden auch die Methoden getMonths(), getYears() verstanden.
public int getYears()  
public int getMonths()  
public int getDays()
Beispiel: Am 20. Juli 1969 landete die Raumsonde Apollo 11 auf dem Mond. Wir können berechnen, wie lange dieses Ereignis im Vergleich zur Gegenwart zurückliegt:
Period_getX_ex1.java
// 1969-07-20
LocalDate apollo11Date = LocalDate.of(1969, 7, 20);

// Now
LocalDate now = LocalDate.now();
System.out.println("Now is " + now);

Period period = Period.between(apollo11Date, now);

System.out.println(period);  
System.out.println("Years: " + period.getYears());   
System.out.println("Months: " + period.getMonths());  
System.out.println("Days: " + period.getDays());
Output:
Now is 2021-06-25
P51Y11M5D
Years: 51
Months: 11
Days: 5
Um die Anzahl der Jahre, Monate, Wochen oder Tage zwischen 2 verschiedenen Zeiten zu berechnen, können Sie auch die Klasse ChronoUnit verwenden. Siehe zum Beispiel:
ChronoUnit_between_ex1.java
// 1969-07-20
LocalDate apollo11Date = LocalDate.of(1969, 7, 20);

// Now
LocalDate now = LocalDate.now();
System.out.println("Now is " + now);

long years = ChronoUnit.YEARS.between(apollo11Date, now);
long months = ChronoUnit.MONTHS.between(apollo11Date, now);
long weeks = ChronoUnit.WEEKS.between(apollo11Date, now);
long days = ChronoUnit.DAYS.between(apollo11Date, now);

System.out.println("Years: " + years);
System.out.println("Months: " + months);
System.out.println("Weeks: " + weeks);
System.out.println("Days:" + days);
Output:
Now is 2021-06-25
Years: 51
Months: 623
Weeks: 2709
Days:18968

6. getUnits()

Gibt die von diesem Period unterstützte(n) TemporalUnit zurück. Nur die folgenden 3 Standard TemporalUnit werden unterstützt:
  • ChronoUnit.YEARS
  • ChronoUnit.MONTHS
  • ChronoUnit.DAYS
// Inherited from ChronoPeriod interface
public List<TemporalUnit> getUnits()
Zum Beispiel:
Period_getUnits_ex1.java
Period period = Period.of(2, 8, 0);  
// ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS
List<TemporalUnit> units = period.getUnits();

for(TemporalUnit unit: units)  {
    System.out.println("Unit: " + unit.getClass().getName() + " - " + unit);
}
Output:
Unit: java.time.temporal.ChronoUnit - Years
Unit: java.time.temporal.ChronoUnit - Months
Unit: java.time.temporal.ChronoUnit - Days

7. getChronology()

Gibt die Chronologie dieses Period zurück, das ist das Kalendersystem ISO (IsoChronology.INSTANCE)
// Inherited from ChronoPeriod interface
public IsoChronology getChronology()
Zum Beispiel:
Period_getChronology_ex1.java
Period period = Period.of(20,  5,  10);
IsoChronology isoChronology    = period.getChronology();
System.out.println("IsoChronology: " + isoChronology.getId()); // ISO.
  • Die Anleitung zu Java IsoChronology

8. withX(..) *

Die Methode withDays(days) gibt eine Kopie dieses Period zurück, wobei die Anzahl der Tage durch die angegebene Anzahl von Tagen ersetzt wird. Jahr und Monat werden von dieser Methode nicht beeinflusst.
Als Namen werden auch die Methoden withYears(years), withMonths(months) verstanden.
public Period withYears(int years)
public Period withMonths(int months)
public Period withDays(int days)
Zum Beispiel:
Period_withX_ex1.java
Period period = Period.of(20, 3, 15);
period = period.withDays(100);

System.out.println(period);
System.out.println("Years: " + period.getYears()); // 20
System.out.println("Months: " + period.getMonths()); // 3
System.out.println("Days: " + period.getDays()); // 100

9. plus(TemporalAmount)

Senden Sie eine Kopie dieses Period mit einer hinzugefügten Zeitdauer zurück.
public Period plus(TemporalAmount amountToAdd)
Die Werte für Tag, Monat und Jahr sind unabhängig voneinander, es wird keine Normalisierung durchgeführt. Wie zum Beispiel:
  • "2 years 10 months 110 days" + "3 years 5 months 10 days" --> "5 years 15 months 120 days".
Zum Beispiel:
Period_plus_amount_ex1.java
// 20 years 3 months 15 days.
Period period = Period.of(20, 3, 15);  
System.out.println("period: " + period); // P20Y3M15D

TemporalAmount amount = Period.ofMonths(15); // 15 months

Period period2 = period.plus(amount);
System.out.println("period2: " + period2); // P20Y18M15D (20 years, 18 months, 15 days)

10. plusX(..) *

Die Methode plusDays(daysToAdd) gibt eine Kopie dieses Period mit der angegebenen Anzahl von hinzugefügten Tagen zurück, was sich nicht auf die Jahres- und Monatswerte auswirkt.
Als Namen werden auch die Methoden plusYears(yearsToAdd) und plusMonths(monthsToAdd) verstanden
public Period plusYears(long yearsToAdd)  
public Period plusMonths(long monthsToAdd)
public Period plusDays(long daysToAdd)
Zum Beispiel:
Period_plusX_ex1.java
Period period = Period.of(20, 3, 15);  

// period1
Period period1 = period.plusDays(100);  

System.out.println("period1.getYears(): " + period1.getYears()); // 20
System.out.println("period1.getMonths(): " + period1.getMonths()); // 3
System.out.println("period1.getDays(): " + period1.getDays()); // 115
System.out.println(" ------- \n");

// period2
Period period2 = period.plusDays(-100);  

System.out.println("period2.getYears(): " + period2.getYears()); // 20
System.out.println("period2.getMonths(): " + period2.getMonths()); // 3
System.out.println("period2.getDays(): " + period2.getDays()); // -85
System.out.println(" ------- \n");

// period3
Period period3 = period.plusYears(-30);  

System.out.println("period3.getYears(): " + period3.getYears()); // -10
System.out.println("period3.getMonths(): " + period3.getMonths()); // 3
System.out.println("period3.getDays(): " + period3.getDays()); // 15
Output:
period1.getYears(): 20
period1.getMonths(): 3
period1.getDays(): 115
 -------

period2.getYears(): 20
period2.getMonths(): 3
period2.getDays(): -85
 -------

period3.getYears(): -10
period3.getMonths(): 3
period3.getDays(): 15

11. minus(TemporalAmount)

Geben Sie eine Kopie dieses Period mit der angegebenen Zeit subtrahiert zurück.
public Period minus(TemporalAmount amountToSubtract)
Die Werte für Tag, Monat und Jahr sind unabhängig voneinander, es wird keine Normalisierung durchgeführt. Wie zum Beispiel:
  • "2 years 10 months 110 days" - "3 years 5 months 10 days" --> "-1 years 10 months 90 days".
Zum Beispiel:
Period_minus_amount_ex1.java
// 20 years 3 months 15 days.
Period period = Period.of(20, 3, 15);  
System.out.println("period: " + period); // P20Y3M15D

TemporalAmount amount = Period.ofMonths(5); // 5 months

Period period2 = period.minus(amount);
System.out.println("period2: " + period2); // P20Y-2M15D (20 years, -2 months, 15 days)
  • Die Anleitung zu Java TemporalAmount

12. minusX(..) *

Die Methode minusDays(daysToSubtract) gibt eine Kopie dieser Period mit der angegebenen Anzahl von Tagen subtrahiert zurück, was sich nicht auf die anderen beiden Felder Jahr und Monat auswirkt.
Als Namen werden auch die Methoden minusYears(yearsToSubtract) und minusMonths(monthsToSubtract) verstanden.
public Period minusYears(long yearsToSubtract)  
public Period minusMonths(long monthsToSubtract)  
public Period minusDays(long daysToSubtract)
Zum Beispiel:
Period_minusX_ex1.java
Period period = Period.of(20, 3, 15);  

// period1
Period period1 = period.minusDays(100);  

System.out.println("period1.getYears(): " + period1.getYears()); // 20
System.out.println("period1.getMonths(): " + period1.getMonths()); // 3
System.out.println("period1.getDays(): " + period1.getDays()); // -85
System.out.println(" ------- \n");

// period2
Period period2 = period.minusDays(-100);  

System.out.println("period2.getYears(): " + period2.getYears()); // 20
System.out.println("period2.getMonths(): " + period2.getMonths()); // 3
System.out.println("period2.getDays(): " + period2.getDays()); // 115
System.out.println(" ------- \n");

// period3
Period period3 = period.minusYears(30);  

System.out.println("period3.getYears(): " + period3.getYears()); // -10
System.out.println("period3.getMonths(): " + period3.getMonths()); // 3
System.out.println("period3.getDays(): " + period3.getDays()); // 15
Output:
period1.getYears(): 20
period1.getMonths(): 3
period1.getDays(): -85
 -------

period2.getYears(): 20
period2.getMonths(): 3
period2.getDays(): 115
 -------

period3.getYears(): -10
period3.getMonths(): 3
period3.getDays(): 15

13. isZero()

Geben Sie true zurück, wenn alle 3 Werte von Tag, Monat und Jahr in diesem Period 0 sind, andernfalls geben Sie false zurück.
// Inherited from ChronoPeriod interface
public boolean isZero()
Zum Beispiel:
Period_isZero_ex1.java
Period period1 = Period.of(0, -1, 30);
System.out.println("period1.isZero()? " + period1.isZero()); // false

Period period2 = Period.of(-1, 12, 0);
System.out.println("period2.isZero()? " + period2.isZero()); // false

Period period3 = Period.of(0, 0, 0);
System.out.println("period3.isZero()? " + period3.isZero()); // true

14. isNegative()

Geben Sie true zurück, wenn ein Tag, Monat oder Jahr dieses Period negativ ist, andernfalls geben Sie false zurück.
// Inherited from ChronoPeriod interface
public boolean isNegative()
Zum Beispiel:
Period_isNegative_ex1.java
Period period1 = Period.of(10, -1, 30);
System.out.println("period1.isNegative()? " + period1.isNegative()); // true

Period period2 = Period.of(1, -12, -15);
System.out.println("period2.isNegative()? " + period2.isNegative()); // true

Period period3 = Period.of(0, 0, 0);
System.out.println("period3.isNegative()? " + period3.isNegative()); // false  

Period period4 = Period.of(5, 10, 15);
System.out.println("period4.isNegative()? " + period4.isNegative()); // false

15. multipliedBy(int)

Multiplizieren Sie diese Period mit einem angegebenen Wert und geben Sie eine neue Period zurück.
// Inherited from ChronoPeriod interface
public Period multipliedBy(int scalar)
Die Werte für Tag, Monat und Jahr sind unabhängig voneinander, es wird keine Normalisierung durchgeführt.
Zum Beispiel:
Period_multipliedBy_ex1.java
// 20 years 10 months 35 days.
Period period = Period.of(20, 10, 35);

Period result = period.multipliedBy(2);

long years = result.get(ChronoUnit.YEARS); // 40
long months = result.get(ChronoUnit.MONTHS); // 20
long days = result.get(ChronoUnit.DAYS); // 70

System.out.printf("%d years, %d months %d days", years, months, days);

16. negated()

// Inherited from ChronoPeriod interface
public Period negated()
Zum Beispiel:
Period_negated_ex1.java
// 20 years 3 months 15 days.
Period period = Period.of(20, 3, 15);  
System.out.println("period: " + period); // P20Y3M15D

// period2 = 0 - period1
Period period2 = period.negated();
System.out.println("period2: " + period2); // P-20Y-3M-15D (-20 Years, -3 months, -15 days)

17. normalized()

Senden Sie eine Kopie dieses Period mit normalisiertem Jahr und Monat zurück. Ein Jahr gilt als 12 Monate, nach der Normalisierung liegt der Wert des Monats im Bereich von -11 bis 11.
// Inherited from ChronoPeriod interface
public Period normalized()
Zum Beispiel:
  • "1 years -25 months 50 days" --> "-1 year -1 months 50 days".
Period_normalized_ex1.java
// 1 years -25 months 50 days.
Period period = Period.of(1, -25, 50);

Period result = period.normalized();

long years = result.get(ChronoUnit.YEARS); // -1
long months = result.get(ChronoUnit.MONTHS); // -1
long days = result.get(ChronoUnit.DAYS); // 50

System.out.printf("%d years, %d months %d days", years, months, days);

18. toTotalMonths()

Geben Sie die Gesamtzahl der Monate in diesem Period zurück, indem Sie die Anzahl der Jahre mit 12 multiplizieren und die Anzahl der Monate addieren. Die Anzahl der Tage wird ignoriert.
public long toTotalMonths()
Zum Beispiel:
Period_toTotalMonths_ex1.java
// 1 years 3 months 145 days.
Period period = Period.of(1, 3, 145);  
System.out.println("period: " + period); // P1Y3M145D

long months = period.toTotalMonths();
System.out.println("period.toTotalMonths(): " + months); // 15

19. addTo(Temporal)

No ADS
Fügen Sie diese Period einem angegebenen Objekt Temporal hinzu und geben Sie ein neues Objekt Temporal zurück.
// Inherited from ChronoPeriod interface
public Temporal addTo(Temporal temporal)
Diese Methode entspricht der Verwendung der Methode Temporal.plus(TemporalAmount).
// Defined in Temporal interface.
public Temporal plus​(TemporalAmount amount)
Zum Beispiel:
Period_addTo_ex1.java
// Create Temporal object.
LocalDateTime localDateTime = LocalDateTime.of(2000, 1, 10, 23, 30, 0);
System.out.println("localDateTime: " + localDateTime); // 2000-01-10T23:30

// 1 Year 1 month 25 days.
Period period = Period.of(1, 1, 25);

LocalDateTime newLocalDateTime = (LocalDateTime) period.addTo(localDateTime);
System.out.println("newLocalDateTime: " + newLocalDateTime); // 2001-03-07T23:30

20. subtractFrom(Temporal)

Subtrahieren Sie diese Period von einem angegebenen Objekt Temporal und geben Sie ein neues Objekt Temporal zurück.
// Inherited from ChronoPeriod interface
public Temporal subtractFrom(Temporal temporal)
Diese Methode entspricht der Verwendung der Methode Temporal.minus(TemporalAmount).
// Defined in Temporal interface.
public Temporal minus(TemporalAmount amount)
Zum Beispiel:
Period_subtractFrom_ex1.java
// Create Temporal object.
LocalDateTime localDateTime = LocalDateTime.of(2000, 1, 10, 23, 30, 0);
System.out.println("localDateTime: " + localDateTime); // 2000-01-10T23:30

// 1 Year 1 month 25 days.
Period period = Period.of(1, 1, 25);

LocalDateTime newLocalDateTime = (LocalDateTime) period.subtractFrom(localDateTime);
System.out.println("newLocalDateTime: " + newLocalDateTime); // 1998-11-15T23:30
No ADS

Die Anleitungen Java Date Time

Show More

Neueste Artikel

Show More