[Java] Datums- / Zeitoperationen

Datums- / Zeitmanipulation

• ** Datums-Zeit-API verwenden ** (Java 8 oder höher)

Aktuelle Zeit abrufen

• ** Lokales Datum ** ist das Datum und die Uhrzeit
• ** Ortszeit ** ist die Zeit

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.ZonedDateTime;

public class Main {
  //Holen Sie sich das aktuelle Datum und die Uhrzeit
  public static void main(String[] args) {
    System.out.println(LocalDateTime.now());  //2020-10-31T07:49:16.502455881
    System.out.println(OffsetDateTime.now()); //2020-10-31T07:49:16.503291965Z
    System.out.println(ZonedDateTime.now());  //020-10-31T07:49:16.504062367Z[Etc/UTC]
    System.out.println(LocalDate.now());      //2020-10-31
    System.out.println(LocalTime.now());      //07:49:16.504349859
  }
}

Holen Sie sich ein bestimmtes Datum und eine bestimmte Uhrzeit

• ** LocalDateTime.of-Methode **

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;


public class Main {
  //Holen Sie sich ein bestimmtes Datum und eine bestimmte Uhrzeit
  public static void main(String[] args) {
    //Generieren Sie Datum und Uhrzeit aus Datum / Stunde / Minute / Sekunde Nanosekunde
    var ldt1 = LocalDateTime.of(2019, 1, 10, 10, 20, 30, 513);
    var ldt2 = LocalDateTime.of(2019, Month.JANUARY, 10, 10, 20, 30);
    //var ldt3 = LocalDateTime.of(2019, 1, 40, 10, 20, 30); //Fehler, weil es außerhalb des Bereichs liegt
    System.out.println(ldt1); //2019-01-10T10:20:30.000000513
    System.out.println(ldt2); //2019-01-10T10:20:30.000000513

    //Generieren Sie nur Datum / Uhrzeit
    var ld = LocalDate.of(2019, 1, 10);
    System.out.println(ld);   //2019-01-10
    var lt = LocalTime.of(10, 20, 30);
    System.out.println(lt);  //10:20:30
    var ldt4 = LocalDateTime.of(ld, lt);
    System.out.println(ldt4); //2019-01-10T10:20:30

    //Zeitzonenversatzwert(ZoneOffset-Objekt)
    var odt = OffsetDateTime.of(2019, 1, 10, 10, 20, 30, 999, ZoneOffset.ofHours(9));
    System.out.println(odt); //2019-01-10T10:20:30.000000999+09:00

    var ot = OffsetTime.of(10, 20, 30, 999, ZoneOffset.ofHours(9));
    System.out.println(ot); //10:20:30.000000999+09:00

    var zdt = ZonedDateTime.of(2019, 1, 10, 10, 20, 30, 999, ZoneId.of("Asia/Tokyo"));
    System.out.println(zdt); //2019-01-10T10:20:30.000000999+09:00[Asia/Tokyo]
  }
}

Datums- / Uhrzeitzeichenfolge konvertieren

• ** Analysemethode **
• Wenn ein Formatierer angegeben ist, kann der im angegebenen Format analysierte Wert abgerufen werden.

import java.time.LocalDate;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;


public class Main {
  //Konvertieren von Datums- / Zeitzeichenfolge
  public static void main(String[] args) {
    //ISO-Datum
    System.out.println(LocalDate.parse(
        "2019-01-01", DateTimeFormatter.ISO_DATE)); //2019-01-01
    //Jahr und Tage
    System.out.println(LocalDate.parse(
        "2019-123", DateTimeFormatter.ISO_ORDINAL_DATE)); //2019-05-03
    //Jahr und Anzahl der Wochen
    System.out.println(LocalDate.parse(
        "2019-W40-5", DateTimeFormatter.ISO_WEEK_DATE)); //2019-10-04
    //Datum und Uhrzeit mit Zeitzonen-ID
    System.out.println(ZonedDateTime.parse(
      "2019-01-10T10:20:30.000000999+09:00[Asia/Tokyo]",
      DateTimeFormatter.ISO_DATE_TIME)); //2019-01-10T10:20:30.000000999+09:00[Asia/Tokyo]
  }
}

Vergleichen Sie Datum und Uhrzeit

• equals / isBefore / isAfter

import java.time.LocalDateTime;
public class Main {
  public static void main(String[] args) {
    var dt1 = LocalDateTime.of(2019, 12, 31, 10, 20, 30);
    var dt2 = LocalDateTime.of(2020, 1, 1, 10, 20, 30);
    System.out.println(dt1.equals(dt2));   //false
    System.out.println(dt1.isBefore(dt2)); //true
    System.out.println(dt1.isAfter(dt2));  //false
  }
}

Zeitelement abrufen

import java.time.LocalDateTime;
import java.time.temporal.ChronoField;

public class Main {
  public static void main(String[] args) {
    var dt = LocalDateTime.of(2019, 1, 10, 10, 20, 30, 123);
    var week = new String[] {"Sonntag", "Montag", "Dienstag", "Mittwoch","Donnerstag", "Freitag", "Samstag"};
    System.out.println(dt.getYear() + "Jahr" +dt.getMonthValue() + "Mond" +dt.getDayOfMonth() + "Tag" +dt.getDayOfWeek() + " " +dt.getHour() + "Zeit" +dt.getMinute() + "Protokoll"+ dt.getSecond() + "Sekunden"+ dt.getNano() + "ナノSekunden");
    System.out.println("Der Monatsname ist" + dt.getMonth() +"dieses Jahr" + dt.getDayOfYear() + "Tag"); //Der Monatsname istJANUARYdieses Jahr10Tag
    //Holen Sie sich Zeit mit Chrono Field
    System.out.println(dt.get(ChronoField.YEAR) + "Jahr" +dt.get(ChronoField.MONTH_OF_YEAR) + "Mond" +dt.get(ChronoField.DAY_OF_MONTH) + "Tag" +week[dt.get(ChronoField.DAY_OF_WEEK) -1] + " "+dt.get(ChronoField.HOUR_OF_DAY) + "Zeit" +dt.get(ChronoField.MINUTE_OF_HOUR) + "Protokoll" +dt.get(ChronoField.SECOND_OF_MINUTE) + "Sekunden" +dt.get(ChronoField.NANO_OF_SECOND) + "ナノSekunden");
  }
} //Mittwoch, 10. Januar 2019 10:20:30 123 Nanosekunden

Datum und Uhrzeit formatieren

• ** Format gemäß dem Argument der DateTimeFormatter-Methode **

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;

public class Main {
  public static void main(String[] args) {
    var dt1 = LocalDateTime.of(2020, 11, 1, 10, 20, 30);
    var dt2 = ZonedDateTime.of(2019, 11, 1, 10, 20, 30, 0, ZoneId.of("Asia/Tokyo"));

    System.out.println(dt1.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)));      //Sunday, November 1, 2020
    System.out.println(dt2.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG)));  //November 1, 2019 at 10:20:30 AM JST
    System.out.println(dt1.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)));    //Nov 1, 2020
    System.out.println(dt2.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT))); //11/1/19, 10:20 AM
  }
}

• ** Formatieren Sie nach Ihren Wünschen mit der DateTimeFormatter.ofPattern-Methode **
• Das Standardformat wird empfohlen, da es Ihnen je nach Gebietsschema ein geeignetes Format (Englisch usw.) bietet.

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class Main {
  public static void main(String[] args) {
    var dt1 = LocalDateTime.of(2020, 11, 1, 10, 20, 30);
    var dt2 = ZonedDateTime.of(2020, 11, 1, 10, 20, 30, 0, ZoneId.of("Asia/Tokyo"));
    System.out.println(dt1.format(DateTimeFormatter.ofPattern("y.MM.dd H:m:s"))); //2020.11.01 10:20:30
    System.out.println(dt2.format(DateTimeFormatter.ofPattern("Y Jahr L Monat d Tag (E) eine K Stunde m Minute s Sekunde(z)"))); //1. November 2020 (So) 10:20:30 Uhr(JST)
  }
}

• ** Datum aus der ursprünglichen Ausgabe mit der Methode JapaneseDate.of generieren **
• var d = JapaneseDate.of (JapaneseEra.REIWA, 1, 1, 1); ist Fehler

//Japanischer Kalender
import java.time.chrono.JapaneseDate;
import java.time.chrono.JapaneseEra;
import java.time.format.DateTimeFormatter;

public class Main {
  public static void main(String[] args) {
    var d = JapaneseDate.of(JapaneseEra.REIWA, 2, 1, 1);
    System.out.println(d); //Japanese Reiwa 2-01-01
    //G ist die ursprüngliche Ausgabe
    var df = DateTimeFormatter.ofPattern("Gy Jahr MM Monat dd Tag");
    System.out.println(d.format(df)); //Reiwa 01. Januar, 2
  }
}

Datums- / Zeitunterschied

• Zeitraum (Datum) / Dauer (Zeit) Klasse ** zwischen Methode **
• Das Punktargument muss einmal mit toLocalDate in LocalDate konvertiert werden
• Das Argument für die Dauer ist vom Typ Zeit: Kann alle Instanzen von LocalDate und ZonedDate akzeptieren

//Die verstrichenen Tage zählen
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.Period;

public class Main {
  public static void main(String[] args) {
    var dt1 = LocalDateTime.of(2019, 12, 31, 0, 0, 0);
    var dt2 = LocalDateTime.of(2020, 11, 1, 10, 20, 30);

    var period = Period.between(dt1.toLocalDate(), dt2.toLocalDate());
    System.out.println("Datumsunterschied:" +
      period.getYears() + "Jahr" + period.getMonths() + "Monate" +
      period.getDays() + "Tage"); //日付の差：0年10ヶ月1Tage

    var duration = Duration.between(dt1, dt2);
    System.out.println("Zeitunterschied:" + duration.toHours() + "Zeit"); //Zeitunterschied:7354Zeit
  }
}

Datumsaddition / -subtraktion

• ** Plus / Minus-Methode **
• ** Es gibt auch Methoden, die auf die Zeitberechnung spezialisiert sind, wie z. B. plusJahre / plusWochen **

//x Jahre später,vor y Tagen
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
public class Main {
  public static void main(String[] args) {
    var d = LocalDate.of(2020, 11, 1);
    System.out.println(d); //2020-11-01
    //3 Jahre später
    System.out.println(d.plus(3, ChronoUnit.YEARS)); //2023-11-01
    //Vor 22 Tagen
    System.out.println(d.minus(22, ChronoUnit.DAYS)); //2020-10-10
  }
}

• Durchlaufzeitraum / Dauer und Addition / Subtraktion in Datumsintervallen
• Zeitraum: ** P **
• P2Y2M = 2 Jahre und 2 Monate
• Dauer: ** P T **
• -P1DT5M = vor 1 Tag 5 Minuten

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.Period;
public class Main {
  public static void main(String[] args) {
    var d = LocalDateTime.of(2020, 11, 1, 10, 20, 30);
    var period = Period.ofYears(3);
    //P<Datum>T<Zeit>
    var duration = Duration.parse("P22DT1H1M1S"); //22 Tage 1 Stunde 1 Minute 1 Sekunde
    System.out.println(d);  //2020-11-01T10:20:30
    System.out.println(d.plus(period)); //2023-11-01T10:20:30
    System.out.println(d.minus(duration)); //2020-10-10T09:19:29
  }
}

Kalenderklasse (Java 7 oder früher)

• ** Mit der toInstant-Methode vom Kalender in die Datums- / Uhrzeit-API konvertieren **
• toInstant-Methode: Hält die verstrichene Zeit von 1 / 1970/1
• ** ofInstant-Methode ** erstellt Objekte wie LocalDateTime

//Bisheriger Kalender-In Zeit-API konvertieren
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Calendar;

public class Main {
  public static void main(String[] args) {
    var cal = Calendar.getInstance();
    var dt1 = LocalDateTime.ofInstant(cal.toInstant(), ZoneId.systemDefault());
    var dt2 = OffsetDateTime.ofInstant(cal.toInstant(), ZoneId.systemDefault());
    var dt3 = ZonedDateTime.ofInstant(cal.toInstant(), ZoneId.systemDefault());
    System.out.println(dt1); //2020-11-01T03:30:12.156
    System.out.println(dt2); //2020-11-01T03:30:12.156Z
    System.out.println(dt3); //2020-11-01T03:30:12.156Z[Etc/UTC]
  }
}

• ** Von Datums- / Uhrzeit-API in Kalender konvertieren **
• Die Kalendergenauigkeit beträgt Millisekunden, daher weniger als Millisekunden
• Empfangen Sie das generierte Instant-Objekt mit der Date.from-Methode. ** Date-Objekt ** Generieren
• ** SetTime-Methode **, um einen Wert von Datum zu Kalender einzugeben

//Date-Konvertieren Sie von der Zeit-API in den Kalender
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Calendar;
import java.util.Date;

public class Main {
  public static void main(String[] args) {
    var dt = LocalDateTime.of(2020, 11, 1, 10, 20, 30, 123456789);
    var d = Date.from(dt.toInstant(ZoneOffset.of("+09:00")));
    //Geben Sie mit der setTime-Methode einen Wert von Datum bis Kalender ein
    var cal = Calendar.getInstance();
    cal.setTime(d);
    System.out.println(cal); //java.util.GregorianCalendar[time=1604193630123,,(Abkürzung),,AM_PM=0,HOUR=1,HOUR_OF_DAY=1,MINUTE=20,SECOND=30,MILLISECOND=123,ZONE_OFFSET=0,DST_OFFSET=0]
    }
}