怎么用Java8写逻辑

Java 8 是一个重要的版本，引入了许多新特性，如 Lambda 表达式、Stream API、Optional 类、新的日期时间 API 等。这些特性不仅简化了代码，还提高了代码的可读性和可维护性。本文将详细介绍如何使用 Java 8 编写逻辑，涵盖 Lambda 表达式、Stream API、Optional 类等核心特性。

1. Lambda 表达式

Lambda 表达式是 Java 8 引入的最重要的特性之一。它允许你将函数作为参数传递给方法，或者将代码作为数据来处理。Lambda 表达式使得代码更加简洁和易读。

1.1 基本语法

Lambda 表达式的基本语法如下：

(parameters) -> expression

或者

(parameters) -> { statements; }

例如，以下是一个简单的 Lambda 表达式：

(int a, int b) -> a + b

这个 Lambda 表达式接受两个整数参数 a 和 b，并返回它们的和。

1.2 使用 Lambda 表达式

Lambda 表达式通常用于替代匿名内部类。例如，以下是一个使用匿名内部类的例子：

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello, World!");
    }
};

使用 Lambda 表达式可以将其简化为：

Runnable r = () -> System.out.println("Hello, World!");

1.3 函数式接口

Lambda 表达式通常与函数式接口一起使用。函数式接口是只包含一个抽象方法的接口。Java 8 提供了许多内置的函数式接口，如 Runnable、Callable、Comparator 等。

例如，以下是一个自定义的函数式接口：

@FunctionalInterface
interface MyFunction {
    int apply(int a, int b);
}

你可以使用 Lambda 表达式来实现这个接口：

MyFunction add = (a, b) -> a + b;
MyFunction multiply = (a, b) -> a * b;

System.out.println(add.apply(2, 3)); // 输出 5
System.out.println(multiply.apply(2, 3)); // 输出 6

2. Stream API

Stream API 是 Java 8 引入的另一个重要特性。它允许你以声明式的方式处理集合数据。Stream API 提供了丰富的操作，如过滤、映射、排序、归约等。

2.1 创建 Stream

你可以通过多种方式创建 Stream，例如从集合、数组、I/O 资源等。

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

2.2 中间操作

中间操作是对 Stream 进行处理的操作，如过滤、映射、排序等。中间操作返回一个新的 Stream，因此可以进行链式调用。

List<String> list = Arrays.asList("a", "b", "c");
List<String> result = list.stream()
    .filter(s -> s.startsWith("a"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

2.3 终端操作

终端操作是 Stream 处理的最后一步，如收集、计数、归约等。终端操作会触发 Stream 的处理，并返回一个非 Stream 的结果。

List<String> list = Arrays.asList("a", "b", "c");
long count = list.stream()
    .filter(s -> s.startsWith("a"))
    .count();

2.4 并行流

Stream API 还支持并行处理，可以通过 parallelStream() 方法创建并行流。

List<String> list = Arrays.asList("a", "b", "c");
List<String> result = list.parallelStream()
    .filter(s -> s.startsWith("a"))
    .collect(Collectors.toList());

3. Optional 类

Optional 类是 Java 8 引入的一个容器类，用于解决空指针异常的问题。Optional 类可以包含一个非空值，也可以为空。

3.1 创建 Optional

你可以使用 Optional.of()、Optional.ofNullable() 和 Optional.empty() 来创建 Optional 对象。

Optional<String> optional = Optional.of("Hello");
Optional<String> optionalNullable = Optional.ofNullable(null);
Optional<String> optionalEmpty = Optional.empty();

3.2 使用 Optional

Optional 类提供了许多方法来判断值是否存在，并对其进行操作。

Optional<String> optional = Optional.of("Hello");
if (optional.isPresent()) {
    System.out.println(optional.get());
}

optional.ifPresent(System.out::println);

3.3 链式调用

Optional 类支持链式调用，可以使用 map()、flatMap()、filter() 等方法对 Optional 进行处理。

Optional<String> optional = Optional.of("Hello");
Optional<String> result = optional
    .map(String::toUpperCase)
    .filter(s -> s.length() > 5);

3.4 默认值

你可以使用 orElse()、orElseGet() 和 orElseThrow() 方法来为 Optional 提供默认值。

Optional<String> optional = Optional.empty();
String result = optional.orElse("Default Value");
String resultGet = optional.orElseGet(() -> "Default Value");
String resultThrow = optional.orElseThrow(() -> new RuntimeException("Value not present"));

4. 新的日期时间 API

Java 8 引入了新的日期时间 API，位于 java.time 包中。新的日期时间 API 解决了旧版 Date 和 Calendar 类的许多问题，如线程安全、不可变性等。

4.1 LocalDate、LocalTime 和 LocalDateTime

LocalDate、LocalTime 和 LocalDateTime 是新的日期时间 API 中的核心类，分别表示日期、时间和日期时间。

LocalDate date = LocalDate.now();
LocalTime time = LocalTime.now();
LocalDateTime dateTime = LocalDateTime.now();

4.2 格式化与解析

你可以使用 DateTimeFormatter 类来格式化和解析日期时间。

LocalDateTime dateTime = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatted = dateTime.format(formatter);
LocalDateTime parsed = LocalDateTime.parse("2023-10-01 12:00:00", formatter);

4.3 时间差计算

你可以使用 Duration 和 Period 类来计算时间差。

LocalDateTime start = LocalDateTime.now();
LocalDateTime end = start.plusHours(2);
Duration duration = Duration.between(start, end);
System.out.println(duration.toHours()); // 输出 2

LocalDate startDate = LocalDate.now();
LocalDate endDate = startDate.plusMonths(1);
Period period = Period.between(startDate, endDate);
System.out.println(period.getMonths()); // 输出 1

5. 其他新特性

除了上述特性外，Java 8 还引入了许多其他新特性，如默认方法、方法引用、重复注解等。

5.1 默认方法

默认方法允许接口提供默认实现，从而在不破坏现有实现的情况下扩展接口。

interface MyInterface {
    default void myMethod() {
        System.out.println("Default Method");
    }
}

5.2 方法引用

方法引用允许你直接引用已有方法或构造器，从而简化 Lambda 表达式。

List<String> list = Arrays.asList("a", "b", "c");
list.forEach(System.out::println);

5.3 重复注解

Java 8 允许在同一元素上重复使用注解。

@Repeatable(MyAnnotations.class)
@interface MyAnnotation {
    String value();
}

@MyAnnotation("a")
@MyAnnotation("b")
class MyClass {}

6. 总结

Java 8 引入了许多新特性，如 Lambda 表达式、Stream API、Optional 类、新的日期时间 API 等。这些特性不仅简化了代码，还提高了代码的可读性和可维护性。通过合理使用这些特性，你可以编写出更加简洁、高效的 Java 代码。

在实际开发中，建议根据具体需求选择合适的特性。例如，对于集合处理，可以使用 Stream API；对于空值处理，可以使用 Optional 类；对于日期时间处理，可以使用新的日期时间 API。通过不断实践和积累经验，你将能够更好地掌握 Java 8 的新特性，并编写出高质量的代码。