Lamda 表达式实现原理

1、匿名内部类

Lambda 表达式本质上是匿名内部类的语法糖。编译器会将 Lambda 表达式转换为一个实现了对应函数式接口的匿名内部类。

// Lambda 表达式
Runnable r = () -> System.out.println("Hello, Lambda!");

// 等价的匿名内部类
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello, Lambda!");
    }
};

2、invokedynamic 指令

为了优化 Lambda 表达式的性能，Java 7 引入了 invokedynamic 指令。该指令允许 JVM 在运行时动态地确定方法调用，而不是在编译时静态确定。

JVM 利用 invokedynamic 指令实现 Lambda 表达式的方式如下:

1. 编译阶段: 编译器遇到 Lambda 表达式时，并不会将其直接转换为匿名内部类。
2. 生成 invokedynamic 指令: 编译器会生成一个 invokedynamic 指令，指向一个引导方法（bootstrap method）。这个指令并不直接调用 Lambda 表达式，而是将调用委托给了引导方法。
3. 引导方法: 引导方法在第一次调用 Lambda 表达式时执行，其作用是生成一个实现了对应函数式接口的类，并将 Lambda 表达式的逻辑嵌入到该类的实现方法中。
4. 缓存和调用: 引导方法会将生成的类缓存起来，以便后续调用。 之后每次调用 Lambda 表达式时，都会直接调用缓存的类中的方法。

invokedynamic 指令带来的优势:

• 延迟加载: Lambda 表达式的实现类只在第一次调用时创建，避免了不必要的对象创建，减少了内存占用。
• 灵活性: JVM 可以根据情况选择最佳的实现方式，例如可以将 Lambda 表达式转换为匿名内部类，也可以使用动态代理等方式实现。
• 性能优化: invokedynamic 指令允许 JVM 对 Lambda 表达式进行更 aggressive 的优化，例如内联 Lambda 表达式的方法体

Lambda 表达式的实现是 Java 语言和 JVM 共同努力的结果。编译器负责将 Lambda 表达式转换为 invokedynamic 指令，JVM 则负责在运行时动态地生成和调用 Lambda 表达式的实现类。 这种实现方式结合了匿名内部类的灵活性和 invokedynamic 指令的性能优势，使得 Java Lambda 表达式既简洁易用，又具备良好的性能

Lamda 应用场景

• 集合操作: 使用 Stream API 对集合进行过滤、映射、排序等操作时，Lambda 表达式可以简洁地定义操作逻辑。
• 事件处理: 为按钮点击、鼠标移动等事件添加监听器时，Lambda 表达式可以简化事件处理逻辑。
• 多线程编程: 创建线程或提交任务时，Lambda 表达式可以简洁地定义线程执行逻辑。
• 自定义函数式接口: Lambda 表达式可以方便地实现自定义的函数式接口

1、 集合操作

import java.util.Arrays;
import java.util.List;

public class LambdaCollectionExample {

    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 过滤: 使用 Lambda 表达式过滤长度大于 4 的名字
        names.stream()
                .filter(name -> name.length() > 4)
                .forEach(System.out::println);

        // 映射: 使用 Lambda 表达式将名字转换为大写
        names.stream()
                .map(String::toUpperCase)
                .forEach(System.out::println);

        // 排序: 使用 Lambda 表达式按名字长度排序
        names.stream()
                .sorted((name1, name2) -> Integer.compare(name1.length(), name2.length()))
                .forEach(System.out::println);
    }
}

2、事件处理

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class LambdaEventHandlingExample {

    public static void main(String[] args) {
        JFrame frame = new JFrame("Lambda Event Handling");
        JButton button = new JButton("Click Me");

        // 使用 Lambda 表达式添加按钮点击事件监听器
        button.addActionListener(e -> {
            JOptionPane.showMessageDialog(frame, "Button Clicked!");
        });

        frame.add(button);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);
    }
}

3、多线程编程

public class LambdaMultithreadingExample {

    public static void main(String[] args) {
        // 使用 Lambda 表达式创建线程
        new Thread(() -> System.out.println("Hello from Lambda Thread!")).start();

        // 使用 Lambda 表达式提交任务到线程池
        Runnable task = () -> System.out.println("Task executed by Lambda!");
        Thread thread = new Thread(task);
        thread.start();
    }
}

4、自定义函数式接口

@FunctionalInterface
interface StringModifier {
    String modify(String str);
}

public class LambdaCustomFunctionalInterfaceExample {

    public static void main(String[] args) {
        // 使用 Lambda 表达式实现自定义函数式接口
        StringModifier toUpperCase = str -> str.toUpperCase();
        StringModifier toLowerCase = str -> str.toLowerCase();

        String name = "John Doe";

        System.out.println(toUpperCase.modify(name)); // 输出: JOHN DOE
        System.out.println(toLowerCase.modify(name)); // 输出: john doe
    }
}

Lamda 使用注意事项以及优缺点

1、注意事项

• Lambda 表达式只能用于函数式接口 : 函数式接口是指只有一个抽象方法的接口。
• Lambda 表达式的参数类型可以省略 : 编译器可以根据上下文推断出参数类型。
• Lambda 表达式可以访问外部变量 : 但是只能访问 final 或 effectively final 的变量。
• Lambda 表达式可以用于方法引用 : 可以使用 :: 运算符引用方法

2、优点

• 代码简洁: Lambda 表达式可以大幅简化代码，提高代码可读性。
• 提高代码可维护性: Lambda 表达式可以使代码更易于理解和维护。
• 支持函数式编程: Lambda 表达式是 Java 支持函数式编程的重要特性

3、缺点

• 调试困难: Lambda 表达式可能会增加调试的难度。
• 性能开销: Lambda 表达式可能会带来一些性能开销(对象创建: 每次调用 Lambda 表达式，都会创建一个新的匿名内部类对象。如果在循环中频繁调用 Lambda 表达式，可能会产生大量的对象，增加 GC 压力)，但通常可以忽略不计

Lamda 性能开销测试

import java.util.function.Function;

public class LambdaPerformanceTest {

    public static void main(String[] args) {
        // 使用 Lambda 表达式
        Function<Integer, Integer> squareLambda = x -> x * x;
        
        // 使用匿名内部类
        Function<Integer, Integer> squareAnonymous = new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer x) {
                return x * x;
            }
        };

        // 测试 Lambda 表达式性能
        long startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            squareLambda.apply(i);
        }
        long endTime = System.nanoTime();
        System.out.println("Lambda execution time: " + (endTime - startTime) + " ns");

        // 测试匿名内部类性能
        startTime = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            squareAnonymous.apply(i);
        }
        endTime = System.nanoTime();
        System.out.println("Anonymous class execution time: " + (endTime - startTime) + " ns");
    }
}

结果分析:

运行以上代码，你会发现 Lambda 表达式的执行时间和匿名内部类的执行时间相差不大，甚至 Lambda 表达式可能会略快一些。
这是因为 JVM 对 Lambda 表达式进行了优化，减少了对象创建和方法调用的开销。

结论:

尽管 Lambda 表达式在实现上依赖于匿名内部类，但 JVM 通过 invokedynamic 指令和缓存机制优化了其性能。
在大多数情况下，Lambda 表达式带来的性能开销非常小，可以忽略不计