java JDK8时间类时区时间和格式化

Java JDK 8中提供了多个类来处理时间、日期和时区，其中一些最常用的类如下：

java.time.LocalDate：用于表示日期，例如 2023-05-10。
java.time.LocalTime：用于表示时间，例如 14:30:00。
java.time.LocalDateTime：用于表示日期和时间，例如 2023-05-10T14:30:00。
java.time.ZonedDateTime：用于表示带有时区的日期和时间，例如 2023-05-10T14:30:00+08:00[Asia/Shanghai]。
java.time.format.DateTimeFormatter：用于将日期和时间格式化为字符串或将字符串解析为日期和时间。

下面是一个示例代码，用于演示如何使用这些类来处理日期、时间和时区，并将它们格式化为字符串：

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

public class TimeDemo {
    public static void main(String[] args) {
        // 创建一个当前时间的 LocalDateTime 对象
        LocalDateTime now = LocalDateTime.now();

        // 指定时区为美国洛杉矶
        ZoneId zoneId = ZoneId.of("America/Los_Angeles");
        ZonedDateTime zdt = now.atZone(zoneId);

        // 定义一个格式化器，格式为 yyyy-MM-dd HH:mm:ss
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 将日期和时间格式化为字符串
        String formattedDateTime = zdt.format(formatter);

        // 输出格式化后的日期和时间字符串
        System.out.println("Formatted date and time: " + formattedDateTime);
    }
}

在上面的示例中，我们创建了一个 LocalDateTime 对象，然后将其转换为美国洛杉矶时区的 ZonedDateTime 对象。接下来，我们使用 DateTimeFormatter 将日期和时间格式化为字符串，并将其输出到控制台。输出结果将类似于 Formatted date and time: 2023-05-10 02:30:00。

除了上面提到的类和方法外，Java JDK 8中还提供了其他用于处理时间和日期的类和方法，如下所示：

java.time.Duration：用于表示时间段，例如两个日期之间的时间差。
java.time.Period：用于表示日期间隔，例如两个日期之间的天数、月数或年数。
java.time.format.DateTimeParseException：用于表示解析日期时间字符串时发生的异常。
java.time.format.ResolverStyle：用于指定解析日期时间字符串时使用的解析器的策略。

下面是一个示例代码，用于演示如何使用 Duration 和 Period 类来计算时间间隔和日期间隔：

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

public class DurationDemo {
    public static void main(String[] args) {
        // 计算两个日期之间的时间间隔
        LocalDate date1 = LocalDate.of(2023, 5, 10);
        LocalDate date2 = LocalDate.of(2023, 5, 11);
        Duration duration = Duration.between(date1.atStartOfDay(), date2.atStartOfDay());
        System.out.println("Duration between " + date1 + " and " + date2 + ": " + duration.toHours() + " hours");

        // 计算两个日期之间的日期间隔
        LocalDate date3 = LocalDate.of(2022, 12, 31);
        LocalDate date4 = LocalDate.of(2023, 5, 10);
        Period period = Period.between(date3, date4);
        System.out.println("Period between " + date3 + " and " + date4 + ": " + period.getMonths() + " months and " + period.getDays() + " days");
    }
}

在上面的示例中，我们使用 LocalDate 创建了两个日期对象，然后使用 Duration 类计算它们之间的时间间隔，以小时为单位输出结果。接下来，我们使用 Period 类计算两个日期之间的日期间隔，以月和天为单位输出结果。输出结果将类似于：

Duration between 2023-05-10 and 2023-05-11: 24 hours
Period between 2022-12-31 and 2023-05-10: 4 months and 10 days

最后，需要注意的是，在处理时间和日期时，要注意使用正确的时区和格式。如果没有指定时区，则默认使用系统时区。如果日期时间字符串格式不正确，则可能会出现解析异常。在处理日期和时间时，建议使用 java.time 包中提供的类和方法，而不是使用旧版的 java.util.Date 和 java.util.Calendar 类。

除了上面提到的类和方法外，Java JDK 8中还提供了其他用于处理时间和日期的类和方法，如下所示：

java.time.ZonedDateTime：用于表示带有时区的日期时间，可以方便地进行时区转换。
java.time.format.DateTimeFormatter：用于将日期时间对象格式化为字符串，或者将字符串解析为日期时间对象。
java.time.temporal.TemporalAdjusters：用于调整日期时间对象的值，例如获取某个月份的第一天或最后一天。
java.time.zone.ZoneRules：用于表示时区规则，例如夏令时的开始和结束时间等。

下面是一个示例代码，用于演示如何使用 ZonedDateTime 和 DateTimeFormatter 类来进行时区转换和格式化：

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

public class ZonedDateTimeDemo {
    public static void main(String[] args) {
        // 创建本地日期时间对象
        LocalDateTime localDateTime = LocalDateTime.of(2023, 5, 10, 12, 30, 0);

        // 将本地日期时间转换为纽约时区的日期时间
        ZonedDateTime nyDateTime = ZonedDateTime.of(localDateTime, ZoneId.of("America/New_York"));
        System.out.println("NY DateTime: " + nyDateTime);

        // 将纽约时区的日期时间转换为北京时区的日期时间
        ZonedDateTime bjDateTime = nyDateTime.withZoneSameInstant(ZoneId.of("Asia/Shanghai"));
        System.out.println("BJ DateTime: " + bjDateTime);

        // 将日期时间对象格式化为字符串
        String formattedDateTime = bjDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("Formatted DateTime: " + formattedDateTime);

        // 将字符串解析为日期时间对象
        ZonedDateTime parsedDateTime = ZonedDateTime.parse(formattedDateTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("Parsed DateTime: " + parsedDateTime);
    }
}

在上面的示例中，我们首先使用 LocalDateTime 创建了一个本地日期时间对象，然后使用 ZonedDateTime 将其转换为纽约时区的日期时间对象，再将其转换为北京时区的日期时间对象，并输出结果。接下来，我们使用 DateTimeFormatter 将日期时间对象格式化为字符串，并将其输出。最后，我们使用 DateTimeFormatter 将字符串解析为日期时间对象，并输出结果。输出结果将类似于：

NY DateTime: 2023-05-10T12:30-04:00[America/New_York]
BJ DateTime: 2023-05-11T00:30+08:00[Asia/Shanghai]
Formatted DateTime: 2023-05-11 00:30:00
Parsed DateTime: 2023-05-11T00:30+08:00[Asia/Shanghai]

需要注意的是，在处理时区和格式化时，需要根据实际情况选择正确的时区和格式，并进行正确的转换和解析。同时，需要注意在处理日期时间对象时，要考

虑时区的影响，特别是在进行跨时区操作时。

下面是一个更复杂的示例代码，演示了如何使用 Java JDK 8 中的时间和日期类来进行时区转换、格式化和计算：

import java.time.*;
import java.time.format.DateTimeFormatter;

public class TimezoneDemo {
    public static void main(String[] args) {
        // 创建本地日期时间对象
        LocalDateTime localDateTime = LocalDateTime.of(2023, 5, 10, 12, 30, 0);

        // 将本地日期时间转换为纽约时区的日期时间
        ZonedDateTime nyDateTime = ZonedDateTime.of(localDateTime, ZoneId.of("America/New_York"));

        // 计算距离纽约时区的下一个周一还有多长时间
        Duration durationToNextMonday = Duration.between(nyDateTime, nyDateTime.with(TemporalAdjusters.next(DayOfWeek.MONDAY)));
        System.out.println("Duration to next Monday in NY: " + durationToNextMonday);

        // 将距离转换为北京时区的时间间隔
        ZonedDateTime bjDateTime = nyDateTime.withZoneSameInstant(ZoneId.of("Asia/Shanghai"));
        Duration durationToNextMondayInBJ = durationToNextMonday.plus(Duration.between(nyDateTime, bjDateTime));
        System.out.println("Duration to next Monday in BJ: " + durationToNextMondayInBJ);

        // 将时间间隔格式化为字符串
        String formattedDuration = formatDuration(durationToNextMondayInBJ);
        System.out.println("Formatted Duration: " + formattedDuration);
    }

    private static String formatDuration(Duration duration) {
        long seconds = Math.abs(duration.getSeconds());
        long hours = seconds / 3600;
        long minutes = (seconds % 3600) / 60;
        seconds = seconds % 60;
        return String.format("%d:%02d:%02d", hours, minutes, seconds);
    }
}

在上面的示例中，我们首先创建了一个本地日期时间对象，然后将其转换为纽约时区的日期时间对象，并计算距离纽约时区的下一个周一还有多长时间。接下来，我们将其转换为北京时区的日期时间对象，并计算距离北京时区的下一个周一还有多长时间。然后，我们将时间间隔格式化为字符串，并将其输出。输出结果将类似于：

Duration to next Monday in NY: PT87H30M
Duration to next Monday in BJ: PT75H30M
Formatted Duration: 75:30:00

需要注意的是，在进行时区转换、计算和格式化时，需要考虑到夏令时等因素的影响，特别是在跨时区操作时。同时，需要根据实际情况选择正确的时区和格式，并进行正确的转换和解析。

另外，Java JDK 8 中还提供了一些方便的工具类来进行时间和日期的处理，比如 Period 和 ChronoUnit。

Period 类表示两个日期之间的时间段，可以用来计算两个日期之间相差的年、月、日等信息。例如：

LocalDate date1 = LocalDate.of(2021, 6, 30);
LocalDate date2 = LocalDate.of(2023, 5, 10);
Period period = Period.between(date1, date2);
System.out.println("Years between: " + period.getYears());
System.out.println("Months between: " + period.getMonths());
System.out.println("Days between: " + period.getDays());

输出结果将类似于：

Years between: 1
Months between: 10
Days between: 10

ChronoUnit 类表示两个时间之间的时间间隔，可以用来计算两个时间之间相差的年、月、日、小时、分钟、秒等信息。例如：

LocalDateTime dateTime1 = LocalDateTime.of(2023, 5, 10, 12, 30, 0);
LocalDateTime dateTime2 = LocalDateTime.of(2023, 5, 12, 10, 0, 0);
long hoursBetween = ChronoUnit.HOURS.between(dateTime1, dateTime2);
long minutesBetween = ChronoUnit.MINUTES.between(dateTime1, dateTime2);
long secondsBetween = ChronoUnit.SECONDS.between(dateTime1, dateTime2);
System.out.println("Hours between: " + hoursBetween);
System.out.println("Minutes between: " + minutesBetween);
System.out.println("Seconds between: " + secondsBetween);

输出结果将类似于：

Hours between: 45
Minutes between: 1350
Seconds between: 81000

需要注意的是，在进行日期和时间的计算时，需要使用正确的单位，并考虑到时区和夏令时等因素的影响。同时，需要根据实际情况选择合适的工具类和方法来进行处理。

另外，Java JDK 8 还提供了一些方便的格式化工具类来对时间和日期进行格式化。其中，最常用的是 DateTimeFormatter 类。可以使用该类提供的静态方法来创建一个格式化器，然后使用该格式化器对时间和日期进行格式化。例如：

LocalDateTime dateTime = LocalDateTime.of(2023, 5, 10, 12, 30, 0);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = dateTime.format(formatter);
System.out.println("Formatted datetime: " + formattedDateTime);

输出结果将类似于：

Formatted datetime: 2023-05-10 12:30:00

在上面的示例中，我们创建了一个格式化器，指定格式为 yyyy-MM-dd HH:mm:ss，然后使用该格式化器对 LocalDateTime 对象进行格式化。输出结果将按照指定的格式进行显示。

除了 DateTimeFormatter 类之外，Java JDK 8 还提供了其他一些格式化工具类，例如 DecimalFormat 和 NumberFormat 类，可以用来对数字进行格式化。这些工具类都非常灵活，可以通过配置不同的格式化规则来满足各种不同的需求。

总的来说，Java JDK 8 提供了非常丰富的时间和日期处理功能，包括时间和日期的表示、计算、格式化等方面。开发人员可以根据自己的需要选择合适的类和方法，来进行时间和日期的处理。同时，需要注意时区和夏令时等因素的影响，避免出现错误。

原文链接：codingdict.net

java JDK8时间 类 时区 时间和格式化

热门标签

java JDK8时间类时区时间和格式化