Java Lambda 表达式详解

变量捕获

在 Java 中，Lambda 表达式允许以更简洁的方式实现接口中的方法。Lambda 表达式可以捕获其所在上下文中有效的 final 或 effectively final（实际上 final，即在 Lambda 表达式内部没有被修改）的局部变量和成员变量。这种捕获机制使得 Lambda 表达式能够访问和使用这些变量，而无需显式地将它们作为参数传递给 Lambda 表达式。

局部变量捕获

对于局部变量，Lambda 表达式只能捕获那些被声明为 final 或者实际上未被修改的变量（effectively final）。这意味着即使变量没有被显式地声明为 final，但如果你在 Lambda 表达式之外没有修改这个变量的值，那么这个变量也可以被 Lambda 表达式捕获。

public class LambdaDemo {
    public static void main(String[] args) {
        final int number = 10; // 显式声明为 final
        int anotherNumber = 20; // 实际上 final，因为之后没有被修改
        // 使用 Lambda 表达式
        Runnable r = () -> System.out.println(number); // 可以捕获 number
        // Runnable r = () -> System.out.println(anotherNumber); // 也可以捕获 anotherNumber
        // 如果尝试修改 anotherNumber，则上面的 Lambda 表达式将无法编译
        // anotherNumber = 30;
        r.run();
    }
}

成员变量捕获

与局部变量不同，Lambda 表达式可以直接访问所在类的成员变量，无论这些成员变量是否被声明为 final。这是因为成员变量是类的属性，它们的生命周期与类的实例相同，而 Lambda 表达式只是类的实例的一个方法或者构造器中的一部分。

public class LambdaDemo {
    private int classVariable = 42;
    public void display() {
        Runnable r = () -> System.out.println(classVariable); // 直接访问成员变量
        r.run();
    }
    public static void main(String[] args) {
        new LambdaDemo().display();
    }
}

总结

1. Lambda 表达式内部不能修改捕获的局部变量（除非这些变量是数组或集合的元素，并且通过引用访问这些元素）。
2. Lambda 表达式可以捕获并访问类的成员变量和静态变量，无需任何限制。
3. Java 8 及以上版本支持 Lambda 表达式。

Lambda 在集合中的使用

为了能够让 Lambda 和 Java 的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与 Lambda 表达式对接。

代码示例

public class Test2 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("hello",13);
        map.put("abc",3);
        map.put("zhangsan",31);
        /*map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("key: "+s +" val: "+integer);
            }
        });*/
        map.forEach((s, integer) -> System.out.println("key: "+s +" val: "+integer));
    }
    public static void main1(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("abc");
        list.add("zhangsan");
        /*list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        list.forEach(s -> System.out.println(s));
        /* list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });*/
        list.sort((o1, o2) -> o1.compareTo(o2));
        System.out.println("====");
        list.forEach(s -> System.out.println(s));
    }
}

Lambda 的优缺点

优点

1. 代码简洁性：Lambda 表达式可以使得代码更加简洁易读，尤其是当实现简单的接口时。相比传统的匿名内部类，Lambda 表达式在语法上更加简洁。
2. 增强功能性接口的使用：Lambda 表达式常与功能性接口（Functional Interface，即只包含一个抽象方法的接口）一起使用，使得这些接口的实现变得更加容易和直观。
3. 易于并行计算：Java 8 的 Streams API 与 Lambda 表达式相结合，使得数据集的并行处理变得简单而高效。开发者可以轻松地将顺序操作转换为并行操作，从而提高程序的执行效率。
4. 促进函数式编程风格：Lambda 表达式和 Streams API 等特性促进了 Java 中函数式编程风格的应用，使得 Java 不再仅仅是面向对象的编程语言，也可以用于实现更加灵活的函数式编程范式。
5. 提升 API 的设计：Lambda 表达式使得 API 的设计更加灵活和强大。开发者可以设计出更加通用和灵活的接口，以适应不同的使用场景。

缺点

1. 学习曲线：对于习惯于传统 Java 编程范式的开发者来说，Lambda 表达式和 Streams API 等新特性可能需要一定的时间来学习和适应。
2. 调试难度：由于 Lambda 表达式在语法上的简洁性，有时候可能会使得调试变得更加困难。尤其是在复杂的 Lambda 表达式中，追踪错误来源可能会比较棘手。
3. 性能开销：虽然 Lambda 表达式在大多数情况下不会对性能产生显著影响，但在某些极端情况下（如大量使用 Lambda 表达式和 Streams API 进行密集计算），可能会引入一定的性能开销。这是因为 Lambda 表达式和 Streams API 的底层实现可能需要更多的内存和 CPU 资源。
4. 可读性和可维护性：虽然 Lambda 表达式可以使代码更加简洁，但在某些情况下，过度使用或滥用 Lambda 表达式可能会降低代码的可读性和可维护性。例如，过于复杂的 Lambda 表达式可能会使得其他开发者难以理解其逻辑。
5. 限制了变量的使用：Lambda 表达式内部只能访问标记为 final 或 effectively final 的局部变量。这一限制可能会在某些情况下造成不便，尤其是当需要在 Lambda 表达式内部修改外部变量时。