Java 8 新特性： Lambda 表达式

Lambda 表达式是 Java 8 中引入的最重要的新特性之一。它使得代码更加简洁紧凑，并且让 Java 也开始支持简单的函数式编程。Lambda 表达式可以看作是匿名函数，它允许将函数作为参数传递给方法，从而极大地简化了代码。

语法格式

Lambda 表达式的基本语法格式为：

(parameters) -> expression

或者

(parameters) -> { statements; }

Lambda 实战

通过一些常见的实例，我们可以更直观地感受 Lambda 表达式带来的便利。

替代匿名内部类

在 Java 8 之前，给方法传递动态参数的唯一方式是使用匿名内部类。下面我们通过几个例子展示如何使用 Lambda 表达式替代匿名内部类。

1. Runnable 接口

传统的匿名内部类实现方式：

java

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("The runnable now is using!");
    }
}).start();

使用 Lambda 表达式：

java

new Thread(() -> System.out.println("It's a lambda function!")).start();

2. Comparator 接口

传统的匿名内部类实现方式：

java

List<Integer> numbers = Arrays.asList(3, 2, 1);
Collections.sort(numbers, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2;
    }
});

使用 Lambda 表达式：

java

List<Integer> numbers = Arrays.asList(3, 2, 1);
Collections.sort(numbers, (Integer o1, Integer o2) -> o1 - o2);

分解开：

java

Comparator<Integer> comparator = (Integer o1, Integer o2) -> o1 - o2;
Collections.sort(numbers, comparator);

3. Listener 接口

传统的匿名内部类实现方式：

java

JButton button = new JButton();
button.addItemListener(new ItemListener() {
    @Override
    public void itemStateChanged(ItemEvent e) {
        e.getItem();
    }
});

使用 Lambda 表达式：

java

button.addItemListener(e -> e.getItem());

4. 自定义接口

我们可以自定义一个函数式接口，并使用 Lambda 表达式来实现它。

java

@FunctionalInterface
public interface LambdaInterface {
    void f();
}

public class LambdaClass {
    public static void forEg() {
        lambdaInterfaceDemo(() -> System.out.println("自定义函数式接口"));
    }

    // 函数式接口参数
    static void lambdaInterfaceDemo(LambdaInterface i) {
        i.f();
    }
}

函数式接口

上面的例子中我们提到，Lambda 表达式可以用于实现函数式接口。函数式接口是只包含一个抽象方法的接口。在 Java 8 中，所有的函数式接口都可以使用 Lambda 表达式来实现。

Java 8 引入了 @FunctionalInterface 注解，用于标记一个接口为函数式接口。尽管不使用这个注解，接口仍然可以被当作函数式接口，但使用这个注解可以更明确地表明意图，并且在编译时如果接口不符合函数式接口的定义，编译器会报错。

例如：

java

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

@FunctionalInterface
public interface Runnable {
    void run();
}

实际应用场景

Lambda 表达式在实际开发中有广泛的应用场景，以下是几个典型的使用场景：

集合操作

使用 Lambda 表达式可以方便地对集合进行操作，例如排序、过滤等。

java

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("A"))
    .collect(Collectors.toList());

filteredNames.forEach(System.out::println);

多线程编程

使用 Lambda 表达式可以更简洁地创建和运行线程：

java

new Thread(() -> System.out.println("Running in a thread")).start();

事件处理

在 GUI 编程中，使用 Lambda 表达式可以简化事件处理代码：

java

JButton button = new JButton("Click me");
button.addActionListener(e -> System.out.println("Button clicked"));

Lambda 表达式的演进过程

Lambda 表达式的引入和演进是 Java 语言发展的一个重要里程碑。它的出现使得 Java 在表达函数式编程方面更加简洁和高效。了解 Lambda 表达式的演进过程，有助于我们更好地理解其设计背后的思想和实现原理。

初期：匿名内部类

在 Java 8 之前，实现某些功能需要创建匿名内部类。匿名内部类虽然能够实现一些简单的功能，但代码非常冗长，不够简洁直观。

例如，实现一个简单的 Runnable 接口：

java

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in a thread");
    }
}).start();

这种方式虽然可行，但代码显得非常冗长。尤其是在需要频繁使用时，代码的可读性和可维护性都不高。

Lambda 表达式引入

为了简化代码，Java 8 引入了 Lambda 表达式。Lambda 表达式是一种匿名函数，可以直接传递行为而不是对象。它使得代码更加简洁。

上述 Runnable 接口的实现，可以简化为：

java

new Thread(() -> System.out.println("Running in a thread")).start();

函数式接口

Lambda 表达式的一个重要特点是它依赖于函数式接口。函数式接口是只包含一个抽象方法的接口。这使得 Lambda 表达式可以与现有的 Java 接口兼容。

例如，Java 8 引入了 @FunctionalInterface 注解，用于标记一个接口为函数式接口：

java

@FunctionalInterface
public interface Runnable {
    void run();
}

在使用 Lambda 表达式时，编译器会自动推断出相应的函数式接口。例如：

java

Runnable r = () -> System.out.println("Running in a thread");

方法引用

Java 8 还引入了方法引用(Method References)，它是 Lambda 表达式的语法糖，用于简化 Lambda 表达式的写法。方法引用有四种主要类型：

1. 引用静态方法
2. 引用某个对象的实例方法
3. 引用某个类型的任意对象的实例方法
4. 引用构造器

例如：

java

// 引用静态方法
Function<String, Integer> func = Integer::parseInt;

// 引用某个对象的实例方法
String str = "Hello";
Supplier<String> supplier = str::toUpperCase;

// 引用某个类型的任意对象的实例方法
Function<String, String> func2 = String::toUpperCase;

// 引用构造器
Supplier<List<String>> listSupplier = ArrayList::new;

Stream API

Java 8 引入了 Stream API，与 Lambda 表达式结合使用，可以极大地简化集合操作。Stream API 提供了一种高效且易于使用的方式来处理集合数据。

例如，对一个集合进行过滤、转换和收集操作：

java

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> filteredNames = names.stream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

filteredNames.forEach(System.out::println);

源码解读

Lambda 表达式的实现

在 Java 8 中，Lambda 表达式的实现实际上是通过动态生成的类来实现的。Java 编译器在编译 Lambda 表达式时，会生成一个私有静态方法，并通过 invokedynamic 指令来动态生成一个类实现相应的函数式接口。

具体的实现机制可以通过以下示例来理解：

java

public class LambdaDemo {
    public static void main(String[] args) {
        Runnable r = () -> System.out.println("Running in a thread");
        r.run();
    }
}

编译上述代码后，可以使用 javap 工具查看生成的字节码：

javap -c LambdaDemo

会看到类似如下的字节码指令：

plaintext

public static void main(java.lang.String[]);
  Code:
     0: invokedynamic #2,  0             // InvokeDynamic #0:run:()Ljava/lang/Runnable;
     5: astore_1
     6: aload_1
     7: invokeinterface #3,  1           // InterfaceMethod java/lang/Runnable.run:()V
    12: return

在字节码中可以看到使用了 invokedynamic 指令，它会在运行时动态生成一个实现 Runnable 接口的类，并将 Lambda 表达式的逻辑放入这个类的 run 方法中。

结论

Lambda 表达式是 Java 8 中一个非常重要的新特性，它使得代码更加简洁紧凑，并且让 Java 也开始支持简单的函数式编程。通过 Lambda 表达式，我们可以更加方便地操作集合、创建和运行线程以及处理事件。