java8新特性之-LocalDateTime

首先，我们必须明确，JAVA为什么在有Date这个类的情况下，又引入了LocalDateTime
大体上来说。
java8引入为了解决旧的java.util.Date和java.util.Calendar等类在处理日期和时间时存在的一些问题，并提供更灵活、清晰、易用的日期时间处理方式。

具体来说有以下几个原因

1. 不可变性

LocalDateTime 类是不可变的，一旦创建，其值不可更改。这符合函数式编程的思想，避免了在多线程环境下的竞态条件问题。

import java.time.LocalDateTime;
import java.util.Date;

/**
 * Description:
 *
 * @author baxian
 * @date 2023-12-15
 */
public class demo1 {
    public static void main(String[] args) {

        // 使用LocalDateTime
        LocalDateTime originalDateTime = LocalDateTime.now();
        LocalDateTime modifiedDateTime = originalDateTime.plusHours(2);

        System.out.println("Original DateTime: " + originalDateTime);
        System.out.println("Modified DateTime: " + modifiedDateTime);

        // Date是可变的
        Date originalDate = new Date();
        Date modifiedDate = originalDate.setTime(new Date(originalDate.getTime() + 2 * 60 * 60 * 1000));

        System.out.println("Original Date: " + originalDate);
        System.out.println("Modified Date: " + modifiedDate);
    }
}

实际在java8，originalDate.setTime()已经不支持直接传入Date参数来设置时间了

只支持传入Long型的参数，该参数表示自1970年1月1日00:00:00 GMT以来的毫秒数。

所以我们不难发现Date对象本身是可以被修改的，而LocalDateTime不会，他只能创建新的时间对象。

LocalDateTime 是不可变的，一旦创建了 LocalDateTime 的实例，它的值就无法被修改。这种设计带来了一些优势：

1. 线程安全性：
   不可变性使得 LocalDateTime 对象在多线程环境下更加安全。由于对象的值不能被修改，不会发生竞态条件（Race Condition）等线程安全问题。【Race Condition（竞态条件）是多线程编程中一种可能导致程序行为不正确的情况。它发生在多个线程试图同时访问和修改共享资源，而没有足够的同步机制来保护这些资源。竞态条件可能导致程序的行为与预期不符，产生不确定性的结果。】

2. 函数式编程风格：
   不可变性符合函数式编程的理念，函数式编程强调无副作用、不可变性和纯函数。在函数式编程中，避免状态的变化有助于写出更加简洁、可维护的代码。

3. 易于推理和调试：
   不可变性使得程序的状态更加可控，更容易推理和调试。如果一个对象的值在生命周期内不发生变化，就可以更容易地理解它的行为。

2.清晰的API设计：

LocalDateTime 类提供了清晰的API，使得日期时间操作更加直观和易读。例如，可以通过plus、minus等方法进行日期时间的加减操作，而无需手动计算。

这种清晰的 API 设计主要表现在以下几个方面：

1. 不可变性：
   LocalDateTime 是不可变的，一旦创建，其值不可更改。这样的设计使得 API 使用起来更加直观，不需要考虑对象在操作过程中的状态变化。
2. 方法命名和语义明确：
   方法的命名清晰明了，直观地表达了其功能。例如，plusHours 表示在当前日期时间上增加指定的小时数，minusDays 表示在当前日期时间上减去指定的天数。这种命名方式让开发者更容易理解方法的作用。
3. 流畅的调用链：
   java.time 包中的日期时间类支持流畅的调用链。通过方法的链式调用，可以更紧凑地表达多个操作。例如，localDateTime.plusDays(1).minusHours(2).plusMinutes(30)，这样的调用链非常直观。
4. 明确的异常：
   方法的设计遵循了明确抛出异常的原则，例如，对于可能导致溢出的操作，会抛出 ArithmeticException。这有助于开发者在编码阶段就能够意识到潜在的问题。
5. 支持函数式编程：
   新的日期时间 API 支持函数式编程的思想，可以方便地使用 lambda 表达式、方法引用和流式操作。这种支持使得日期时间的处理更为灵活和现代化。

import java.time.LocalDateTime;

public class LocalDateTimeApiExample {
    public static void main(String[] args) {
        // 创建一个不可变的 LocalDateTime 对象
        LocalDateTime originalDateTime = LocalDateTime.now();

        // 清晰的 API 调用
        LocalDateTime modifiedDateTime = originalDateTime
                .plusHours(2)
                .minusDays(1)
                .plusMinutes(30);

        System.out.println("Original DateTime: " + originalDateTime);
        System.out.println("Modified DateTime: " + modifiedDateTime);
    }
}

这个示例中，通过链式调用 plusHours、minusDays 和 plusMinutes 方法，清晰地表达了对日期时间的修改操作。

3.时区处理：

旧的java.util.Date类在设计上存在时区处理的问题，而LocalDateTime是没有时区信息的，更适用于处理本地时间。
如果需要考虑时区，可以使用ZonedDateTime类，它包含了时区信息，使得时区的处理更为灵活。

java.time 包引入了 ZoneId 和 ZoneOffset 类型，以更好地处理时区信息。以下是一些体现时区处理灵活性的方面：

1. ZonedDateTime 类：
   ZonedDateTime 类表示带有时区信息的日期和时间。它提供了在时区变化时进行调整的方法，以确保时间的一致性。
   ZoneId 和 ZoneOffset：

2. ZoneId 表示一个时区的标识符，例如 “Europe/Paris”。
   ZoneOffset 表示一个固定的时区偏移，例如 UTC+02:00。
   这两个类的引入使得处理时区信息更为明确和可控。

3. OffsetDateTime 类：
   OffsetDateTime 类表示带有偏移的日期和时间，结合了 LocalDateTime 和 ZoneOffset。

4. 明确的时区转换方法：
   新的日期时间 API 提供了明确的方法进行时区之间的转换，例如，atZone(ZoneId zone)、withZoneSameInstant(ZoneId zone) 等。

例如下面这个

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

public class TimeZoneExample {
    public static void main(String[] args) {
        // 创建一个不带时区信息的 LocalDateTime 对象
        LocalDateTime localDateTime = LocalDateTime.now();

        // 使用 ZoneId 添加时区信息
        ZoneId parisZone = ZoneId.of("Europe/Paris");
        ZonedDateTime zonedDateTimeParis = ZonedDateTime.of(localDateTime, parisZone);

        ZoneId newYorkZone = ZoneId.of("America/New_York");
        ZonedDateTime zonedDateTimeNewYork = ZonedDateTime.of(localDateTime, newYorkZone);

        System.out.println("Local DateTime: " + localDateTime);
        System.out.println("Paris Time: " + zonedDateTimeParis);
        System.out.println("New York Time: " + zonedDateTimeNewYork);
    }
}

4.引入新的日期时间API：

第四点是关于新的日期时间 API 引入的一整套新的日期时间类，包括 LocalDate、LocalTime、ZonedDateTime 等。这些类之间可以无缝协同工作，提供更加全面和灵活的日期时间处理功能。

以下是一些体现新 API 提供的一整套日期时间类的特性：

1. LocalDate：
   表示日期的类，只包含年、月、日信息。适用于处理不需要时分秒的场景。
2. LocalTime：
   表示时间的类，只包含时分秒信息。适用于处理不需要日期的场景。
3. ZonedDateTime：
   表示带有时区信息的日期和时间的类。结合了 LocalDateTime 和 ZoneId。
4. Duration 和 Period：
   Duration 表示时间上的持续时间，以秒和纳秒为单位。
   Period 表示日期上的时间段，以年、月、日为单位。
5. 全新的设计思想：
   新 API 的设计思想更符合现代编程的需求，强调不可变性、清晰的 API 设计和函数式编程风格。
6. 提供静态方法：
   提供了一系列静态方法，使得创建、操作和转换日期时间更为方便。
   看下面的代码

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.ZonedDateTime;
import java.time.Duration;
import java.time.Period;

public class NewDateTimeClassesExample {
    public static void main(String[] args) {
        // 创建 LocalDate、LocalTime、LocalDateTime
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println("Local Date: " + localDate);
        System.out.println("Local Time: " + localTime);
        System.out.println("Local DateTime: " + localDateTime);

        // 创建带有时区信息的 ZonedDateTime
        ZonedDateTime zonedDateTime = ZonedDateTime.now();
        System.out.println("Zoned DateTime: " + zonedDateTime);

        // 计算两个日期之间的间隔
        LocalDate futureDate = LocalDate.of(2023, 12, 31);
        Period period = Period.between(localDate, futureDate);
        System.out.println("Period between two dates: " + period);

        // 计算两个时间点之间的持续时间
        LocalDateTime futureDateTime = LocalDateTime.of(2023, 12, 31, 23, 59, 59);
        Duration duration = Duration.between(localDateTime, futureDateTime);
        System.out.println("Duration between two date-times: " + duration);
    }
}

在 ISO 8601 标准中，以 “P” 开头的字符串表示一个时间周期（duration），而以 “T” 分隔日期和时间部分。“PT390H2M19.735S” 中，它表示一个时间间隔的持续时间。

PT390H2M19.735S

“2Y” 表示 2 年。 “11M” 表示 11 个月。 “16D” 表示 16 天。
“P” 表示周期的开始。 “T” 表示日期和时间的分隔。 “390H” 表示 390 小时。 “2M” 表示 2 分钟。
“19.735S” 表示 19.735 秒。 因此，“PT390H2M19.735S” 表示一个时间间隔，持续时间为 390 小时、2分钟、19.735 秒。

5. JAVA8在时间的处理上常用到的API

1. LocalDate：
   用于表示日期，不包含具体时间。适用于需要表示生日、开工日期等只关注日期的场景。
   示例：

LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plusDays(1);
LocalTime：

2. 用于表示时间，不包含日期信息。适用于需要表示一天中的具体时间的场景。
   示例：

LocalTime currentTime = LocalTime.now();
LocalTime noon = LocalTime.of(12, 0);

3. LocalDateTime：
   用于表示日期和时间，是 LocalDate 和 LocalTime 的组合。适用于需要同时表示日期和时间的场景。
   示例：

LocalDateTime currentDateTime = LocalDateTime.now();

4. ZonedDateTime：
   用于表示带有时区信息的日期和时间。适用于需要处理时区的场景。
   示例：

ZoneId zoneId = ZoneId.of("America/New_York");
ZonedDateTime zonedDateTime = ZonedDateTime.now(zoneId);

5. Duration：

表示时间间隔，例如两个时间点之间的持续时间。
示例：

LocalDateTime start = LocalDateTime.now();
LocalDateTime end = start.plusHours(2).plusMinutes(30);
Duration duration = Duration.between(start, end);

6. Period：

表示日期间隔，例如两个日期之间的间隔。
示例：

LocalDate startDate = LocalDate.of(2022, 1, 1);
LocalDate endDate = LocalDate.of(2023, 1, 1);
Period period = Period.between(startDate, endDate);

7.TemporalAdjusters：

提供了一些用于调整日期的静态方法，例如获取下一个星期日。
示例：

LocalDate today = LocalDate.now();
LocalDate nextSunday = today.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));

8.。 DateTimeFormatter：
用于日期时间的格式化和解析。

LocalDateTime dateTime = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = dateTime.format(formatter);