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

接上文：/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表达式来处理许多常见的编程问题，并进步代码的可读性和可维护性。

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

4. 办法引证与结构函数引证

4.1 办法引证的根本用法

4.2 结构函数引证的运用

5. Lambda与Stream API

5.1 Stream API简介

5.2 常用的Stream操作办法

6. Lambda的约束与留意事项

6.1 对变量的拜访约束

6.2 Lambda中的反常处理

6.3 Lambda的功能考虑

7. 实践运用场景

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

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

总结

相关文章

android framework13-status bar[03NavigationBar]

Spring之Bean实例化的四种方式

从根上理解Cglib与JDK动态代理

Xmake v2.7.8 发布，改进包虚拟环境和构建速度

作者信息