Java の基本 -- 日付時刻クラス

序文

インスタント (タイムスタンプ) クラス

LocalData(日付)クラス

LocalTime (時間) クラス

LocalDataTime (日付時刻) クラス

期間（時間間隔）クラス

期間（日付間隔）クラス

Clock (タイムゾーンの取得) クラス

序文

開発では、日付と時刻を扱う必要があることがよくあります。Java は、日付と時刻の処理専用の API セットを提供します。日付と時刻のクラスには、LocalDate、LocalTime、Instant、Duration、および Period が含まれます。これらのクラスはすべて含まれていますjava.time パッケージ内。

クラス名	機能説明
インスタント	時刻を表し、タイムスタンプを表します
ローカル日付	特定の時刻のない日付
現地時間	日付のない時間
ローカル日時	日付と時刻が含まれています
間隔	時間ベースの値は時間を測定します
期間	日付と時刻の差を計算します。年、月、日のみが正確です。
時計	現在時刻を知るための時計システム

インスタント (タイムスタンプ) クラス

Instant クラスは特定の時間を表します。その内部は2つのロングフィールドで構成されており、

最初の部分は、標準 Java コンピューティング時代 (つまり、1970 年 1 月 1 日から始まる) から現在時刻までの秒数、つまりタイムスタンプ (タイムスタンプ) を保存することです。タイムスタンプは、基準時点からの経過秒数を表します。
2 番目の部分は、ナノ秒数を保存することです。ナノ秒は時間のより細かい単位であり、10 億分の 1 秒を表します。

一般的な方法

now(): システムクロックを使用して現在の瞬間を取得します。
now(Clock clock): 指定されたクロックを使用して現在の瞬間を取得します。
ofEpochSecond(long epochSecond):標準 Java コンピューティングエポックからの秒数を使用してInstantインスタンスを取得します。
ofEpochMilli(long epochMilli):標準 Java コンピューティングエポックからのミリ秒数を使用してInstantインスタンスを取得します。
getEpochSecond(): タイムスタンプの秒部分を取得します。
getNano(): タイムスタンプのナノ秒部分を取得します。
parse(CharSequence text): 時刻を表す文字列を対応するInstantオブジェクトに変換します。
from(TemporalAccessor tenporal):Instant時間オブジェクトのインスタンスを取得します。
plusSeconds(long seconds) AND plusMillis(long millis): 指定された秒数またはミリ秒数をタイムスタンプに追加します。
minusSeconds() And minusMillis(): タイムスタンプから指定された秒数またはミリ秒数を減算します。
isBefore() 方法 isAfter() : 2 つのタイムスタンプのシーケンスを比較します。

サンプルコード:

import java.time.Clock;
import java.time.Instant;

public class InstantExample {
    public static void main(String[] args) {
        // 获取当前时间的瞬时实例
        Instant now = Instant.now();
        System.out.println("当前时间：" + now);

        // 使用指定时钟获取当前时间的瞬时实例
        Clock clock = Clock.systemUTC();
        Instant nowWithClock = Instant.now(clock);
        System.out.println("当前时间（使用指定时钟）：" + nowWithClock);

        // 使用从自标准Java计算时代开始的秒数创建Instant实例        
        Instant epochSecondInstant = Instant.ofEpochSecond(1234567890);
        System.out.println("自1970年1月1日起的秒数对应的时间：" + epochSecondInstant);

        // 使用从自标准Java计算时代开始的毫秒数创建Instant实例
        Instant epochMilliInstant = Instant.ofEpochMilli(1627368000000L);
        System.out.println("自1970年1月1日起的毫秒数对应的时间：" + epochMilliInstant);

        // 获取时间戳的秒数部分
        long seconds = now.getEpochSecond();
        System.out.println("时间戳的秒数部分：" + seconds);

        // 获取时间戳的纳秒数部分
        int nanos = now.getNano();
        System.out.println("时间戳的纳秒数部分：" + nanos);

        // 将表示时间的字符串转换为Instant对象
        String timeString = "2023-08-14T10:30:00Z";
        Instant parsedInstant = Instant.parse(timeString);
        System.out.println("解析后的时间：" + parsedInstant);

        // 在时间戳的基础上增加指定的秒数或毫秒数
        Instant plusSecondsInstant = now.plusSeconds(3600);
        Instant plusMillisInstant = now.plusMillis(1000);
        System.out.println("增加1小时后的时间：" + plusSecondsInstant);
        System.out.println("增加1秒后的时间：" + plusMillisInstant);

        // 在时间戳的基础上减去指定的秒数或毫秒数
        Instant minusSecondsInstant = now.minusSeconds(1800);
        Instant minusMillisInstant = now.minusMillis(500);
        System.out.println("减去30分钟后的时间：" + minusSecondsInstant);
        System.out.println("减去0.5秒后的时间：" + minusMillisInstant);

        // 比较两个时间戳的先后顺序
        Instant earlierInstant = Instant.parse("2023-08-14T09:00:00Z");
        Instant laterInstant = Instant.parse("2023-08-14T11:00:00Z");
        boolean isBefore = earlierInstant.isBefore(laterInstant);
        boolean isAfter = earlierInstant.isAfter(laterInstant);
        System.out.println("earlierInstant是否在laterInstant之前：" + isBefore);
        System.out.println("earlierInstant是否在laterInstant之后：" + isAfter);
    }
}

操作結果:

当前时间：2023-08-14T09:41:00.027378100Z
当前时间（使用指定时钟）：2023-08-14T09:41:00.037343Z
自1970年1月1日起的秒数对应的时间：2009-02-13T23:31:30Z
自1970年1月1日起的毫秒数对应的时间：2021-07-27T06:40:00Z
时间戳的秒数部分：1692006060
时间戳的纳秒数部分：27378100
解析后的时间：2023-08-14T10:30:00Z
增加1小时后的时间：2023-08-14T10:41:00.027378100Z
增加1秒后的时间：2023-08-14T09:41:01.027378100Z
减去30分钟后的时间：2023-08-14T09:11:00.027378100Z
减去0.5秒后的时间：2023-08-14T09:40:59.527378100Z
earlierInstant是否在laterInstant之前：true
earlierInstant是否在laterInstant之后：false

LocalData( date ) クラス

LocalData クラスは Java 8 で導入された日付クラスで、日付 (年、月、日) 情報を表すために使用されます。このクラスには次のメソッドがあります。

now(): これは、現在の日付を表すオブジェクトを返す静的メソッドですLocalDate。たとえば、LocalDate.now()今日の日付を表すオブジェクトが返されます。
of(int year, int month, int dayOfMonth): これもLocalDate年、月、日を指定してオブジェクトを作成する静的メソッドです。パラメーターはyear年、month月 (1 から 12 の間)、dayOfMonth月内の特定の日を表します。
format(DateTimeFormatter formatter): このメソッドは、LocalDate指定された形式に従ってオブジェクトを文字列表現に変換します。DateTimeFormatter事前定義された形式またはカスタム形式を使用できるオブジェクトを渡す必要があります。たとえば、date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))「年-月-日」形式の日付文字列が返されます。
plusYears(long years)/ : これらのメソッドは、minusYears(long years)既存のオブジェクトLocalDateの指定された年数を増減するために使用されます。このパラメータは、years加算または減算する年数を示します。
plusMonths(long months)/ : 上記のメソッドと同様に、これらのメソッドは、minusMonths(long months)既存のオブジェクトLocalDateの指定された月数を増減するために使用されます。
plusDays(long days)/ : これらのメソッドは、minusDays(long days)既存のオブジェクトLocalDateの指定された日数を増減するために使用されます。
isBefore(LocalDate other)/ isAfter(LocalDate other): これら 2 つのメソッドは、LocalDate2 つのオブジェクトのシーケンスを比較するために使用されます。isBefore()このメソッドは、日付がパラメータの日付より前であるかどうかを示すブール値を返し、isAfter()日付がパラメータの日付より後であるかどうかを示すブール値を返します。
getYear()// getMonthValue():これらのメソッドは、オブジェクトの年、月、日の情報をgetDayOfMonth()取得するために使用されます。LocalDate
isLeapYear():指定された年が閏年であるかどうかを判断するために使用されます。

サンプルコード:

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

public class myclass {
    public static void main(String[] args) {
        // 获取当前日期
        LocalDate currentDate = LocalDate.now();
        System.out.println("当前日期：" + currentDate);

        // 创建指定日期
        LocalDate customDate = LocalDate.of(2023, 8, 14);
        System.out.println("自定义日期：" + customDate);

        // 格式化日期为字符串
        String formattedDate = customDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        System.out.println("格式化后的日期：" + formattedDate);

        // 增减年份
        LocalDate futureDate = customDate.plusYears(2);
        System.out.println("增加两年后的日期：" + futureDate);

        // 判断日期先后
        boolean isBefore = customDate.isBefore(currentDate);
        boolean isAfter = customDate.isAfter(currentDate);
        System.out.println("自定义日期是否在当前日期之前：" + isBefore);
        System.out.println("自定义日期是否在当前日期之后：" + isAfter);

        // 获取年、月、日
        int year = customDate.getYear();
        int month = customDate.getMonthValue();
        int dayOfMonth = customDate.getDayOfMonth();
        System.out.println("年：" + year);
        System.out.println("月：" + month);
        System.out.println("日：" + dayOfMonth);

        // 判断闰年
        boolean isLeapYear = customDate.isLeapYear();
        System.out.println("自定义日期所在年份是否为闰年：" + isLeapYear);
    }
}

操作結果:

当前日期：2023-08-14
自定义日期：2023-08-14
格式化后的日期：2023-08-14
增加两年后的日期：2025-08-14
自定义日期是否在当前日期之前：false
自定义日期是否在当前日期之后：false
年：2023
月：8
日：14
自定义日期所在年份是否为闰年：false

LocalTime (時間)クラス

LocalTime クラスは、時間を表すために使用されます。通常は、時、分、秒です。LocalData クラスと同様、このクラスはタイムライン上の即時情報を表すことはできず、時間の説明のみを表します。時刻オブジェクトを取得するメソッドは LocalTime クラスで提供されます。これは LocalData の使用法に似ています。

同時に、LocalTime クラスは、時刻の書式設定、日付クラスに対応する時間、分、秒の加算と減算などの一般的なメソッドも提供します。これらのメソッドは LocalData ( date ) クラスに対応するため、ここではリストしません。詳細はこちら。

サンプルコード:

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class LocalTimeExample {
    public static void main(String[] args) {
        // 获取当前时间
        LocalTime currentTime = LocalTime.now();
        System.out.println("当前时间：" + currentTime);

        // 创建指定时间
        LocalTime customTime = LocalTime.of(12, 30, 45);
        System.out.println("自定义时间：" + customTime);

        // 格式化时间为字符串
        String formattedTime = customTime.format(DateTimeFormatter.ofPattern("HH:mm:ss"));
        System.out.println("格式化后的时间：" + formattedTime);

        // 增减小时数
        LocalTime futureTime = customTime.plusHours(2);
        System.out.println("增加两小时后的时间：" + futureTime);

        // 判断时间先后
        boolean isBefore = customTime.isBefore(currentTime);
        boolean isAfter = customTime.isAfter(currentTime);
        System.out.println("自定义时间是否在当前时间之前：" + isBefore);
        System.out.println("自定义时间是否在当前时间之后：" + isAfter);

        // 获取小时、分钟、秒
        int hour = customTime.getHour();
        int minute = customTime.getMinute();
        int second = customTime.getSecond();
        System.out.println("小时：" + hour);
        System.out.println("分钟：" + minute);
        System.out.println("秒：" + second);
    }
}

操作結果:

当前时间：18:04:40.272290700
自定义时间：12:30:45
格式化后的时间：12:30:45
增加两小时后的时间：14:30:45
自定义时间是否在当前时间之前：true
自定义时间是否在当前时间之后：false
小时：12
分钟：30
秒：45

LocalDataTime (日付時刻) クラス

LocalDataTime クラスは、日付 (LocalDate) クラスと時刻 (LocalTime) クラスを組み合わせたものです。日付と時刻の両方が含まれます。API を表示すると、LocalDataTime クラスのメソッドには、 LocalData クラスと LocalTime クラス。

LocalDateTime のデフォルト形式は 2020-02-29T21:23:26.774 であり、私たちがよく使用する形式と一致しない可能性があるため、LocalData およびLocalTime クラスは、さらに変換メソッドを提供します。

LocalDateTime クラスの一般的に使用されるメソッドの一部を次に示します。

now(): 静的メソッド。現在の日付と時刻の LocalDateTime オブジェクトを返します。
of(int year, int month, int dayOfMonth, int hour, int minutes) / of(int year, int month, int dayOfMonth, int hour, int minutes, int Second): 年、月、日を指定する静的メソッド、 LocalDateTime オブジェクトを作成するための時、分、秒 (オプション)。
parse(CharSequence text): 文字列を LocalDateTime オブジェクトに解析する静的メソッド。
format(DateTimeFormatter フォーマッタ): 指定された形式に従って LocalDateTime オブジェクトを文字列表現に変換します。
toLocalDate(): LocalDateTime オブジェクトの日付部分を取得し、LocalDate オブジェクトを返します。
toLocalTime(): LocalDateTime オブジェクトの時刻部分を取得し、LocalTime オブジェクトを返します。
plusyears(long years) / minusyears(long years): 指定された年数を既存の LocalDateTime オブジェクトに加算または減算します。
plusMonths(長い月) /minusMonths(長い月): 指定された月数を既存の LocalDateTime オブジェクトに加算または減算します。
plusDays(long days) / minusDays(long days): 指定された日数を既存の LocalDateTime オブジェクトに加算または減算します。
plusHours(長い時間) / minusHours(長い時間): 既存の LocalDateTime オブジェクトの指定された時間数を加算または減算します。
plusMinutes(長い分) / minusMinutes(長い分): 既存の LocalDateTime オブジェクトの指定された分数を加算または減算します。
plusSeconds(長い秒数) / minusSeconds(長い秒数): 既存の LocalDateTime オブジェクトの指定された秒数を加算または減算します。
get Year() / getMonthValue() / getDayOfMonth(): LocalDateTime オブジェクトの年、月、日の情報を取得します。

サンプルコード:

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class myclass {
    public static void main(String[] args) {
        // 获取当前日期和时间
        LocalDateTime currentDateTime = LocalDateTime.now();
        System.out.println("当前日期和时间：" + currentDateTime);

        // 创建指定的日期和时间
        LocalDateTime customDateTime = LocalDateTime.of(2023, 8, 14, 12, 30);
        System.out.println("自定义日期和时间：" + customDateTime);

        // 格式化日期时间为字符串
        String formattedDateTime = customDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("格式化后的日期和时间：" + formattedDateTime);

        // 增减年数、月数、天数、小时数、分钟数、秒数
        LocalDateTime futureDateTime = customDateTime.plusYears(1).minusMonths(2).plusDays(15).minusHours(3).plusMinutes(10).plusSeconds(30);
        System.out.println("操作后的日期和时间：" + futureDateTime);

        // 获取日期和时间部分
        LocalDate datePart = customDateTime.toLocalDate();
        LocalTime timePart = customDateTime.toLocalTime();
        System.out.println("日期部分：" + datePart);
        System.out.println("时间部分：" + timePart);

        // 获取年、月、日信息
        int year = customDateTime.getYear();
        int month = customDateTime.getMonthValue();
        int dayOfMonth = customDateTime.getDayOfMonth();
        System.out.println("年：" + year);
        System.out.println("月：" + month);
        System.out.println("日：" + dayOfMonth);
    }
}

操作結果:

当前日期和时间：2023-08-14T18:09:24.472147600
自定义日期和时间：2023-08-14T12:30
格式化后的日期和时间：2023-08-14 12:30:00
操作后的日期和时间：2024-06-29T09:40:30
日期部分：2023-08-14
时间部分：12:30
年：2023
月：8
日：14

期間（時間間隔）クラス

Duration クラスは、時間間隔を表すために Java 8 で導入されたクラスです。2 つの時間点の差を計算したり、秒、分、時間などの異なる単位間で変換したりするために使用できます。

以下は、Duration クラスの一般的に使用されるメソッドの一部です。

ofDays(長い日) / ofHours(長い時間) / ofMinutes(長い分): 指定された日数、時間数、または分数を表す期間を作成する静的メソッド。
ofSeconds(長い秒) / ofMillis(長いミリ秒) / ofNanos(長いナノ秒): 指定された秒数、ミリ秒数、またはナノ秒数を表す期間を作成する静的メソッド。
between(Temporal startInclusive, Temporal endExclusive): 開始時刻と終了時刻の差を表す期間を作成する静的メソッド。
plus(デュレーション期間) / マイナス(デュレーション期間): 既存のデュレーションオブジェクトの別のデュレーションオブジェクトのデュレーションを加算または減算します。
toDays() / toHours() / toMinutes(): 期間を対応する日数、時間数、または分数に変換します。
toSeconds() / toMillis() / toNanos(): 継続時間を対応する秒数、ミリ秒数、またはナノ秒数に変換します。
getSeconds() / getNano(): 継続時間の秒数とナノ秒数を取得します。
isNegative() / isZero(): 期間が負であるかゼロであるかを判断します。

サンプルコード:

import java.time.Duration;

public class myclass {
    public static void main(String[] args) {
        // 创建一个持续时间，表示5小时30分钟15秒
        Duration duration1 = Duration.ofHours(5).plusMinutes(30).plusSeconds(15);
        System.out.println("Duration 1: " + duration1); // 输出：PT5H30M15S

        // 创建一个持续时间，表示1分钟
        Duration duration2 = Duration.ofMinutes(1);
        System.out.println("Duration 2: " + duration2); // 输出：PT1M

        // 计算两个持续时间之间的差异
        Duration difference = duration1.minus(duration2);
        System.out.println("Difference: " + difference); // 输出：PT5H29M15S

        // 获取持续时间的小时数、分钟数和秒数
        long hours = difference.toHours();
        long minutes = difference.toMinutesPart();
        long seconds = difference.toSecondsPart();
        System.out.println("Hours: " + hours); // 输出：5
        System.out.println("Minutes: " + minutes); // 输出：29
        System.out.println("Seconds: " + seconds); // 输出：15

        // 判断持续时间是否为负值或零值
        boolean isNegative = difference.isNegative();
        boolean isZero = difference.isZero();
        System.out.println("是负的? " + isNegative); // 输出：false
        System.out.println("是零吗? " + isZero); // 输出：false
    }
}

期間（日付間隔）クラス

Period は、主に 2 つの日付間の間隔を計算するために使用されます。Duration と同じです。また、 between between で日付の間隔を計算し、年、月、日を取得するための 3 つの一般的なメソッド、getyears()、getMonths() を提供します。そしてgetDays()。

サンプルコード:

import java.time.LocalDate;
import java.time.Period;

public class myclass {
    public static void main(String[] args) {
        // 创建两个日期
        LocalDate startDate = LocalDate.of(2023, 1, 1);
        LocalDate endDate = LocalDate.of(2023, 4, 30);

        // 计算日期之间的差异
        Period period = Period.between(startDate, endDate);
        System.out.println("日期间隔: " + period); // 输出：P3M29D

        // 获取年、月、日的差异
        int years = period.getYears();
        int months = period.getMonths();
        int days = period.getDays();
        System.out.println("年: " + years); // 输出：0
        System.out.println("月: " + months); // 输出：3
        System.out.println("日: " + days); // 输出：29

        // 添加日期间隔到指定日期
        LocalDate newDate = startDate.plus(period);
        System.out.println("新日期: " + newDate); // 输出：2023-04-30

        // 判断日期间隔是否为负值或零值
        boolean isNegative = period.isNegative();
        boolean isZero = period.isZero();
        System.out.println("是否为负值? " + isNegative); // 输出：false
        System.out.println("是否为零值? " + isZero); // 输出：false
    }
}

Clock (タイムゾーンの取得) クラス

Clockclass は、現在の時刻、日付、タイムゾーン情報を取得するために使用される Java の抽象クラスです。これは、システムクロックにアクセスし、さまざまなタイムゾーンの現在時刻を取得するための一般的な方法を提供します。

systemDefaultZone(): 静的メソッド。システムのデフォルトのタイムゾーンを使用してシステムクロックを返します。
systemUTC(): 協定世界時 (UTC) を使用してシステムクロックを返す静的メソッド。
tiny(ClockfixedClock,DurationticDuration):指定されたクロックをラップする「ティック」クロックを返し、指定された期間を毎回進める静的メソッドです。
fix(Instant fixInstant, ZoneIdzone): 静的メソッド。固定クロックを返し、常に指定されたインスタントとタイムゾーンを返します。
offset(ClockbaseClock,DurationoffsetDuration):ベースクロックに対して指定された期間だけオフセットされたクロックを返す静的メソッド。
millis(): 1970 年 1 月 1 日の午前 0 時からのミリ秒数を返すインスタンスメソッド。
instant(): インスタンスメソッド。現在のクロックの現在の瞬間を返します。
getZone(): インスタンスメソッド。時計のタイムゾーン情報を返します。

サンプルコード:

import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.ZoneId;

public class myclass {
    public static void main(String[] args) {
        // 获取系统默认时区的时钟
        Clock systemDefaultClock = Clock.systemDefaultZone();
        System.out.println("系统默认时钟：" + systemDefaultClock);

        // 获取使用协调世界时（UTC）的系统时钟
        Clock systemUTCClock = Clock.systemUTC();
        System.out.println("系统UTC时钟：" + systemUTCClock);

        // 创建一个滴答时钟，每次前进1秒钟
        Clock tickClock = Clock.tick(systemDefaultClock, Duration.ofSeconds(1));
        System.out.println("滴答时钟：" + tickClock);

        // 创建一个固定的时钟，始终返回指定的瞬间和时区
        Instant fixedInstant = Instant.parse("2022-01-01T00:00:00Z");
        ZoneId fixedZone = ZoneId.of("Asia/Shanghai");//亚洲/上海
        Clock fixedClock = Clock.fixed(fixedInstant, fixedZone);
        System.out.println("固定时钟：" + fixedClock);

        // 创建一个相对于基准时钟偏移10秒钟的时钟
        Clock baseClock = Clock.systemDefaultZone();
        Duration offsetDuration = Duration.ofSeconds(10);
        Clock offsetClock = Clock.offset(baseClock, offsetDuration);
        System.out.println("偏移时钟：" + offsetClock);

        // 获取当前时钟的毫秒数
        long millis = systemDefaultClock.millis();
        System.out.println("毫秒数：" + millis);

        // 获取当前时钟的当前瞬间
        Instant instant = systemDefaultClock.instant();
        System.out.println("当前瞬间：" + instant);

        // 获取当前时钟的时区信息
        ZoneId zone = systemDefaultClock.getZone();
        System.out.println("时区：" + zone);
    }
}