Java的lambda表达式

Java中的lambda表达式是一种匿名函数；它是一种没有声明名称的方法，但我们可以作为参数传递，或者将其赋给一个变量。Lambda表达式是Java 8引入的一个关键特性，它使得我们能够以函数式风格编写代码。Lambda表达式可以简化代码，特别是当使用函数式接口时。

函数式接口(Functional Interface)

在了解lambda表达式之前，我们需要先了解函数式接口的概念。函数式接口是只有一个抽象方法的接口。Java的java.util.function包下提供了多种函数式接口。例如，java.util.function.Predicate<T> 是一个标准的函数式接口，它表示接受一个输入参数并返回布尔值的函数。我们可以为这样的接口提供一个lambda表达式。

Lambda表达式的语法

Lambda表达式的基本语法如下：

(parameters) -> expression

或者

(parameters) -> { statements; }

• parameters：这可以是一个参数或参数列表，就像定义方法一样，类型可以省略，因为编译器可以从上下文推断出类型。
• ->：这是lambda表达式的语法，用来分隔参数和lambda体。
• expression：表达式部分可以是一个表达式或一个代码块。如果是一个表达式，那么lambda表达式的结果就是该表达式的结果。如果是一系列语句，则必须用花括号括起来。

示例

下面是一些使用lambda表达式的例子。

1. 无参数的Lambda表达式：

() -> System.out.println("Hello, World!");

2. 一个参数的Lambda表达式：

如果只有一个参数，可以省略参数的括号。

str -> str.length()

3. 多个参数的Lambda表达式：

(int a, int b) -> a + b

4. Lambda表达式作为一个接口的实现：

// 假设有一个函数式接口如下
@FunctionalInterface
interface MathOperation {
    int operation(int a, int b);
}

// 我们可以这样使用lambda表达式
MathOperation addition = (a, b) -> a + b;
MathOperation subtraction = (a, b) -> a - b;

使用Lambda表达式

Lambda表达式通常与集合一起使用，尤其是在java.util.Stream API中。例如，我们可以在集合上执行过滤、排序和映射等操作。

List<String> names = Arrays.asList("John", "Jane", "Doe", "Sarah");

// 使用lambda表达式进行过滤
List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("J"))
                                  .collect(Collectors.toList());

// 使用lambda表达式进行排序
List<String> sortedNames = names.stream()
                                .sorted((a, b) -> a.compareTo(b))
                                .collect(Collectors.toList());

Lambda表达式可以使代码更加简洁和可读，但也要注意不要过度使用，因为在一些复杂的情况下，使用传统的方法可能会更清晰。



 

下面是一些Java lambda表达式的额外例子，展示了如何在不同的上下文中使用它们。

1. 使用Lambda表达式进行集合迭代

使用forEach方法遍历集合，而不是使用传统的for循环。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
numbers.forEach(n -> System.out.println(n));

2. 使用Lambda表达式和Thread类

创建一个新线程而不需要创建一个实现Runnable接口的匿名类。

new Thread(() -> {
    System.out.println("新线程运行代码");
}).start();

3. 使用Lambda表达式实现Comparator接口

对集合进行排序。

List<String> cities = Arrays.asList("London", "Sydney", "New York", "Amsterdam");

Collections.sort(cities, (s1, s2) -> s1.compareTo(s2));

// 或者使用Comparator的更简洁形式
cities.sort(String::compareTo);

4. 使用Lambda表达式替代事件监听器

在编写图形用户界面(GUI)时，可以简化事件处理代码。

JButton show = new JButton("Show");
show.addActionListener(e -> System.out.println("Button clicked!"));

5. 使用Lambda表达式与map和reduce操作

在Stream操作中，进行转换和聚合。

List<Integer> values = Arrays.asList(1, 2, 3, 4, 5);

int sum = values.stream()
                .map(n -> n * 2) // 先将每个数字乘以2
                .reduce(0, (c, n) -> c + n); // 然后计算它们的和

System.out.println(sum); // 输出结果为30

6. 使用Lambda表达式处理异常

使用Lambda表达式时捕获异常。

Consumer<Integer> handler = n -> {
    try {
        if (n % 2 != 0) {
            throw new IllegalArgumentException("不是偶数: " + n);
        }
        System.out.println(n);
    } catch (IllegalArgumentException e) {
        System.err.println(e.getMessage());
    }
};

numbers.forEach(handler);

7. 使用Lambda表达式实现工厂模式

interface AbstractFactory<T> {
    T create(String type);
}

class ProductFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A": return new ProductA();
            case "B": return new ProductB();
            default: throw new IllegalArgumentException("Unknown product type");
        }
    }
}

AbstractFactory<Product> factory = ProductFactory::createProduct;
Product productA = factory.create("A");
Product productB = factory.create("B");

这些例子展示了lambda表达式的多样性，它们可以用来简化代码，使其看起来更清爽并且易于理解。在实际开发中，lambda表达式是一个非常强大的工具，可以用来实现各种功能，包括那些要求函数式编程风格的操作。



 

下面有一些完整的且可以正常运行的Java lambda表达式示例。

示例 1: 使用Lambda表达式对列表进行排序

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

public class LambdaSortExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Steve", "Peter", "James", "Maria", "Jane");

        // 使用Lambda表达式按字典顺序排序
        Collections.sort(names, (String a, String b) -> a.compareTo(b));

        // 打印排序后的列表
        names.forEach(System.out::println);
    }
}

示例 2: 使用Lambda表达式创建线程

public class ThreadExample {
    public static void main(String[] args) {
        // 使用Lambda表达式创建一个线程并运行
        new Thread(() -> System.out.println("线程执行！")).start();
    }
}

示例 3: 使用Lambda表达式实现事件监听器

这个例子是用于创建一个简单的GUI窗口，并为按钮添加一个事件监听器。

import javax.swing.JButton;
import javax.swing.JFrame;

public class EventListenerExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Lambda Event Listener Example");
        JButton button = new JButton("Click Me!");

        // 添加事件监听器
        button.addActionListener(e -> System.out.println("按钮被点击了！"));

        frame.add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

为了运行上述的GUI示例，你需要在一个支持Swing的环境中运行它，比如说在安装了Java的桌面操作系统上。

示例 4: 使用Lambda表达式和Stream API

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamFilterExample {
    public static void main(String[] args) {
        List<String> lines = Arrays.asList("spring", "node", "mkyong");

        // 使用Lambda表达式过滤出包含"spring"的字符串
        List<String> result = lines.stream()                // 转换成Stream
                                   .filter(line -> !"mkyong".equals(line)) // 过滤
                                   .collect(Collectors.toList());           // 转换成List

        // 打印过滤后的结果
        result.forEach(System.out::println); // 输出spring和node
    }
}

示例 5: 使用Lambda表达式计算列表元素的平方和

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

public class SquareSumExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // 计算列表元素的平方和
        int squareSum = numbers.stream()
                               .mapToInt(n -> n * n)
                               .sum();

        System.out.println(squareSum); // 输出55
    }
}

每个示例都是自包含的，并且可以直接复制到Java文件中运行，前提是你已经安装了相应版本的Java开发环境。例如，对于Swing示例，你需要一个支持Swing的桌面环境，而对于其他示例，任何标准的Java环境都可以运行。