lambda表达式

Java中的Lambda表达式

Java中的Lambda表达式，也称为闭包，是Java 8引入的重要新特性。它允许将函数作为方法的参数传递，或者将函数作为返回值。Lambda表达式的引入使得Java代码更加简洁和易于阅读，是Java向函数式编程迈进的一大步。

Lambda表达式的基本语法

Lambda表达式的基本语法包括参数列表、箭头符号->以及表达式主体。参数列表可以是空的，也可以包含多个参数，参数之间用逗号分隔。表达式主体可以是单行的表达式，也可以是多行的语句块。如果只有一个返回值，可以使用return关键字返回；如果没有返回值，可以省略return关键字。

(参数列表) -> 表达式
或
(参数列表) -> { 语句块; }

Lambda表达式的应用场景

Lambda表达式主要用于实现只有一个抽象方法的接口，即函数式接口。Java中的函数式接口包括Runnable、Callable、Comparator等，它们都有一个抽象方法。通过Lambda表达式，你可以直接传递一个函数作为参数，或者返回一个函数，从而实现更加简洁和灵活的编程方式。

示例

以下是一个使用Lambda表达式实现Runnable接口的例子：

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class LambdaExample {
    public static void main(String[] args) throws InterruptedException {
        // 使用Lambda表达式创建一个线程
        Thread thread = Executors.newSingleThreadExecutor().submit(
            () -> System.out.println("Hello from Lambda!")
        );
        thread.join(1000);
    }
}

在这个例子中，我们创建了一个线程，该线程在启动时会打印出"Hello from Lambda!"。这是通过传递一个Lambda表达式作为参数给Executors.newSingleThreadExecutor()方法实现的。

以下是一个使用Lambda表达式实现Callable接口的例子：

import java.util.concurrent.Callable;

public class CallableLambdaExample {
    
    public static void main(String[] args) {
        // 创建一个Callable对象，它使用Lambda表达式来实现
        Callable<Integer> c = () -> {
            int a = 10;
            int b = 20;
            return a + b; // 返回两个数的和
        };
        
        // 使用Callable对象
        try {
            // 提交Callable任务到线程池执行
            Integer result = new java.util.concurrent.FutureTask<>(c).get();
            System.out.println("Sum of numbers is: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们创建了一个Callable接口的匿名实现，它通过Lambda表达式来定义call方法的行为。call方法计算两个整数a和b的和，并返回结果。

以下是一个使用Lambda表达式实现Comparator接口的例子：

import java.util.Arrays;
import java.util.Comparator;

public class LambdaComparatorExample {
    public static void main(String[] args) {
        // 创建一个对象数组
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 20),
            new Person("Charlie", 40)
        };

        // 使用Lambda表达式创建一个Comparator实例，根据Person对象的年龄进行升序排序
        Comparator<Person> ageComparator = (person1, person2) -> person1.getAge().compareTo(person2.getAge());

        // 使用Comparator对Person数组进行排序
        Arrays.sort(people, ageComparator);

        // 打印排序后的数组
        for (Person person : people) {
            System.out.println(person.getName() + ", " + person.getAge());
        }
    }
}

class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

在这个例子中，Person类有两个属性：name和age。我们创建了一个Person对象数组，并希望根据age属性对这些对象进行排序。

使用Lambda表达式，我们创建了一个Comparator实例，该实例比较两个Person对象的年龄。getAge()方法返回每个Person对象的年龄，然后使用Integer类的compareTo方法来比较这两个年龄。

接着，我们使用Arrays.sort方法对people数组进行排序，传入ageComparator作为参数。最后，我们遍历并打印出排序后的Person对象。

注意事项

在使用Lambda表达式时，需要注意的是，它们只能访问在相同作用域中定义的final变量，或者实际上是final的局部变量。这是因为Lambda表达式在技术上是通过invokedynamic指令实现的，这意味着它们是在运行时动态生成的。因此，它们不能访问可能会在运行时改变的变量，否则会产生编译错误。