Java Lambda：简洁、灵活、高效的函数式编程范式(续)

站长

2023年05月31日 20:01 · 阅读数 74

接上文：juejin.cn/post/723880…

4. 方法引用与构造函数引用

4.1 方法引用的基本用法

Java方法引用是一种简化Lambda表达式的语法，它提供了一种直接引用已存在的方法的方式。方法引用可以被看作是Lambda表达式的一种简写形式，用于将方法作为值传递。

Java方法引用有以下三种类型：

静态方法引用：静态方法引用是引用静态方法的方式。它的语法是类名::静态方法名，可以直接引用已存在的静态方法。

示例代码：

// 定义一个静态方法
class MathUtils {
    public static int square(int num) {
        return num * num;
    }
}

// 静态方法引用
Function<Integer, Integer> squareFunction = MathUtils::square;
int result = squareFunction.apply(5); // 调用静态方法 square(5)

实例方法引用：实例方法引用是引用某个对象的实例方法的方式。它的语法是对象::实例方法名，可以直接引用已存在的实例方法。

示例代码：

// 定义一个类
class Printer {
    public void printMessage(String message) {
        System.out.println(message);
    }
}

// 实例方法引用
Printer printer = new Printer();
Consumer<String> printConsumer = printer::printMessage;
printConsumer.accept("Hello, world!"); // 调用实例方法 printMessage("Hello, world!")

构造函数引用：构造函数引用是引用构造函数来创建新对象的方式。它的语法是类名::new，可以直接引用已存在的构造函数。

示例代码：

// 定义一个类
class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }
}

// 构造函数引用
Function<String, Person> personConstructor = Person::new;
Person person = personConstructor.apply("John"); // 调用构造函数 new Person("John")

方法引用可以简化代码，使代码更加简洁、可读。它适用于Lambda表达式只是调用一个已存在方法的场景，避免了编写重复的方法实现代码。方法引用还保留了方法的签名，使得代码的意图更加清晰。需要注意的是，方法引用是一种函数式接口的实现，因此它只能用于与函数式接口兼容的上下文中。

需要注意的是，方法引用并不会调用方法，而是提供了对方法的引用，以便在需要时进行调用。因此，方法引用的执行是惰性的，只有在实际调用时才会执行相关的方法。

4.2 构造函数引用的使用

在Java中，构造函数引用是一种通过引用构造函数来创建新对象的方式。它使用语法类名::new来表示对构造函数的引用。构造函数引用可以被用作函数式接口的实现，从而简化对象的创建过程。

下面是使用构造函数引用创建对象的示例代码：

// 定义一个类
class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }
}

// 构造函数引用
Function<String, Person> personConstructor = Person::new;
Person person = personConstructor.apply("John");

在上述示例中，我们定义了一个Person类，并在其构造函数中接受一个name参数。然后，我们使用构造函数引用Person::new创建了一个Function类型的对象personConstructor，该对象接受一个String类型的参数并返回一个Person对象。最后，我们通过personConstructor.apply("John")调用构造函数引用来创建了一个名为person的Person对象。

使用构造函数引用创建对象的优势如下：

简化代码：构造函数引用消除了在Lambda表达式中编写完整的对象创建代码的需要。它提供了一种简洁的语法，直接引用构造函数，使代码更加清晰、易读。
类型安全：构造函数引用通过编译器进行类型检查，确保传递给构造函数引用的参数类型与目标构造函数的参数类型相匹配。这样可以在编译时捕获类型错误，提高代码的健壮性。
延迟加载：与传统的对象创建方式相比，构造函数引用是一种延迟加载的方式。它并不立即创建对象，而是在需要时才通过调用构造函数来创建新的实例。这样可以延迟对象的创建，避免不必要的开销。
与函数式接口兼容：构造函数引用可以与函数式接口结合使用，作为函数式接口的实现。这为函数式编程提供了更加灵活的选项，可以使用构造函数引用创建对象并将其作为函数式接口的参数或返回值。

5. Lambda与Stream API

5.1 Stream API简介

Java Stream API是Java 8引入的一种用于处理集合数据的功能强大的工具。它提供了一种流式操作的方式，允许我们以声明式的方式对集合进行处理和转换。Stream API可以极大地简化集合的操作和处理，提高代码的可读性和可维护性。

Stream API的主要作用包括：

简化集合操作：Stream API提供了丰富的操作方法，如过滤、映射、排序、归约等，可以直接应用于集合上。使用Stream API，我们可以以一种更简洁、更流畅的方式对集合进行操作，而无需编写显式的循环和条件语句。
延迟计算：Stream API中的操作是延迟计算的，即在执行终端操作之前，中间操作不会立即执行。这种延迟计算的特性使得我们可以根据需要组合多个操作，并在最终需要结果时才进行计算，提高了效率。
并行处理：Stream API内置支持并行处理，可以自动将集合的操作并行化处理，充分利用多核处理器的性能优势。通过简单的API调用，我们可以轻松地将顺序处理转换为并行处理，提高处理大数据集合的效率。
函数式编程风格：Stream API采用函数式编程的思想，将集合的处理操作抽象为函数，支持Lambda表达式和方法引用。这种函数式编程的风格使得代码更加简洁、可读，同时也使得代码更具表达力和灵活性。

使用Stream API可以实现一系列的操作，例如：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 过滤操作，获取偶数
List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());

// 映射操作，将每个数加倍
List<Integer> doubledNumbers = numbers.stream()
                                      .map(n -> n * 2)
                                      .collect(Collectors.toList());

// 排序操作，按照降序排序
List<Integer> sortedNumbers = numbers.stream()
                                     .sorted(Comparator.reverseOrder())
                                     .collect(Collectors.toList());

// 归约操作，求和
int sum = numbers.stream()
                 .reduce(0, Integer::sum);

在上述示例中，我们通过Stream API实现了过滤、映射、排序和归约等操作。通过流式操作的方式，我们可以以简洁的方式完成对集合的处理，并且代码更具可读性和可维护性。此外，我们还可以根据需要使用并行流来提高处理效率。

5.2 常用的Stream操作方法

Java Stream API提供了一系列常用的操作方法，用于对Stream进行过滤、映射、排序、归约等操作。下面介绍一些常用的操作方法以及它们的使用场景和示例代码：

filter()：过滤操作

使用场景：根据指定条件过滤掉不满足条件的元素，返回满足条件的元素组成的新Stream。

示例代码：

javaCopy code
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());
// 过滤出偶数 [2, 4, 6, 8, 10]

map()：映射操作

使用场景：将Stream中的每个元素映射为另一个元素，返回映射后的新Stream。

示例代码：

javaCopy code
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<Integer> nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());
// 映射为名字长度 [5, 3, 7]

sorted()：排序操作

使用场景：对Stream中的元素进行排序，返回排序后的新Stream。

示例代码：

javaCopy code
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 6);

List<Integer> sortedNumbers = numbers.stream()
                                     .sorted()
                                     .collect(Collectors.toList());
// 排序后的列表 [1, 2, 5, 6, 8]

collect()：收集操作

使用场景：将Stream中的元素收集到一个结果容器中，例如List、Set、Map等。

示例代码：

javaCopy code
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

Set<String> nameSet = names.stream()
                           .collect(Collectors.toSet());
// 收集为Set集合 {"Alice", "Bob", "Charlie"}

这些操作方法只是Java Stream API中的一部分，还有其他许多方法可用于更复杂的操作。这些方法使得对集合的处理更加简洁、可读，并且可以通过流式操作进行链式调用。通过使用Stream API，我们可以更轻松地进行集合的操作和处理，减少了冗余的代码和循环结构，提高了代码的可读性和可维护性。

6. Lambda的限制与注意事项

6.1 对变量的访问限制

在Java Lambda表达式中，对外部变量的访问有一些限制，这些限制主要适用于局部变量、实例变量和静态变量。

局部变量：
- 局部变量必须被声明为final或者是实际上的final（即在Lambda表达式中不会被修改）才能在Lambda表达式内部访问。
- 这是因为Lambda表达式可能在不同的线程中执行，访问非final的局部变量可能导致线程安全问题。
- Java 8之后，可以在Lambda表达式中访问局部变量时，编译器会隐式地将其当作final变量对待。
实例变量和静态变量：
- 实例变量和静态变量可以在Lambda表达式中直接访问，无需声明为final。
- Lambda表达式内部对实例变量和静态变量的修改会反映在其定义的类中。

下面是一些示例代码来说明对外部变量的访问限制：

public class LambdaVariableAccess {
    private int instanceVar = 10;
    private static int staticVar = 20;

    public void testLambda() {
        int localVar = 30;

        // 访问局部变量
        Runnable runnable = () -> {
            System.out.println(localVar);
            // localVar = 40;  // 错误，局部变量在Lambda内部被隐式视为final
        };

        // 访问实例变量
        Runnable instanceRunnable = () -> {
            System.out.println(instanceVar);
            instanceVar = 50;  // 可以修改实例变量
        };

        // 访问静态变量
        Runnable staticRunnable = () -> {
            System.out.println(staticVar);
            staticVar = 60;  // 可以修改静态变量
        };
    }
}

在上述示例中，testLambda方法中定义了局部变量localVar，实例变量instanceVar和静态变量staticVar。Lambda表达式可以访问实例变量和静态变量，并对其进行修改，但无法修改局部变量。

6.2 Lambda中的异常处理

Java Lambda表达式中的异常处理方式与传统的方法相同，可以通过try-catch块来捕获和处理异常。但是，需要注意Lambda表达式中的异常分为两种类型：受检异常（checked exception）和未受检异常（unchecked exception）。

受检异常：
- 受检异常是指在方法声明中被标记为throws的异常，编译器要求必须显式地处理或向上层方法传递这些异常。
- 在Lambda表达式中，如果表达式体内可能抛出受检异常，可以使用try-catch块来捕获异常并进行处理。
- 如果Lambda表达式内部没有显式地处理受检异常，可以在函数式接口中使用throws声明来传递异常，或者将Lambda表达式包装在try-catch块中。
- 示例代码：
```
Function<Integer, Integer> divideByZero = num -> {
    try {
        return 10 / num;
    } catch (ArithmeticException e) {
        // 处理异常
        System.out.println("除以零错误：" + e.getMessage());
        return 0;
    }
};
```
未受检异常：
- 未受检异常是指继承自RuntimeException或Error的异常，编译器不会强制要求进行处理或声明。
- 在Lambda表达式中抛出未受检异常时，不需要显式地进行捕获或声明。
- 示例代码：
```
Consumer<String> printUpperCase = str -> {
    if (str == null) {
        throw new IllegalArgumentException("输入不能为空");
    }
    System.out.println(str.toUpperCase());
};
```

需要注意的是，Lambda表达式中的异常处理应根据具体的业务需求进行选择。对于受检异常，可以根据情况决定是捕获并处理异常，还是向上层方法传递异常；对于未受检异常，可以在Lambda表达式内部直接抛出异常。在使用Lambda表达式时，应注意异常的处理，以确保代码的健壮性和可靠性。

6.3 Lambda的性能考虑

Java Lambda表达式在运行时会产生一些性能开销，主要包括创建Lambda的开销和捕获上下文的成本。下面是关于Java Lambda表达式性能问题的一些讨论、建议和优化技巧：

创建Lambda的开销：
- 创建Lambda表达式时会生成一个实现函数式接口的匿名内部类，并实例化该类的对象。这个过程需要一定的时间和资源。
- 建议避免在性能敏感的代码路径中频繁创建Lambda表达式，尤其是在循环中。可以考虑将Lambda表达式提取为单独的方法或静态变量，以便在需要时重复使用。
捕获上下文的成本：
- Lambda表达式可以捕获外部作用域的变量，这些变量会被复制或创建对应的引用，捕获上下文的过程可能会带来一定的开销。
- 对于频繁使用的Lambda表达式，尽量避免捕获过多的上下文变量，尽量减少捕获上下文的复杂度，以降低性能开销。
- 如果不需要捕获上下文变量，可以使用静态方法引用或实例方法引用，而不是Lambda表达式。
使用基本类型：
- Lambda表达式在处理基本类型时，需要进行自动装箱和拆箱操作，这可能导致一定的性能损失。
- 可以考虑使用Java 8引入的特殊的函数式接口（例如IntConsumer、DoubleFunction等），它们直接支持基本类型，避免了装箱和拆箱的开销。
并行流注意事项：
- 并行流使用多线程并行处理数据，Lambda表达式的性能问题在并行流中可能会更加显著。
- 在使用并行流时，需要注意Lambda表达式的线程安全性和并发性能，避免共享可变状态和数据竞争。

总体而言，对于绝大多数应用，Lambda表达式的性能开销是可以接受的。然而，在性能敏感的场景中，需要注意Lambda表达式的创建开销和捕获上下文的成本，并采取相应的优化措施，例如重用Lambda表达式、减少捕获上下文的复杂度、使用基本类型接口等。对于并行流的使用，还需要考虑线程安全和并发性能方面的问题。最重要的是，性能优化应该基于具体的场景和需求，通过测试和性能分析来指导优化工作。

7. 实际应用场景

7.1 函数式编程的优势和适用场景

函数式编程具有许多优势，使其成为解决特定问题和应用于特定场景的有力工具。下面是一些函数式编程的优势和适用场景：

代码简洁：函数式编程通过Lambda表达式和方法引用等特性，可以将代码写得更加简洁、紧凑。它提供了一种更直观、更简单的编码方式，减少了样板代码和冗余代码的数量。
可读性强：函数式编程鼓励使用一系列的函数操作来解决问题，这使得代码更易读、更易理解。函数式代码通常具有良好的可读性，因为它更接近于自然语言的表达方式。
声明式编程：函数式编程强调"做什么"而非"怎么做"，它更关注于问题的描述和数据之间的转换，而不是具体的实现细节。这种声明式的编程风格使得代码更加清晰，易于维护和理解。
并发编程的便利性：函数式编程的不可变性和无副作用的特性使得并发编程更加容易。函数式代码可以避免共享可变状态和数据竞争的问题，从而简化了并发编程的复杂性。
测试容易：函数式编程强调函数的纯性，即函数的输出仅由输入决定，没有副作用。这种纯函数易于测试，因为对于给定的输入，它们总是产生相同的输出。

函数式编程适用于以下场景：

数据转换和处理：函数式编程在处理集合、列表、映射等数据结构时非常有用。通过使用Lambda表达式和流式操作，可以简化对数据的转换、过滤、映射和聚合等操作。
并发编程：函数式编程的不可变性和无副作用的特性使得并发编程更容易。使用函数式编程可以避免共享可变状态和数据竞争的问题，从而提高并发性能和可靠性。
事件驱动编程：函数式编程可以很好地应用于事件驱动的编程模型，例如GUI开发、响应式编程等。通过使用Lambda表达式和函数式接口，可以将事件处理器和回调函数以更简洁和灵活的方式组织起来。

7.2 在项目中使用Lambda的实例：

以下是一些实际项目中使用Lambda表达式和函数式编程的案例：

集合处理：使用Lambda表达式和流式操作可以简化对集合的过滤、映射、排序和聚合等操作。例如，在一个学生管理系统中，可以使用Lambda表达式从学生列表中筛选出成绩优秀的学生，或者根据条件对学生进行排序。

List<Student> excellentStudents = students.stream()
                                           .filter(student -> student.getGrade() >= 90)
                                           .sorted(Comparator.comparing(Student::getGrade).reversed())
                                           .collect(Collectors.toList());

并发编程：使用函数式接口Runnable和Callable结合Lambda表达式可以简化线程和并发编程。例如，可以使用Lambda表达式创建一个新的线程：

Thread thread = new Thread(() -> {
    // 执行线程任务
});
thread.start();

GUI开发：在GUI开发中，使用Lambda表达式可以简化事件处理器的定义。例如，在JavaFX中，可以使用Lambda表达式定义按钮的点击事件处理器：

Button button = new Button("Click me");
button.setOnAction(event -> {
    // 处理按钮点击事件
});

这些示例展示了如何使用Lambda表达式和函数式编程思想来简化代码，提高可读性，并在实际项目中应用函数式编程的优势。

总结

Java Lambda表达式的引入为我们提供了一种简洁、灵活、高效的函数式编程范式。通过使用Lambda，我们可以简化代码、提高开发效率，并且能够更好地利用Java 8及更高版本的新特性。然而，我们也需要注意Lambda的一些限制和注意事项，以确保在使用Lambda时能够获得最佳的性能和可维护性。在实际应用中，我们可以通过函数式编程和Lambda表达式来解决许多常见的编程问题，并提高代码的可读性和可维护性。

转载自:https://juejin.cn/post/7238978524031533115