Java-lambda表达式各种应用场景总结

一、应用场景说明

Lambda 表达式是 Java 8 引入的一种语法特性，它允许你以更紧凑的方式表示匿名函数或代码块。Lambda 表达式主要用于函数式编程和简化代码，它在多种场景下都能发挥作用。以下是 Java 中 Lambda 表达式的主要用法总结：

1. 函数式接口： Lambda 表达式最常见的用法是创建函数式接口的实例。函数式接口是只包含一个抽象方法的接口，Lambda 表达式可以作为这个抽象方法的实现。
2. 匿名函数： Lambda 表达式允许你以更简洁的方式创建匿名函数，避免了传统匿名内部类的冗长语法。
3. 传递行为： Lambda 表达式可以作为参数传递给方法，这样你可以在调用方法时指定不同的行为。
4. 集合操作： Lambda 表达式常用于集合操作，例如使用 forEach 遍历集合、使用 filter 过滤元素、使用 map 转换元素等。
5. 排序和比较： Lambda 表达式可以用于自定义排序和比较规则，例如使用 Comparator 接口。
6. 并行和多线程： Lambda 表达式在并行流和多线程编程中发挥重要作用，可以更容易地编写并发代码。
7. 事件处理： Lambda 表达式可以用于事件处理，例如 GUI 应用程序中的按钮点击事件。
8. 替代策略模式： Lambda 表达式可以替代传统的策略模式，使代码更加简洁。
9. 延迟执行： Lambda 表达式可以实现延迟执行，例如在某个条件满足时才执行代码。
10. 简化回调： 使用 Lambda 表达式可以简化回调函数的定义和传递。
11. 流式编程： Lambda 表达式与 Java 流式编程结合，可以实现链式的数据处理和转换。

这些只是 Lambda 表达式的一些常见用法。通过使用 Lambda 表达式，你可以编写更简洁、更具可读性的代码，并且在函数式编程范式中更自然地表达逻辑。请注意，在使用 Lambda 表达式时需要了解参数列表、箭头操作符和代码块的语法结构。

二、举例对比各个场景下使用前后区别

1. 函数式接口：

• 使用 Lambda 之前（使用匿名内部类）：

interface MyInterface {
    void doSomething();
}

MyInterface myObj = new MyInterface() {
    public void doSomething() {
        System.out.println("Doing something.");
    }
};

• 使用 Lambda 之后：

MyInterface myObj = () -> System.out.println("Doing something.");

• 区别：使用 Lambda 表达式可以更紧凑地定义接口实例，避免了冗长的匿名内部类语法。

2. 匿名函数：

• 使用 Lambda 之前：

Runnable runnable = new Runnable() {
    public void run() {
        System.out.println("Running...");
    }
};

• 使用 Lambda 之后：

Runnable runnable = () -> System.out.println("Running...");

• 区别：Lambda 表达式更清晰地表示了匿名函数的逻辑，减少了样板代码。

3. 传递行为：
   -使用 Lambda 之前：

public void process(Action action) {
    action.execute();
}

Action action = new Action() {
    public void execute() {
        System.out.println("Action executed.");
    }
};

process(action);

• 使用 Lambda 之后：

public void process(Action action) {
    action.execute();
}

process(() -> System.out.println("Action executed."));

• 区别：Lambda 表达式允许你直接在方法调用时传递行为，使代码更简洁。

4. 集合操作：

• 使用 Lambda 之前：

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

for (Integer number : numbers) {
    System.out.println(number);
}

• 使用 Lambda 之后：

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

numbers.forEach(number -> System.out.println(number));

• 区别：Lambda 表达式可以将集合操作的逻辑内联，使代码更紧凑。

5. 排序和比较：

• 使用 Lambda 之前：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

Collections.sort(names, new Comparator<String>() {
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});

• 使用 Lambda 之后：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

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

区别：Lambda 表达式使排序和比较逻辑更紧凑、更可读。

6. 并行和多线程：

• 使用 Lambda 之前：

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(new Runnable() {
    public void run() {
        System.out.println("Task executed.");
    }
});

• 使用 Lambda 之后：

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> System.out.println("Task executed."));

区别：Lambda 表达式使多线程代码更加简洁，同时支持并行和异步任务。

7. 事件处理：

• 使用 Lambda 之前：

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked.");
    }
});

• 使用 Lambda 之后：

button.addActionListener(e -> System.out.println("Button clicked."));

区别：Lambda 表达式使事件处理逻辑更直观，减少了样板代码。

8. 替代策略模式：

• 使用 Lambda 之前：

Validator validator = new Validator() {
    public boolean isValid(String input) {
        return input != null && !input.isEmpty();
    }
};

• 使用 Lambda 之后：

Validator validator = input -> input != null && !input.isEmpty();

区别：Lambda 表达式简化了策略模式的实现，使代码更加简洁。

9. 延迟执行：

• 使用 Lambda 之前：

if (condition) {
    executeDelayedTask(new Runnable() {
        public void run() {
            System.out.println("Delayed task executed.");
        }
    });
}

• 使用 Lambda 之后：

if (condition) {
    executeDelayedTask(() -> System.out.println("Delayed task executed."));
}

区别：Lambda 表达式使延迟执行代码更紧凑。

10. 简化回调：

• 使用 Lambda 之前：

performOperation(new Callback() {
    public void onSuccess() {
        System.out.println("Operation succeeded.");
    }
    
    public void onFailure() {
        System.out.println("Operation failed.");
    }
});

• 使用 Lambda 之后：

performOperation(() -> System.out.println("Operation succeeded."),
                 () -> System.out.println("Operation failed."));

区别：Lambda 表达式使回调函数更简洁，减少了冗余代码。

11. 流式编程：
    -使用 Lambda 之前：

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

int sum = 0;
for (int number : numbers) {
    sum += number;
}

• 使用 Lambda 之后：

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

int sum = numbers.stream().reduce(0, (x, y) -> x + y);

区别：Lambda 表达式与流式编程结合，使数据处理更加简洁、函数式。

总的来说，Lambda 表达式能够显著减少冗长的代码，提高代码的可读性和可维护性，同时支持函数式编程风格，使代码更加优雅和灵活。