codestory

Die Anleitung zu Java JapaneseEra

  1. JapaneseEra
  2. Japanese Era List
  3. JapaneseEra Examples
  4. of(int japaneseEra)
  5. valueOf(String japaneseEra)
  6. values()
  7. getValue()
  8. range(TemporalField)
  9. getDisplayName(TextStyle, Locale)

1. JapaneseEra

Die Klasse JapaneseEra repräsentiert eine Ära im japanischen imperialen Kalendersystem, einem Kalendersystem, das hauptsächlich in diesem Land verwendet wird.
Grundsätzlich entspricht eine Ära im japanischen Kaiserkalendersystem der Regierungszeit eines Königs. Wenn eine Ära beginnt, wird das Jahr mit 1 beginnend nummeriert, Tag und Monat bleiben unverändert und entsprechen dem ISO-Kalendersystem.
public final class JapaneseEra implements Era, Serializable
Schauen wir uns der Einfachheit halber die folgende Abbildung an:
Kaiser Akihito regierte Japan vom 8. Januar 1989 bis zum 30. April 2019. Die Zeit seiner Herrschaft wird als Ära Heisei bezeichnet. Wenn eine neue Ära beginnt, wird das Jahr mit 1 beginnend nummeriert, Tag und Monat ändern sich nicht.
So war nach dem japanischen Kaiserkalender der erste Tag der Ära Heisei der 8. Januar und der letzte Tag der 30. April 31.

2. Japanese Era List

In der japanischen Geschichte gibt es viele Dynastien, von denen jede einer Epoche entspricht. In diesem Artikel möchte ich nicht alle vorstellen. Bei Interesse ist der folgende Artikel für Sie hilfreich:
Die ersten Kalendersysteme erschienen in Japan ab 604 basierend auf dem chinesischen Mondkalender. Dieses Kalendersystem existierte bis Ende 1872, bevor es durch das Kalendersystem Gregorian (alias ISO) ersetzt wurde. Das japanische imperiale Kalendersystem der Zeit vor dem 1. Januar 1873 wird von Java nicht unterstützt.
Liste der unterstützten Epochen in Java:
getValue()
Era Name
Emperor
ISO Date
From
To
-1
明治 (Meiji)
Mutsuhito
1868-09-08
1873-01-01(*)
1912-07-29
0
大正 (Taisho)
Yoshihito
1912-07-30
1926-12-24
1
昭和 (Showa)
Hirohito
1926-12-25
1989-01-07
2
平成 (Heisei)
Akihito
1989-01-08
2019-04-30
3
令和 (Reiwa)
Naruhito
2019-05-01
present
JapaneseEra.MEIJI
Der Zeitraum vom 23. Oktober 1868 bis 29. Juli 1912 war die Regierungszeit von Kaiser Meiji. Sein richtiger Name war Mutsuhito (3. Dezember 1852 - 30. Juli 1912). Dies war die erste Hälfte des japanischen Imperiums, als sich die Japaner von einer isolierten Feudalgesellschaft, die von einer Invasion durch den Westen bedroht war, in ein modernes Industriehauptstadtland verwandelten.
Während der Ära Meiji erfuhr das Kalendersystem eine große Veränderung:
Vom 23. Oktober 1868 bis 31. Dezember 1872: Japan verwendete ein imperiales Kalendersystem mit Tag und Monat basierend auf dem Mondkalender, aber die Jahre wurden nach dem Alter der aktuellen Ära nummeriert. (Java unterstützt diese Phase nicht)
Vom 1. Januar 1973 bis heute: Japan unterhält 2 Kalendersysteme, das Gregorian und das verbesserte imperiale Kalendersystem (Tag und Monat basieren auf dem Kalender Gregorian, aber die Jahre werden nach dem Alter der aktuellen Ära nummeriert).
JapaneseEra.TAISHO
Am 30. Juli 1912 starb Kaiser Meiji . Kronprinz Yoshihito (31. August 1879 – 25. Dezember 1926) wurde Kaiser und leitete vom 30. Juli 1912 bis 24. Dezember 1926 die Ära Taisho ein. Taisho bedeutet „große Gerechtigkeit“ (great righteousness).
JapaneseEra.SHOWA
Kaiser Shōwa (29. April 1901 - 7. Januar 1989), dessen richtiger Name Hirohito ist. Er war der 124. Kaiser von Japan und regierte Japan vom 25. Dezember 1926 bis 7. Januar 1989.
JapaneseEra.HEISEI
Kaiser Heisei wurde am 23. Dezember 1933 mit bürgerlichem Namen Akihito geboren und ist der erste Sohn von Kaiser Shōwa. Am 8. Januar 1989 wurde er Kaiser und regierte Japan bis zum 30. April 2019. Heisei bedeutet auf Japanisch "Frieden überall" (peace everywhere).
JapaneseEra.REIWA
Am 30. April 2019 dankte Kaiser Heisei aus gesundheitlichen Gründen ab, sein Sohn Naruhito bestieg den Thron und wurde 126. Kaiser von Japan. Er nannte die Ära Reiwa, was "schöne Harmonie" (beautiful harmony) bedeutet. Die Ära Reiwa begann am 1. Mai 2019 und ist die aktuelle Ära Japans.

3. JapaneseEra Examples

Die folgende Klasse JapaneseEraUtils stellt Dienstprogrammmethoden bereit, mit denen Sie das erste und das letzte Datum in einem bestimmten Zeitraum finden können:
JapaneseEraUtils.java
package org.o7planning.japaneseera.util;

import java.time.chrono.JapaneseDate;
import java.time.chrono.JapaneseEra;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.ValueRange;

public class JapaneseEraUtils {
    public static final JapaneseDate FIRST_SUPPORTED_JP_DATE = JapaneseDate.of(JapaneseEra.MEIJI, 6, 1, 1);

    public static JapaneseDate getFirstDateInSameEra(final JapaneseDate japaneseDate) {
        final JapaneseEra thisEra = japaneseDate.getEra();

        // Valid Japanese Year range with the same given day & month & era.
        ValueRange validYearRange = japaneseDate.range(ChronoField.YEAR_OF_ERA); // Ex: 1-64

        // Valid Min Japanese year with the same given day & month
        int validMinYear = (int) validYearRange.getMinimum(); // 1

        if (thisEra.equals(JapaneseEra.MEIJI)) {
            if (validMinYear < 6) {
                validMinYear = 6;
            }
        }
        final JapaneseDate jpDate2 = JapaneseDate.of(thisEra, validMinYear, 12, 31);

        ValueRange dayOfY2 = jpDate2.range(ChronoField.DAY_OF_YEAR);

        // First date in the same year with jpDate2.
        final JapaneseDate jpDate3 = jpDate2.minus(dayOfY2.getMaximum() - dayOfY2.getMinimum(), ChronoUnit.DAYS);

        if (!jpDate3.isAfter(FIRST_SUPPORTED_JP_DATE)) {
            return jpDate3;
        }
        final JapaneseDate jpDate4 = jpDate3.minus(1, ChronoUnit.DAYS);
        final JapaneseEra era4 = jpDate4.getEra();

        if (!thisEra.equals(era4)) {
            return jpDate3;
        }
        ValueRange dayOfY4 = jpDate4.range(ChronoField.DAY_OF_YEAR);
        // First date in the same Era with given japaneseDate.
        final JapaneseDate jpDate5 = jpDate4.minus(dayOfY4.getMaximum() - dayOfY4.getMinimum(), ChronoUnit.DAYS);
        return jpDate5;
    }

    public static JapaneseDate getLastDateInSameEra(final JapaneseDate japaneseDate) {
        final JapaneseEra thisEra = japaneseDate.getEra();

        // Valid Japanese Year range with the same given day & month & era.
        ValueRange validYearRange = japaneseDate.range(ChronoField.YEAR_OF_ERA); // Ex: 1-64

        // Valid Max Japanese year with the same given day & month
        int validMaxYear = (int) validYearRange.getMaximum(); // Ex: 64

        final JapaneseDate jpDate2 = JapaneseDate.of(thisEra, validMaxYear, 1, 1);
        ValueRange dayOfY2 = jpDate2.range(ChronoField.DAY_OF_YEAR);

        // Last date in the same year with jpDate2.
        final JapaneseDate jpDate3 = jpDate2.plus(dayOfY2.getMaximum() - dayOfY2.getMinimum(), ChronoUnit.DAYS);

        final JapaneseDate jpDate4 = jpDate3.plus(1, ChronoUnit.DAYS);
        final JapaneseEra era4 = jpDate4.getEra();

        if (!thisEra.equals(era4)) {
            return jpDate3;
        }
        ValueRange dayOfY4 = jpDate4.range(ChronoField.DAY_OF_YEAR);
        // Last date in the same Era with given japaneseDate.
        final JapaneseDate jpDate5 = jpDate4.plus(dayOfY4.getMaximum() - dayOfY4.getMinimum(), ChronoUnit.DAYS);
        return jpDate5;
    }

    public static JapaneseDate getFirstDateInEra(final JapaneseEra era) {
        JapaneseDate jpDate = FIRST_SUPPORTED_JP_DATE;
        while (true) {
            JapaneseEra jpEra = jpDate.getEra();
            if (era.equals(jpEra)) {
                return getFirstDateInSameEra(jpDate);
            }
            jpDate = getLastDateInSameEra(jpDate);
            jpDate = jpDate.plus(1, ChronoUnit.DAYS); // First Date in next era.
        }
    }

    public static JapaneseDate getLastDateInEra(final JapaneseEra era) {
        JapaneseDate jpDate = FIRST_SUPPORTED_JP_DATE;
        while (true) {
            JapaneseEra jpEra = jpDate.getEra();
            if (era.equals(jpEra)) {
                return getLastDateInSameEra(jpDate);
            }
            jpDate = getLastDateInSameEra(jpDate);
            jpDate = jpDate.plus(1, ChronoUnit.DAYS); // First Date in next era.
        }
    }
}
Beispiel: Drucken Sie den ersten und den letzten Tag jeder Ära im japanischen imperialen Kalendersystem, das von Java unterstützt wird.
JapaneseEra_printAllEras_ex1.java
for (JapaneseEra era : JapaneseEra.values()) {
    JapaneseDate jpFirstDate = JapaneseEraUtils.getFirstDateInEra(era);
    JapaneseDate jpLastDate = JapaneseEraUtils.getLastDateInEra(era);

    System.out.printf("Era: %s, era.getValue(): %d%n", era, era.getValue());
    System.out.printf(" >> First Date: %s ~ ISO Date: %s%n", jpFirstDate, LocalDate.from(jpFirstDate));
    System.out.printf(" >> Last Date: %s ~ ISO Date: %s%n%n", jpLastDate, LocalDate.from(jpLastDate));
}
Output:
Era: Meiji, era.getValue(): -1
 >> First Date: Japanese Meiji 6-01-01 ~ ISO Date: 1873-01-01
 >> Last Date: Japanese Meiji 45-07-29 ~ ISO Date: 1912-07-29

Era: Taisho, era.getValue(): 0
 >> First Date: Japanese Taisho 1-07-30 ~ ISO Date: 1912-07-30
 >> Last Date: Japanese Taisho 15-12-24 ~ ISO Date: 1926-12-24

Era: Showa, era.getValue(): 1
 >> First Date: Japanese Showa 1-12-25 ~ ISO Date: 1926-12-25
 >> Last Date: Japanese Showa 64-01-07 ~ ISO Date: 1989-01-07

Era: Heisei, era.getValue(): 2
 >> First Date: Japanese Heisei 1-01-08 ~ ISO Date: 1989-01-08
 >> Last Date: Japanese Heisei 31-04-30 ~ ISO Date: 2019-04-30

Era: Reiwa, era.getValue(): 3
 >> First Date: Japanese Reiwa 1-05-01 ~ ISO Date: 2019-05-01
 >> Last Date: Japanese Reiwa 292276977-04-04 ~ ISO Date: +292278995-04-04

4. of(int japaneseEra)

public static JapaneseEra of(int japaneseEra)

5. valueOf(String japaneseEra)

public static JapaneseEra valueOf(String japaneseEra)

6. values()

public static JapaneseEra[] values()

7. getValue()

public int getValue()

8. range(TemporalField)

public ValueRange range(TemporalField field)

9. getDisplayName(TextStyle, Locale) 

public String getDisplayName(TextStyle style, Locale locale)

Die Anleitungen Java Date Time

Show More

Neueste Artikel

Show More